christoph/fail
1
Fork 0
Code Releases Activity
Files
2575604b4183259bec592dbbc7c430bcbaa0c014
fail/simulators/ovp/armmModel/armmVFP.c

877 lines
24 KiB
C
Raw Blame History

/*
* Copyright (c) 2005-2011 Imperas Software Ltd., www.imperas.com
*
* YOUR ACCESS TO THE INFORMATION IN THIS MODEL IS CONDITIONAL
* UPON YOUR ACCEPTANCE THAT YOU WILL NOT USE OR PERMIT OTHERS
* TO USE THE INFORMATION FOR THE PURPOSES OF DETERMINING WHETHER
* IMPLEMENTATIONS OF THE ARM ARCHITECTURE INFRINGE ANY THIRD
* PARTY PATENTS.
*
* THE LICENSE BELOW EXTENDS ONLY TO USE OF THE SOFTWARE FOR
* MODELING PURPOSES AND SHALL NOT BE CONSTRUED AS GRANTING
* A LICENSE TO CREATE A HARDWARE IMPLEMENTATION OF THE
* FUNCTIONALITY OF THE SOFTWARE LICENSED HEREUNDER.
* YOU MAY USE THE SOFTWARE SUBJECT TO THE LICENSE TERMS BELOW
* PROVIDED THAT YOU ENSURE THAT THIS NOTICE IS REPLICATED UNMODIFIED
* AND IN ITS ENTIRETY IN ALL DISTRIBUTIONS OF THE SOFTWARE,
* MODIFIED OR UNMODIFIED, IN SOURCE CODE OR IN BINARY FORM.
*
* Licensed under an Imperas Modfied Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.ovpworld.org/licenses/OVP_MODIFIED_1.0_APACHE_OPEN_SOURCE_LICENSE_2.0.pdf
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
* either express or implied.
*
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
#include <math.h>
// VMI header files
#include "vmi/vmiRt.h"
#include "vmi/vmiMessage.h"
// model header files
#include "armFPConstants.h"
#include "armMessage.h"
#include "armVFP.h"
#include "armSysRegisters.h"
#include "armStructure.h"
#include "armUtils.h"
//
// Prefix for messages from this module
//
#define CPU_PREFIX "ARMM_VFP"
//
// Return current program counter
//
inline static Uns32 getPC(armP arm) {
return vmirtGetPC((vmiProcessorP)arm);
}
////////////////////////////////////////////////////////////////////////////////
// FLOATING POINT CONTROL PREDICATES
////////////////////////////////////////////////////////////////////////////////
//
// Return the current rounding control
//
static vmiFPRC getRoundingControl(armP arm) {
// map ARM rounding mode to VMI rounding mode
static const vmiFPRC modeMap[] = {
[0] = vmi_FPR_NEAREST,
[1] = vmi_FPR_POS_INF,
[2] = vmi_FPR_NEG_INF,
[3] = vmi_FPR_ZERO
};
if(SCS_USE_CPUID(arm) && !SCS_FIELD(arm, MVFR0, VFP_RoundingModes)) {
// if rounding modes are not supported, use vmi_FPR_NEAREST
return vmi_FPR_NEAREST;
} else {
// return the mapped rounding mode
return modeMap[FPSCR_FIELD(arm, RMode)];
}
}
//
// Should the default NaN be returned in any calculation that produces a NaN?
//
inline static Bool returnDefaultNaN(armP arm) {
return (
// in VFP mode, return the default NaN if FPSCR.DN is set
FPSCR_FIELD(arm, DN) ||
// MVFR1.DefaultNaNMode=0 indicates hardware supports only the default
// NaN mode
(SCS_USE_CPUID(arm) && !SCS_FIELD(arm, MVFR1, DefaultNaNMode))
);
}
//
// Is flush-to-zero mode enabled?
//
inline static Bool inFTZMode(armP arm) {
return (
// flush-to-zero is enabled if FPSCR.FZ is set
FPSCR_FIELD(arm, FZ) ||
// MVFR1.FlushToZeroMode=0 indicates hardware supports only
// flush-to-zero mode
(SCS_USE_CPUID(arm) && !SCS_FIELD(arm, MVFR1, FlushToZeroMode))
);
}
//
// Is alternative half precision mode enabled?
//
inline static Bool inAHPMode(armP arm) {
return FPSCR_FIELD(arm, AHP);
}
////////////////////////////////////////////////////////////////////////////////
// FLOATING REGISTER ACCESS
////////////////////////////////////////////////////////////////////////////////
//
// Set control word
//
inline static void setControlWord(armP arm, armFPCW new) {
if(arm->currentCW.u32 != new.u32) {
arm->currentCW = new;
vmirtSetFPControlWord((vmiProcessorP)arm, new.cw);
}
}
//
// Update VFP control word to make it consistent with the FPSCR
//
static void updateVFPControlWord(armP arm) {
// Mask off all exceptions */
armFPCW newFPCW = {.cw.IM=1, .cw.DM=1, .cw.ZM=1, .cw.OM=1, .cw.UM=1, .cw.PM=1};
// set rounding control, denormals-are-zero and flush-to-zero
newFPCW.cw.RC = getRoundingControl(arm);
newFPCW.cw.DAZ = newFPCW.cw.FZ = inFTZMode(arm);
// Set the new control word
setControlWord(arm, newFPCW);
}
//
// Write VFP FPSCR register
//
void armWriteFPSCR(armP arm, Uns32 newValue, Uns32 writeMask) {
Uns32 oldValue = FPSCR_REG(arm);
// update raw register
FPSCR_REG(arm) = ((oldValue & ~writeMask) | (newValue & writeMask));
// set denormal input sticky flag
arm->denormalInput = FPSCR_FIELD(arm, IDC);
// set sticky flags
vmiFPFlags sticky = {0};
sticky.f.I = FPSCR_FIELD(arm, IOC); // invalid operation flag
sticky.f.Z = FPSCR_FIELD(arm, DZC); // divide-by-zero flag
sticky.f.O = FPSCR_FIELD(arm, OFC); // overflow flag
sticky.f.U = FPSCR_FIELD(arm, UFC); // underflow flag
sticky.f.P = FPSCR_FIELD(arm, IXC); // inexact flag
arm->sdfpSticky = sticky.bits;
// set comparison flags
arm->sdfpAFlags.NF = (FPSCR_FIELD(arm, N)) ? 1 : 0;
arm->sdfpAFlags.ZF = (FPSCR_FIELD(arm, Z)) ? 1 : 0;
arm->sdfpAFlags.CF = (FPSCR_FIELD(arm, C)) ? 1 : 0;
arm->sdfpAFlags.VF = (FPSCR_FIELD(arm, V)) ? 1 : 0;
// update simulator floating point control word
updateVFPControlWord(arm);
}
//
// Read VFP FPSCR register
//
Uns32 armReadFPSCR(armP arm) {
// compose denormal input flag
FPSCR_FIELD(arm, IDC) = arm->denormalInput;
// compose remaining sticky flags
vmiFPFlags sticky = {arm->sdfpSticky};
FPSCR_FIELD(arm, IOC) = sticky.f.I; // invalid operation flag
FPSCR_FIELD(arm, DZC) = sticky.f.Z; // divide-by-zero flag
FPSCR_FIELD(arm, OFC) = sticky.f.O; // overflow flag
FPSCR_FIELD(arm, UFC) = sticky.f.U; // underflow flag
FPSCR_FIELD(arm, IXC) = sticky.f.P; // inexact flag
// compose comparison flags
FPSCR_FIELD(arm, N) = (arm->sdfpAFlags.NF) ? 1 : 0;
FPSCR_FIELD(arm, Z) = (arm->sdfpAFlags.ZF) ? 1 : 0;
FPSCR_FIELD(arm, C) = (arm->sdfpAFlags.CF) ? 1 : 0;
FPSCR_FIELD(arm, V) = (arm->sdfpAFlags.VF) ? 1 : 0;
// return composed value
return FPSCR_REG(arm);
}
////////////////////////////////////////////////////////////////////////////////
// EXCEPTION FLAG UTILITIES
////////////////////////////////////////////////////////////////////////////////
//
// Validate that an exception is disabled
//
inline static void validateFTZ(armP arm) {
VMI_ASSERT(
inFTZMode(arm),
"expected enabled flush-to-zero mode"
);
}
//
// Set the denormal sticky bit (when flush-to-zero mode is enabled)
//
static void setDenormalStickyFTZ(armP arm) {
validateFTZ(arm);
arm->denormalInput = 1;
}
//
// Set the underflow sticky bit (when flush-to-zero mode is enabled)
//
static void setUnderflowStickyFTZ(armP arm) {
validateFTZ(arm);
const static vmiFPFlags underflow = {f:{U:1}};
arm->sdfpSticky |= underflow.bits;
}
//
// Raise the denormal exception
//
static void raiseDenormal(armP arm) {
arm->denormalInput = 1;
}
//
// Raise the underflow exception
//
static void raiseUnderflow(armP arm) {
const static vmiFPFlags underflow = {f:{U:1}};
arm->sdfpSticky |= underflow.bits;
}
//
// Raise the overflow exception
//
static void raiseOverflow(armP arm) {
const static vmiFPFlags overflow = {f:{O:1}};
arm->sdfpSticky |= overflow.bits;
}
//
// Raise the invalid operation exception
//
static void raiseInvalidOperation(armP arm) {
const static vmiFPFlags invalidOperation = {f:{I:1}};
arm->sdfpSticky |= invalidOperation.bits;
}
//
// Raise the inexact exception
//
static void raiseInexact(armP arm) {
const static vmiFPFlags inexact = {f:{P:1}};
arm->sdfpSticky |= inexact.bits;
}
////////////////////////////////////////////////////////////////////////////////
// HALF-PRECISION OPERATIONS
////////////////////////////////////////////////////////////////////////////////
//
// Convert from half-precision to single-precision
//
Uns32 armFPHalfToSingle(armP arm, Uns16 half) {
Int32 exponent = ARM_FP16_EXPONENT(half);
Uns32 fraction = ARM_FP16_FRACTION(half);
Bool sign = ARM_FP16_SIGN(half);
Bool expAll1 = (exponent==ARM_FP16_EXP_ONES);
Bool isZero = (!exponent && !fraction);
Bool isInfinity = (expAll1 && !fraction);
Bool isNaN = (expAll1 && !isInfinity);
Bool useAHP = inAHPMode(arm);
if(isInfinity && !useAHP) {
// infinities require exponent correction
exponent = ARM_FP32_EXPONENT(ARM_FP32_PLUS_INFINITY);
fraction = ARM_FP32_FRACTION(ARM_FP32_PLUS_INFINITY);
} else if(isZero) {
// zero values require no special processing
} else if(isNaN && !useAHP) {
// argument is an SNaN if MSB of fraction is clear
Bool isSNaN = !(fraction & (1 << (ARM_FP16_EXP_SHIFT-1)));
// raise Invalid Operation exception if an SNaN
if(isSNaN) {
raiseInvalidOperation(arm);
}
if(returnDefaultNaN(arm)) {
// default QNaN is required
exponent = ARM_FP32_EXPONENT(ARM_QNAN_DEFAULT_32);
fraction = ARM_FP32_FRACTION(ARM_QNAN_DEFAULT_32);
sign = ARM_FP32_SIGN(ARM_QNAN_DEFAULT_32);
} else {
// NaNs require exponent correction
exponent = ARM_FP32_EXP_ONES;
// NaNs require fraction correction
fraction = fraction << (ARM_FP32_EXP_SHIFT - ARM_FP16_EXP_SHIFT);
fraction |= ARM_QNAN_MASK_32;
}
} else {
// normalize a denormal value if required
if(!exponent) {
// shift up until implicit MSB is 1
do {
fraction <<= 1;
exponent--;
} while(!(fraction & (1<<ARM_FP16_EXP_SHIFT)));
// correct exponent and mask off implicit MSB
exponent++;
fraction &= ~(1<<ARM_FP16_EXP_SHIFT);
}
// rebase exponent and fraction
exponent += (ARM_FP32_EXP_BIAS - ARM_FP16_EXP_BIAS );
fraction <<= (ARM_FP32_EXP_SHIFT - ARM_FP16_EXP_SHIFT);
}
// compose single-precision result
return (
(sign << ARM_FP32_SIGN_SHIFT) |
(exponent << ARM_FP32_EXP_SHIFT ) |
fraction
);
}
//
// Convert from single-precision to half-precision
//
Uns16 armFPSingleToHalf(armP arm, Uns32 single) {
Int32 exponent = ARM_FP32_EXPONENT(single);
Uns32 fraction = ARM_FP32_FRACTION(single);
Bool sign = ARM_FP32_SIGN(single);
Bool expAll1 = (exponent==ARM_FP32_EXP_ONES);
Bool isZero = (!exponent && !fraction);
Bool isDenormal = (!exponent && fraction);
Bool isInfinity = (expAll1 && !fraction);
Bool isNaN = (expAll1 && !isInfinity);
Bool useAHP = inAHPMode(arm);
if(isInfinity) {
if(useAHP) {
// alternative half precision has a different infinity format
exponent = ARM_FP16_EXPONENT(ARM_FP16_AHP_INFINITY);
fraction = ARM_FP16_FRACTION(ARM_FP16_AHP_INFINITY);
raiseInvalidOperation(arm);
} else {
// IEEE infinities require exponent correction
exponent = ARM_FP16_EXPONENT(ARM_FP16_PLUS_INFINITY);
fraction = ARM_FP16_FRACTION(ARM_FP16_PLUS_INFINITY);
}
} else if(isZero) {
// zero values require no special processing
} else if(isNaN) {
// argument is an SNaN if MSB of fraction is clear
Bool isSNaN = !(fraction & (1 << (ARM_FP32_EXP_SHIFT-1)));
// raise Invalid Operation exception if using Alternative Half Precision
// format or argument is an SNaN
if(isSNaN || useAHP) {
raiseInvalidOperation(arm);
}
if(useAHP) {
// if using Alternative Half Precision format, NaNs go to zero
exponent = 0;
fraction = 0;
} else if(returnDefaultNaN(arm)) {
// default QNaN is required
exponent = ARM_FP16_EXPONENT(ARM_QNAN_DEFAULT_16);
fraction = ARM_FP16_FRACTION(ARM_QNAN_DEFAULT_16);
sign = ARM_FP16_SIGN(ARM_QNAN_DEFAULT_16);
} else {
// NaNs require exponent correction
exponent = ARM_FP16_EXP_ONES;
// NaNs require fraction correction
fraction = fraction >> (ARM_FP32_EXP_SHIFT - ARM_FP16_EXP_SHIFT);
fraction |= ARM_QNAN_MASK_16;
}
} else if(isDenormal && inFTZMode(arm)) {
// flush denormals to zero if required
setDenormalStickyFTZ(arm);
exponent = 0;
fraction = 0;
} else {
// split value into sign, unrounded mantissa and exponent
union {Uns32 u32; Flt32 f32;} u = {single};
Flt32 result = u.f32;
Flt32 mantissa = sign ? -result : result;
exponent = 0;
while(mantissa<1.0) {
mantissa *= 2.0; exponent--;
}
while(mantissa>=2.0) {
mantissa /= 2.0; exponent++;
}
// bias the exponent so that the minimum exponent becomes 1, lower
// values 0 (indicating possible underflow)
exponent -= ARM_FP16_EXP_MIN;
while(exponent<0) {
exponent++;
mantissa /= 2.0;
}
// get the unrounded mantissa as an integer and the "units in last
// place" rounding error
Flt32 mantissaExp2F = mantissa*(1<<ARM_FP16_EXP_SHIFT);
fraction = mantissaExp2F;
Flt32 error = mantissaExp2F - fraction;
// there is an underflow exception if the exponent is too small before
// rounding and the result is inexact
if(!exponent && error) {
raiseUnderflow(arm);
}
Bool roundUp;
Bool overflowToInf;
// now round using the required rounding mode
switch(getRoundingControl(arm)) {
case vmi_FPR_NEAREST:
roundUp = ((error>0.5) || ((error==0.5) && (fraction&1)));
overflowToInf = True;
break;
case vmi_FPR_POS_INF:
roundUp = (error && !sign);
overflowToInf = !sign;
break;
case vmi_FPR_NEG_INF:
roundUp = (error && sign);
overflowToInf = sign;
break;
default:
roundUp = False;
overflowToInf = False;
break;
}
if(roundUp) {
fraction++;
// check for round up from denormalized to normalized
if(fraction==(1<<ARM_FP16_EXP_SHIFT)) {
exponent = 1;
}
// check for round up to next exponent
if(fraction==(1<<(ARM_FP16_EXP_SHIFT+1))) {
exponent++;
fraction /= 2;
}
}
// deal with overflow and generate result
if(!useAHP) {
// IEEE format result required
if(exponent>=((1<<ARM_FP16_EXP_BITS)-1)) {
if(overflowToInf) {
exponent = ARM_FP16_EXPONENT(ARM_FP16_PLUS_INFINITY);
fraction = ARM_FP16_FRACTION(ARM_FP16_PLUS_INFINITY);
} else {
exponent = ARM_FP16_EXPONENT(ARM_FP16_MAX_NORMAL);
fraction = ARM_FP16_FRACTION(ARM_FP16_MAX_NORMAL);
}
raiseOverflow(arm);
// Note this is not in the psuedo code but is needed to match
// behavior of reference simulator
raiseInexact(arm);
}
} else {
// alternative half precision result required
if(exponent>=(1<<ARM_FP16_EXP_BITS)) {
exponent = ARM_FP16_EXPONENT(ARM_FP16_AHP_INFINITY);
fraction = ARM_FP16_FRACTION(ARM_FP16_AHP_INFINITY);
raiseInvalidOperation(arm);
// avoid an inexact exception
error = 0.0;
}
}
// deal with inexact exception
if(error) {
raiseInexact(arm);
}
}
// compose half-precision result
return (
(sign << ARM_FP16_SIGN_SHIFT) |
(exponent << ARM_FP16_EXP_SHIFT ) |
fraction
);
}
////////////////////////////////////////////////////////////////////////////////
// INFINITY/ZERO CHECK
////////////////////////////////////////////////////////////////////////////////
//
// Return True if the single-precision floating point values op1 and op2 are 0
// and infinity (in either order), setting the denormal sticky bit if so
//
Bool armFPInfinityAndZero(armP arm, Uns32 op1, Uns32 op2) {
Bool op1Zero = ((op1 & 0x7f800000) == 0);
Bool op2Zero = ((op2 & 0x7f800000) == 0);
Bool op1Inf = ((op1 & 0x7fffffff) == 0x7f800000);
Bool op2Inf = ((op2 & 0x7fffffff) == 0x7f800000);
if((op1Zero && op2Inf) || (op2Zero && op1Inf)) {
// check if an op is denormal number
if ((op1Zero && (op1 & 0x007fffff) != 0) ||
(op2Zero && (op2 & 0x007fffff) != 0))
{
// raise denormal exception
raiseDenormal(arm);
}
return True;
}
return False;
}
////////////////////////////////////////////////////////////////////////////////
// QNAN/TINY HANDLING
////////////////////////////////////////////////////////////////////////////////
//
// Is the argument a 32-bit QNaN?
//
inline static Bool is32BitQNaN(vmiFPNaNArgP arg) {
return arg->isFlt32 && (arg->u32 & ARM_QNAN_MASK_32);
}
//
// Is the argument a 64-bit QNaN?
//
inline static Bool is64BitQNaN(vmiFPNaNArgP arg) {
return !arg->isFlt32 && (arg->u64 & ARM_QNAN_MASK_64);
}
//
// Is the argument a 32-bit SNaN?
//
inline static Bool is32BitSNaN(vmiFPNaNArgP arg) {
return arg->isFlt32 && !(arg->u32 & ARM_QNAN_MASK_32);
}
//
// Is the argument a 64-bit SNaN?
//
inline static Bool is64BitSNaN(vmiFPNaNArgP arg) {
return !arg->isFlt32 && !(arg->u64 & ARM_QNAN_MASK_64);
}
//
// Handle 32-bit QNaN result
//
static VMI_FP_QNAN32_RESULT_FN(handleQNaN32) {
armP arm = (armP)processor;
if(!NaNArgNum || returnDefaultNaN(arm)) {
return ARM_QNAN_DEFAULT_32;
} else {
Uns32 i;
// PASS 1: if any argument is an 32-bit SNaN, return that (as a QNaN)
for(i=0; i<NaNArgNum; i++) {
if(is32BitSNaN(&NaNArgs[i])) {
return NaNArgs[i].u32 | ARM_QNAN_MASK_32;
}
}
// PASS 2: if any argument is a 32-bit QNaN, return that
for(i=0; i<NaNArgNum; i++) {
if(is32BitQNaN(&NaNArgs[i])) {
return NaNArgs[i].u32;
}
}
// otherwise, if no argument is a 32-bit NaN (e.g. this is a conversion
// from 64-bit) return the calculated result
return QNaN32;
}
}
//
// Handle 64-bit QNaN result
//
static VMI_FP_QNAN64_RESULT_FN(handleQNaN64) {
armP arm = (armP)processor;
if(!NaNArgNum || returnDefaultNaN(arm)) {
return ARM_QNAN_DEFAULT_64;
} else {
Uns32 i;
// PASS 1: if any argument is an 64-bit SNaN, return that (as a QNaN)
for(i=0; i<NaNArgNum; i++) {
if(is64BitSNaN(&NaNArgs[i])) {
return NaNArgs[i].u64 | ARM_QNAN_MASK_64;
}
}
// PASS 2: if any argument is a 64-bit QNaN, return that
for(i=0; i<NaNArgNum; i++) {
if(is64BitQNaN(&NaNArgs[i])) {
return NaNArgs[i].u64;
}
}
// otherwise, if no argument is a 64-bit NaN (e.g. this is a conversion
// from 32-bit) return the calculated result
return QNaN64;
}
}
//
// Is the passed value a QNaN or SNaN?
//
static Bool isNaN80(vmiFP80Arg value) {
// decompose vmiFP80Arg into mantissa and sign
union {vmiFP80Arg fp80; struct {Uns64 mantissa; Uns16 expSign;};} u = {
value
};
if((u.expSign & 0x7fff)!=0x7fff) {
// exponent most be all 1's
return False;
} else if(u.mantissa==0x8000000000000000ULL) {
// +infinity, -infinity
return False;
} else {
// NaNs have some non-zero bit in the mantissa
return u.mantissa;
}
}
//
// Handle 16-bit indeterminate result
//
static VMI_FP_IND16_RESULT_FN(handleIndeterminate16) {
Uns32 result;
if(isNaN80(value)) {
result = 0;
} else if(value.bytes[VMI_FP_80_BYTES-1] & 0x80) {
result = isSigned ? ARM_MIN_INT16 : ARM_MIN_UNS16;
} else {
result = isSigned ? ARM_MAX_INT16 : ARM_MAX_UNS16;
}
return result;
}
//
// Handle 32-bit indeterminate result
//
static VMI_FP_IND32_RESULT_FN(handleIndeterminate32) {
Uns32 result;
if(isNaN80(value)) {
result = 0;
} else if(value.bytes[VMI_FP_80_BYTES-1] & 0x80) {
result = isSigned ? ARM_MIN_INT32 : ARM_MIN_UNS32;
} else {
result = isSigned ? ARM_MAX_INT32 : ARM_MAX_UNS32;
}
return result;
}
//
// Enumeration of tiny values that might be returned by flushing
//
typedef enum tinyValueE {
TV_PLUS_0,
TV_MINUS_0,
TV_LAST
} tinyValue;
//
// These contain tiny values
//
static vmiFP80Arg tinyValues32[TV_LAST];
//
// Initialize constant tiny 32-bit values
//
static void initTinyValue32(tinyValue tv, Uns32 pattern) {
union {Uns32 u32; Flt32 f32;} u = {pattern};
tinyValues32[tv].f80 = u.f32;
}
//
// Initialize constant tiny values
//
static void initTinyValues(void) {
initTinyValue32(TV_PLUS_0, 0x00000000);
initTinyValue32(TV_MINUS_0, 0x80000000);
}
//
// Handle 32-bit tiny result
//
static VMI_FP_TINY_RESULT_FN(handleTinyResult) {
// set underflow sticky bit
setUnderflowStickyFTZ((armP)processor);
// return appropriately-signed zero
Bool isNegative = value.bytes[VMI_FP_80_BYTES-1] & 0x80;
return tinyValues32[isNegative ? TV_MINUS_0 : TV_PLUS_0];
}
//
// Handle 64-bit tiny argument
//
static VMI_FP_TINY_ARGUMENT_FN(handleTinyArgument) {
// set denormal sticky bit
setDenormalStickyFTZ((armP)processor);
// return appropriately-signed zero
Bool isNegative = value.bytes[VMI_FP_80_BYTES-1] & 0x80;
return tinyValues32[isNegative ? TV_MINUS_0 : TV_PLUS_0];
}
////////////////////////////////////////////////////////////////////////////////
// RESET AND INITIALIZATION
////////////////////////////////////////////////////////////////////////////////
//
// Call on initialization
//
void armFPInitialize(armP arm) {
// initialize current control word to an empty value
arm->currentCW.u32 = -1;
// Initialize FP registers if present (AFTER armSysInitialize)
if (SCS_USE_CPUID(arm) && FPU_PRESENT(arm)) {
// initialize constant tiny values
initTinyValues();
// set up QNaN values and handlers
vmirtConfigureFPU(
(vmiProcessorP)arm,
ARM_QNAN_DEFAULT_32,
ARM_QNAN_DEFAULT_64,
0, // indeterminate value not used
0, // indeterminate value not used
0, // indeterminate value not used
handleQNaN32,
handleQNaN64,
handleIndeterminate16,
handleIndeterminate32,
0, // 64-bit indeterminate value handler not required
handleTinyResult,
handleTinyArgument,
True
);
// Set the write mask for CPACR to allow updating field cp10 and cp11
SCS_MASK_FIELD(arm, CPACR, cp10) = 3;
SCS_MASK_FIELD(arm, CPACR, cp11) = 3;
}
}
//
// Call on reset
//
void armFPReset(armP arm) {
// no action unless floating point is implemented
if(SCS_USE_CPUID(arm) && FPU_PRESENT(arm)) {
armWriteFPSCR(arm, 0, FPSCR_MASK);
}
}
View Git Blame Copy Permalink