izzy/xemu
0
0
Fork 0
mirror of https://github.com/izzy2lost/xemu.git synced 2026-07-06 00:20:22 -07:00
Code Issues Packages Projects Releases Wiki Activity

m68k comments break patch submission due to being incorrectly formatted

Browse Source 
Altering all comments in target/m68k to match Qemu coding styles so that future
patches wont fail due to style breaches.

Signed-off-by: Lucien Murray-Pitts <lucienmp.qemu@gmail.com>
Reviewed-by: Laurent Vivier <laurent@vivier.eu>
Message-Id: <20190606234125.GA4830@localhost.localdomain>
Signed-off-by: Laurent Vivier <laurent@vivier.eu>
This commit is contained in:
Lucien Murray-Pitts
2019-06-26 17:14:39 +02:00
committed by Laurent Vivier
parent bf1fa6912d
commit 808d77bc5f
12 changed files with 353 additions and 227 deletions
Download Patch File Download Diff File Expand all files Collapse all files
target/m68k/cpu-qom.h
+1 -1
View File
@@ -31,7 +31,7 @@
#define M68K_CPU_GET_CLASS(obj) \
OBJECT_GET_CLASS(M68kCPUClass, (obj), TYPE_M68K_CPU)
/**
/*
* M68kCPUClass:
* @parent_realize: The parent class' realize handler.
* @parent_reset: The parent class' reset handler.
target/m68k/cpu.c
+4 -2
View File
@@ -203,8 +203,10 @@ static void any_cpu_initfn(Object *obj)
m68k_set_feature(env, M68K_FEATURE_CF_ISA_APLUSC);
m68k_set_feature(env, M68K_FEATURE_BRAL);
m68k_set_feature(env, M68K_FEATURE_CF_FPU);
/* MAC and EMAC are mututally exclusive, so pick EMAC.
It's mostly backwards compatible. */
/*
* MAC and EMAC are mututally exclusive, so pick EMAC.
* It's mostly backwards compatible.
*/
m68k_set_feature(env, M68K_FEATURE_CF_EMAC);
m68k_set_feature(env, M68K_FEATURE_CF_EMAC_B);
m68k_set_feature(env, M68K_FEATURE_USP);
target/m68k/cpu.h
+18 -11
View File
@@ -106,9 +106,11 @@ typedef struct CPUM68KState {
float_status fp_status;
uint64_t mactmp;
/* EMAC Hardware deals with 48-bit values composed of one 32-bit and
two 8-bit parts. We store a single 64-bit value and
rearrange/extend this when changing modes. */
/*
* EMAC Hardware deals with 48-bit values composed of one 32-bit and
* two 8-bit parts. We store a single 64-bit value and
* rearrange/extend this when changing modes.
*/
uint64_t macc[4];
uint32_t macsr;
uint32_t mac_mask;
@@ -146,7 +148,7 @@ typedef struct CPUM68KState {
uint32_t features;
} CPUM68KState;
/**
/*
* M68kCPU:
* @env: #CPUM68KState
*
@@ -171,9 +173,11 @@ int m68k_cpu_gdb_write_register(CPUState *cpu, uint8_t *buf, int reg);
void m68k_tcg_init(void);
void m68k_cpu_init_gdb(M68kCPU *cpu);
/* you can call this signal handler from your SIGBUS and SIGSEGV
signal handlers to inform the virtual CPU of exceptions. non zero
is returned if the signal was handled by the virtual CPU. */
/*
* you can call this signal handler from your SIGBUS and SIGSEGV
* signal handlers to inform the virtual CPU of exceptions. non zero
* is returned if the signal was handled by the virtual CPU.
*/
int cpu_m68k_signal_handler(int host_signum, void *pinfo,
void *puc);
uint32_t cpu_m68k_get_ccr(CPUM68KState *env);
@@ -182,7 +186,8 @@ void cpu_m68k_set_sr(CPUM68KState *env, uint32_t);
void cpu_m68k_set_fpcr(CPUM68KState *env, uint32_t val);
/* Instead of computing the condition codes after each m68k instruction,
/*
* Instead of computing the condition codes after each m68k instruction,
* QEMU just stores one operand (called CC_SRC), the result
* (called CC_DEST) and the type of operation (called CC_OP). When the
* condition codes are needed, the condition codes can be calculated
@@ -447,9 +452,11 @@ void m68k_switch_sp(CPUM68KState *env);
void do_m68k_semihosting(CPUM68KState *env, int nr);
/* There are 4 ColdFire core ISA revisions: A, A+, B and C.
Each feature covers the subset of instructions common to the
ISA revisions mentioned. */
/*
* There are 4 ColdFire core ISA revisions: A, A+, B and C.
* Each feature covers the subset of instructions common to the
* ISA revisions mentioned.
*/
enum m68k_features {
M68K_FEATURE_M68000,
target/m68k/fpu_helper.c
+4 -2
View File
@@ -25,7 +25,8 @@
#include "exec/cpu_ldst.h"
#include "softfloat.h"
/* Undefined offsets may be different on various FPU.
/*
* Undefined offsets may be different on various FPU.
* On 68040 they return 0.0 (floatx80_zero)
*/
@@ -611,7 +612,8 @@ void HELPER(fcos)(CPUM68KState *env, FPReg *res, FPReg *val)
void HELPER(fsincos)(CPUM68KState *env, FPReg *res0, FPReg *res1, FPReg *val)
{
floatx80 a = val->d;
/* If res0 and res1 specify the same floating-point data register,
/*
* If res0 and res1 specify the same floating-point data register,
* the sine result is stored in the register, and the cosine
* result is discarded.
*/
target/m68k/gdbstub.c
+4 -2
View File
@@ -41,8 +41,10 @@ int m68k_cpu_gdb_read_register(CPUState *cs, uint8_t *mem_buf, int n)
return gdb_get_reg32(mem_buf, env->pc);
}
}
/* FP registers not included here because they vary between
ColdFire and m68k. Use XML bits for these. */
/*
* FP registers not included here because they vary between
* ColdFire and m68k. Use XML bits for these.
*/
return 0;
}
target/m68k/helper.c
+10 -6
View File
@@ -965,9 +965,11 @@ void HELPER(set_sr)(CPUM68KState *env, uint32_t val)
}
/* MAC unit. */
/* FIXME: The MAC unit implementation is a bit of a mess. Some helpers
take values, others take register numbers and manipulate the contents
in-place. */
/*
* FIXME: The MAC unit implementation is a bit of a mess. Some helpers
* take values, others take register numbers and manipulate the contents
* in-place.
*/
void HELPER(mac_move)(CPUM68KState *env, uint32_t dest, uint32_t src)
{
uint32_t mask;
@@ -1047,9 +1049,11 @@ void HELPER(macsats)(CPUM68KState *env, uint32_t acc)
if (env->macsr & MACSR_V) {
env->macsr |= MACSR_PAV0 << acc;
if (env->macsr & MACSR_OMC) {
/* The result is saturated to 32 bits, despite overflow occurring
at 48 bits. Seems weird, but that's what the hardware docs
say. */
/*
* The result is saturated to 32 bits, despite overflow occurring
* at 48 bits. Seems weird, but that's what the hardware docs
* say.
*/
result = (result >> 63) ^ 0x7fffffff;
}
}
target/m68k/m68k-semi.c
+16 -8
View File
@@ -130,7 +130,8 @@ static void m68k_semi_return_u32(CPUM68KState *env, uint32_t ret, uint32_t err)
target_ulong args = env->dregs[1];
if (put_user_u32(ret, args) ||
put_user_u32(err, args + 4)) {
/* The m68k semihosting ABI does not provide any way to report this
/*
* The m68k semihosting ABI does not provide any way to report this
* error to the guest, so the best we can do is log it in qemu.
* It is always a guest error not to pass us a valid argument block.
*/
@@ -159,8 +160,10 @@ static void m68k_semi_cb(CPUState *cs, target_ulong ret, target_ulong err)
CPUM68KState *env = &cpu->env;
if (m68k_semi_is_fseek) {
/* FIXME: We've already lost the high bits of the fseek
return value. */
/*
* FIXME: We've already lost the high bits of the fseek
* return value.
*/
m68k_semi_return_u64(env, ret, err);
m68k_semi_is_fseek = 0;
} else {
@@ -168,7 +171,8 @@ static void m68k_semi_cb(CPUState *cs, target_ulong ret, target_ulong err)
}
}
/* Read the input value from the argument block; fail the semihosting
/*
* Read the input value from the argument block; fail the semihosting
* call if the memory read fails.
*/
#define GET_ARG(n) do { \
@@ -440,14 +444,18 @@ void do_m68k_semihosting(CPUM68KState *env, int nr)
}
ts->heap_limit = base + size;
}
/* This call may happen before we have writable memory, so return
values directly in registers. */
/*
* This call may happen before we have writable memory, so return
* values directly in registers.
*/
env->dregs[1] = ts->heap_limit;
env->aregs[7] = ts->stack_base;
}
#else
/* FIXME: This is wrong for boards where RAM does not start at
address zero. */
/*
* FIXME: This is wrong for boards where RAM does not start at
* address zero.
*/
env->dregs[1] = ram_size;
env->aregs[7] = ram_size;
#endif
target/m68k/op_helper.c
+37 -21
View File
@@ -494,10 +494,12 @@ bool m68k_cpu_exec_interrupt(CPUState *cs, int interrupt_request)
if (interrupt_request & CPU_INTERRUPT_HARD
&& ((env->sr & SR_I) >> SR_I_SHIFT) < env->pending_level) {
/* Real hardware gets the interrupt vector via an IACK cycle
at this point. Current emulated hardware doesn't rely on
this, so we provide/save the vector when the interrupt is
first signalled. */
/*
* Real hardware gets the interrupt vector via an IACK cycle
* at this point. Current emulated hardware doesn't rely on
* this, so we provide/save the vector when the interrupt is
* first signalled.
*/
cs->exception_index = env->pending_vector;
do_interrupt_m68k_hardirq(env);
return true;
@@ -537,7 +539,8 @@ void HELPER(divuw)(CPUM68KState *env, int destr, uint32_t den)
env->cc_c = 0; /* always cleared, even if overflow */
if (quot > 0xffff) {
env->cc_v = -1;
/* real 68040 keeps N and unset Z on overflow,
/*
* real 68040 keeps N and unset Z on overflow,
* whereas documentation says "undefined"
*/
env->cc_z = 1;
@@ -564,7 +567,8 @@ void HELPER(divsw)(CPUM68KState *env, int destr, int32_t den)
if (quot != (int16_t)quot) {
env->cc_v = -1;
/* nothing else is modified */
/* real 68040 keeps N and unset Z on overflow,
/*
* real 68040 keeps N and unset Z on overflow,
* whereas documentation says "undefined"
*/
env->cc_z = 1;
@@ -647,7 +651,8 @@ void HELPER(divull)(CPUM68KState *env, int numr, int regr, uint32_t den)
env->cc_c = 0; /* always cleared, even if overflow */
if (quot > 0xffffffffULL) {
env->cc_v = -1;
/* real 68040 keeps N and unset Z on overflow,
/*
* real 68040 keeps N and unset Z on overflow,
* whereas documentation says "undefined"
*/
env->cc_z = 1;
@@ -681,7 +686,8 @@ void HELPER(divsll)(CPUM68KState *env, int numr, int regr, int32_t den)
env->cc_c = 0; /* always cleared, even if overflow */
if (quot != (int32_t)quot) {
env->cc_v = -1;
/* real 68040 keeps N and unset Z on overflow,
/*
* real 68040 keeps N and unset Z on overflow,
* whereas documentation says "undefined"
*/
env->cc_z = 1;
@@ -838,14 +844,18 @@ static struct bf_data bf_prep(uint32_t addr, int32_t ofs, uint32_t len)
addr -= 1;
}
/* Compute the number of bytes required (minus one) to
satisfy the bitfield. */
/*
* Compute the number of bytes required (minus one) to
* satisfy the bitfield.
*/
blen = (bofs + len - 1) / 8;
/* Canonicalize the bit offset for data loaded into a 64-bit big-endian
word. For the cases where BLEN is not a power of 2, adjust ADDR so
that we can use the next power of two sized load without crossing a
page boundary, unless the field itself crosses the boundary. */
/*
* Canonicalize the bit offset for data loaded into a 64-bit big-endian
* word. For the cases where BLEN is not a power of 2, adjust ADDR so
* that we can use the next power of two sized load without crossing a
* page boundary, unless the field itself crosses the boundary.
*/
switch (blen) {
case 0:
bofs += 56;
@@ -937,8 +947,10 @@ uint64_t HELPER(bfextu_mem)(CPUM68KState *env, uint32_t addr,
struct bf_data d = bf_prep(addr, ofs, len);
uint64_t data = bf_load(env, d.addr, d.blen, ra);
/* Put CC_N at the top of the high word; put the zero-extended value
at the bottom of the low word. */
/*
* Put CC_N at the top of the high word; put the zero-extended value
* at the bottom of the low word.
*/
data <<= d.bofs;
data >>= 64 - d.len;
data |= data << (64 - d.len);
@@ -1016,15 +1028,18 @@ uint64_t HELPER(bfffo_mem)(CPUM68KState *env, uint32_t addr,
uint64_t n = (data & mask) << d.bofs;
uint32_t ffo = helper_bfffo_reg(n >> 32, ofs, d.len);
/* Return FFO in the low word and N in the high word.
Note that because of MASK and the shift, the low word
is already zero. */
/*
* Return FFO in the low word and N in the high word.
* Note that because of MASK and the shift, the low word
* is already zero.
*/
return n | ffo;
}
void HELPER(chk)(CPUM68KState *env, int32_t val, int32_t ub)
{
/* From the specs:
/*
* From the specs:
* X: Not affected, C,V,Z: Undefined,
* N: Set if val < 0; cleared if val > ub, undefined otherwise
* We implement here values found from a real MC68040:
@@ -1054,7 +1069,8 @@ void HELPER(chk)(CPUM68KState *env, int32_t val, int32_t ub)
void HELPER(chk2)(CPUM68KState *env, int32_t val, int32_t lb, int32_t ub)
{
/* From the specs:
/*
* From the specs:
* X: Not affected, N,V: Undefined,
* Z: Set if val is equal to lb or ub
* C: Set if val < lb or val > ub, cleared otherwise
target/m68k/softfloat.c
+94 -87
View File
@@ -14,7 +14,8 @@
* the Softfloat-2a license unless specifically indicated otherwise.
*/
/* Portions of this work are licensed under the terms of the GNU GPL,
/*
* Portions of this work are licensed under the terms of the GNU GPL,
* version 2 or later. See the COPYING file in the top-level directory.
*/
@@ -41,10 +42,10 @@ static floatx80 propagateFloatx80NaNOneArg(floatx80 a, float_status *status)
return a;
}
/*----------------------------------------------------------------------------
| Returns the modulo remainder of the extended double-precision floating-point
| value `a' with respect to the corresponding value `b'.
*----------------------------------------------------------------------------*/
/*
* Returns the modulo remainder of the extended double-precision floating-point
* value `a' with respect to the corresponding value `b'.
*/
floatx80 floatx80_mod(floatx80 a, floatx80 b, float_status *status)
{
@@ -124,10 +125,10 @@ floatx80 floatx80_mod(floatx80 a, floatx80 b, float_status *status)
80, zSign, bExp + expDiff, aSig0, aSig1, status);
}
/*----------------------------------------------------------------------------
| Returns the mantissa of the extended double-precision floating-point
| value `a'.
*----------------------------------------------------------------------------*/
/*
* Returns the mantissa of the extended double-precision floating-point
* value `a'.
*/
floatx80 floatx80_getman(floatx80 a, float_status *status)
{
@@ -158,10 +159,10 @@ floatx80 floatx80_getman(floatx80 a, float_status *status)
0x3FFF, aSig, 0, status);
}
/*----------------------------------------------------------------------------
| Returns the exponent of the extended double-precision floating-point
| value `a' as an extended double-precision value.
*----------------------------------------------------------------------------*/
/*
* Returns the exponent of the extended double-precision floating-point
* value `a' as an extended double-precision value.
*/
floatx80 floatx80_getexp(floatx80 a, float_status *status)
{
@@ -191,13 +192,13 @@ floatx80 floatx80_getexp(floatx80 a, float_status *status)
return int32_to_floatx80(aExp - 0x3FFF, status);
}
/*----------------------------------------------------------------------------
| Scales extended double-precision floating-point value in operand `a' by
| value `b'. The function truncates the value in the second operand 'b' to
| an integral value and adds that value to the exponent of the operand 'a'.
| The operation performed according to the IEC/IEEE Standard for Binary
| Floating-Point Arithmetic.
*----------------------------------------------------------------------------*/
/*
* Scales extended double-precision floating-point value in operand `a' by
* value `b'. The function truncates the value in the second operand 'b' to
* an integral value and adds that value to the exponent of the operand 'a'.
* The operation performed according to the IEC/IEEE Standard for Binary
* Floating-Point Arithmetic.
*/
floatx80 floatx80_scale(floatx80 a, floatx80 b, float_status *status)
{
@@ -282,26 +283,26 @@ floatx80 floatx80_move(floatx80 a, float_status *status)
aExp, aSig, 0, status);
}
/*----------------------------------------------------------------------------
| Algorithms for transcendental functions supported by MC68881 and MC68882
| mathematical coprocessors. The functions are derived from FPSP library.
*----------------------------------------------------------------------------*/
/*
* Algorithms for transcendental functions supported by MC68881 and MC68882
* mathematical coprocessors. The functions are derived from FPSP library.
*/
#define one_exp 0x3FFF
#define one_sig LIT64(0x8000000000000000)
/*----------------------------------------------------------------------------
| Function for compactifying extended double-precision floating point values.
*----------------------------------------------------------------------------*/
/*
* Function for compactifying extended double-precision floating point values.
*/
static int32_t floatx80_make_compact(int32_t aExp, uint64_t aSig)
{
return (aExp << 16) | (aSig >> 48);
}
/*----------------------------------------------------------------------------
| Log base e of x plus 1
*----------------------------------------------------------------------------*/
/*
* Log base e of x plus 1
*/
floatx80 floatx80_lognp1(floatx80 a, float_status *status)
{
@@ -498,9 +499,9 @@ floatx80 floatx80_lognp1(floatx80 a, float_status *status)
}
}
/*----------------------------------------------------------------------------
| Log base e
*----------------------------------------------------------------------------*/
/*
* Log base e
*/
floatx80 floatx80_logn(floatx80 a, float_status *status)
{
@@ -666,9 +667,9 @@ floatx80 floatx80_logn(floatx80 a, float_status *status)
}
}
/*----------------------------------------------------------------------------
| Log base 10
*----------------------------------------------------------------------------*/
/*
* Log base 10
*/
floatx80 floatx80_log10(floatx80 a, float_status *status)
{
@@ -723,9 +724,9 @@ floatx80 floatx80_log10(floatx80 a, float_status *status)
return a;
}
/*----------------------------------------------------------------------------
| Log base 2
*----------------------------------------------------------------------------*/
/*
* Log base 2
*/
floatx80 floatx80_log2(floatx80 a, float_status *status)
{
@@ -790,9 +791,9 @@ floatx80 floatx80_log2(floatx80 a, float_status *status)
return a;
}
/*----------------------------------------------------------------------------
| e to x
*----------------------------------------------------------------------------*/
/*
* e to x
*/
floatx80 floatx80_etox(floatx80 a, float_status *status)
{
@@ -848,7 +849,8 @@ floatx80 floatx80_etox(floatx80 a, float_status *status)
j = n & 0x3F; /* J = N mod 64 */
m = n / 64; /* NOTE: this is really arithmetic right shift by 6 */
if (n < 0 && j) {
/* arithmetic right shift is division and
/*
* arithmetic right shift is division and
* round towards minus infinity
*/
m--;
@@ -973,9 +975,9 @@ floatx80 floatx80_etox(floatx80 a, float_status *status)
}
}
/*----------------------------------------------------------------------------
| 2 to x
*----------------------------------------------------------------------------*/
/*
* 2 to x
*/
floatx80 floatx80_twotox(floatx80 a, float_status *status)
{
@@ -1051,14 +1053,16 @@ floatx80 floatx80_twotox(floatx80 a, float_status *status)
j = n & 0x3F;
l = n / 64; /* NOTE: this is really arithmetic right shift by 6 */
if (n < 0 && j) {
/* arithmetic right shift is division and
/*
* arithmetic right shift is division and
* round towards minus infinity
*/
l--;
}
m = l / 2; /* NOTE: this is really arithmetic right shift by 1 */
if (l < 0 && (l & 1)) {
/* arithmetic right shift is division and
/*
* arithmetic right shift is division and
* round towards minus infinity
*/
m--;
@@ -1121,9 +1125,9 @@ floatx80 floatx80_twotox(floatx80 a, float_status *status)
}
}
/*----------------------------------------------------------------------------
| 10 to x
*----------------------------------------------------------------------------*/
/*
* 10 to x
*/
floatx80 floatx80_tentox(floatx80 a, float_status *status)
{
@@ -1200,14 +1204,16 @@ floatx80 floatx80_tentox(floatx80 a, float_status *status)
j = n & 0x3F;
l = n / 64; /* NOTE: this is really arithmetic right shift by 6 */
if (n < 0 && j) {
/* arithmetic right shift is division and
/*
* arithmetic right shift is division and
* round towards minus infinity
*/
l--;
}
m = l / 2; /* NOTE: this is really arithmetic right shift by 1 */
if (l < 0 && (l & 1)) {
/* arithmetic right shift is division and
/*
* arithmetic right shift is division and
* round towards minus infinity
*/
m--;
@@ -1274,9 +1280,9 @@ floatx80 floatx80_tentox(floatx80 a, float_status *status)
}
}
/*----------------------------------------------------------------------------
| Tangent
*----------------------------------------------------------------------------*/
/*
* Tangent
*/
floatx80 floatx80_tan(floatx80 a, float_status *status)
{
@@ -1484,9 +1490,9 @@ floatx80 floatx80_tan(floatx80 a, float_status *status)
}
}
/*----------------------------------------------------------------------------
| Sine
*----------------------------------------------------------------------------*/
/*
* Sine
*/
floatx80 floatx80_sin(floatx80 a, float_status *status)
{
@@ -1723,9 +1729,9 @@ floatx80 floatx80_sin(floatx80 a, float_status *status)
}
}
/*----------------------------------------------------------------------------
| Cosine
*----------------------------------------------------------------------------*/
/*
* Cosine
*/
floatx80 floatx80_cos(floatx80 a, float_status *status)
{
@@ -1960,9 +1966,9 @@ floatx80 floatx80_cos(floatx80 a, float_status *status)
}
}
/*----------------------------------------------------------------------------
| Arc tangent
*----------------------------------------------------------------------------*/
/*
* Arc tangent
*/
floatx80 floatx80_atan(floatx80 a, float_status *status)
{
@@ -2157,9 +2163,9 @@ floatx80 floatx80_atan(floatx80 a, float_status *status)
}
}
/*----------------------------------------------------------------------------
| Arc sine
*----------------------------------------------------------------------------*/
/*
* Arc sine
*/
floatx80 floatx80_asin(floatx80 a, float_status *status)
{
@@ -2222,9 +2228,9 @@ floatx80 floatx80_asin(floatx80 a, float_status *status)
return a;
}
/*----------------------------------------------------------------------------
| Arc cosine
*----------------------------------------------------------------------------*/
/*
* Arc cosine
*/
floatx80 floatx80_acos(floatx80 a, float_status *status)
{
@@ -2291,9 +2297,9 @@ floatx80 floatx80_acos(floatx80 a, float_status *status)
return a;
}
/*----------------------------------------------------------------------------
| Hyperbolic arc tangent
*----------------------------------------------------------------------------*/
/*
* Hyperbolic arc tangent
*/
floatx80 floatx80_atanh(floatx80 a, float_status *status)
{
@@ -2356,9 +2362,9 @@ floatx80 floatx80_atanh(floatx80 a, float_status *status)
return a;
}
/*----------------------------------------------------------------------------
| e to x minus 1
*----------------------------------------------------------------------------*/
/*
* e to x minus 1
*/
floatx80 floatx80_etoxm1(floatx80 a, float_status *status)
{
@@ -2410,7 +2416,8 @@ floatx80 floatx80_etoxm1(floatx80 a, float_status *status)
j = n & 0x3F; /* J = N mod 64 */
m = n / 64; /* NOTE: this is really arithmetic right shift by 6 */
if (n < 0 && j) {
/* arithmetic right shift is division and
/*
* arithmetic right shift is division and
* round towards minus infinity
*/
m--;
@@ -2607,9 +2614,9 @@ floatx80 floatx80_etoxm1(floatx80 a, float_status *status)
}
}
/*----------------------------------------------------------------------------
| Hyperbolic tangent
*----------------------------------------------------------------------------*/
/*
* Hyperbolic tangent
*/
floatx80 floatx80_tanh(floatx80 a, float_status *status)
{
@@ -2722,9 +2729,9 @@ floatx80 floatx80_tanh(floatx80 a, float_status *status)
}
}
/*----------------------------------------------------------------------------
| Hyperbolic sine
*----------------------------------------------------------------------------*/
/*
* Hyperbolic sine
*/
floatx80 floatx80_sinh(floatx80 a, float_status *status)
{
@@ -2811,9 +2818,9 @@ floatx80 floatx80_sinh(floatx80 a, float_status *status)
}
}
/*----------------------------------------------------------------------------
| Hyperbolic cosine
*----------------------------------------------------------------------------*/
/*
* Hyperbolic cosine
*/
floatx80 floatx80_cosh(floatx80 a, float_status *status)
{
target/m68k/softfloat.h
+2 -1
View File
@@ -14,7 +14,8 @@
* the Softfloat-2a license unless specifically indicated otherwise.
*/
/* Portions of this work are licensed under the terms of the GNU GPL,
/*
* Portions of this work are licensed under the terms of the GNU GPL,
* version 2 or later. See the COPYING file in the top-level directory.
*/
target/m68k/softfloat_fpsp_tables.h
+2 -1
View File
@@ -14,7 +14,8 @@
* the Softfloat-2a license unless specifically indicated otherwise.
*/
/* Portions of this work are licensed under the terms of the GNU GPL,
/*
* Portions of this work are licensed under the terms of the GNU GPL,
* version 2 or later. See the COPYING file in the top-level directory.
*/
target/m68k/translate.c
+161 -85
View File
File diff suppressed because it is too large Load Diff