PTO-SCALAR-MODEL-FSU-PROFILE

1// PTO-UNIT: {"id":"PTO-SCALAR-MODEL-FSU-PROFILE","surface":"scalar","classification":["model","fsu","profile"],"depends_on":["PTO-SCALAR-MODEL-FSU-ARITHMETIC","PTO-ARCH-STATE-NUMERIC-STATUS"]}2// Raw scalar floating-point execution. The portable model fixes carrier,3// control/status, comparison, NaN, signed-zero, and destination rules. Numeric4// operations that require a concrete floating-point implementation cross one5// of the explicit profile hooks below.6
7pure func ScalarFPSourceTypeCode(source_type: bits(2)) => bits(5)8begin9    if source_type == '00' then return '00000';10    elsif source_type == '01' then return '00001';11    else return '11111';12    end;13end;14
15pure func ScalarSignedIntegerSourceTypeCode(source_type: bits(2)) => bits(5)16begin17    if source_type == '00' then return '01000';18    elsif source_type == '01' then return '01001';19    else return '11111';20    end;21end;22
23pure func ScalarUnsignedIntegerSourceTypeCode(source_type: bits(2)) => bits(5)24begin25    if source_type == '00' then return '00000';26    elsif source_type == '01' then return '00001';27    else return '11111';28    end;29end;30
31pure func ScalarFPTypeCodeSupported(data_type: bits(5)) => boolean32begin33    return UInt(data_type) <= 14;34end;35
36pure func ScalarIntegerTypeCodeSupported(data_type: bits(5)) => boolean37begin38    return UInt(data_type) <= 14;39end;40
41readonly func ScalarFPActiveRoundingMode() => NumericRoundingMode42begin43    return ResolveScalarFPActiveRoundingMode(_SystemRegisters.core_state[39:37]);44end;45
46pure func ScalarFPFixedConversionRoundingMode(operation: ScalarOperation)47                                                => NumericRoundingMode48begin49    if operation == ScalarOperation_FCVTA then return NumericRound_RNA;50    elsif operation == ScalarOperation_FCVTM then return NumericRound_RTM;51    elsif operation == ScalarOperation_FCVTN then return NumericRound_RNE;52    elsif operation == ScalarOperation_FCVTP then return NumericRound_RTP;53    elsif operation == ScalarOperation_FCVTZ then return NumericRound_RTZ;54    else unreachable;55    end;56end;57
58readonly func ScalarFPFlags() => bits(5)59begin60    return NumericStatusFlags();61end;62
63func ScalarFPRecordFlags(flags: bits(5))64begin65    RecordNumericStatusFlags(flags);66end;67
68pure func NormalizeScalarFPSource(value: Word, data_type: bits(5)) => Word69begin70    if data_type == '00001' then71        return ZeroExtend{PTO_XLEN}(value[31:0]);72    else73        return value;74    end;75end;76
77pure func NormalizeScalarIntegerSource(value: Word, data_type: bits(5)) => Word78begin79    if data_type == '00001' then return ZeroExtend{PTO_XLEN}(value[31:0]);80    elsif data_type == '01001' then return SignExtend{PTO_XLEN}(value[31:0]);81    else return value;82    end;83end;84
85pure func NormalizeScalarFPResult(value: Word, data_type: bits(5)) => Word86begin87    case UInt(data_type) of88        when 0 => return value;89        when 1, 3 => return ZeroExtend{PTO_XLEN}(value[31:0]);90        when 2 => return ZeroExtend{PTO_XLEN}(value[18:0]);91        when 4, 5 => return ZeroExtend{PTO_XLEN}(value[15:0]);92        when 6, 7, 8, 13 => return ZeroExtend{PTO_XLEN}(value[7:0]);93        when 9, 10 => return ZeroExtend{PTO_XLEN}(value[5:0]);94        when 11, 12 => return ZeroExtend{PTO_XLEN}(value[3:0]);95        when 14 => return ZeroExtend{PTO_XLEN}(value[8:0]);96        otherwise => unreachable;97    end;98end;99
100pure func NormalizeScalarIntegerResult(value: Word, data_type: bits(5)) => Word101begin102    case UInt(data_type) of103        when 0, 8 => return value;104        when 1 => return ZeroExtend{PTO_XLEN}(value[31:0]);105        when 2 => return ZeroExtend{PTO_XLEN}(value[15:0]);106        when 3 => return ZeroExtend{PTO_XLEN}(value[7:0]);107        when 4 => return ZeroExtend{PTO_XLEN}(value[3:0]);108        when 5 => return ZeroExtend{PTO_XLEN}(value[1:0]);109        when 6, 7 => return ZeroExtend{PTO_XLEN}(value[0:0]);110        when 9 => return SignExtend{PTO_XLEN}(value[31:0]);111        when 10 => return SignExtend{PTO_XLEN}(value[15:0]);112        when 11 => return SignExtend{PTO_XLEN}(value[7:0]);113        when 12 => return SignExtend{PTO_XLEN}(value[3:0]);114        when 13 => return SignExtend{PTO_XLEN}(value[1:0]);115        when 14 => return SignExtend{PTO_XLEN}(value[0:0]);116        otherwise => unreachable;117    end;118end;119
120pure func ScalarFP64IsNaN(value: Word) => boolean121begin122    return NumericValueClassIsNaN(123        TileNumericValueClass(TileDataType_FP64, value));124end;125
126pure func ScalarFP64IsSignalingNaN(value: Word) => boolean127begin128    return TileNumericValueClass(TileDataType_FP64, value) ==129        NumericValue_SignalingNaN;130end;131
132pure func ScalarFP64IsZero(value: Word) => boolean133begin134    return NumericValueClassIsZero(135        TileNumericValueClass(TileDataType_FP64, value));136end;137
138pure func ScalarFP64OrderKey(value: Word) => Word139begin140    if value[63] == '1' then return NOT(value);141    else return value XOR (Zeros{PTO_XLEN} + 0x8000000000000000);142    end;143end;144
145pure func ScalarFP32IsNaN(value: bits(32)) => boolean146begin147    return NumericValueClassIsNaN(TileNumericValueClass(148        TileDataType_FP32, ZeroExtend{PTO_XLEN}(value)));149end;150
151pure func ScalarFP32IsSignalingNaN(value: bits(32)) => boolean152begin153    return TileNumericValueClass(TileDataType_FP32,154        ZeroExtend{PTO_XLEN}(value)) == NumericValue_SignalingNaN;155end;156
157pure func ScalarFP32IsZero(value: bits(32)) => boolean158begin159    return NumericValueClassIsZero(TileNumericValueClass(160        TileDataType_FP32, ZeroExtend{PTO_XLEN}(value)));161end;162
163pure func ScalarFPCarrierIsZero(value: Word, data_type: bits(5)) => boolean164begin165    if data_type == '00001' then return ScalarFP32IsZero(value[31:0]);166    else return ScalarFP64IsZero(value);167    end;168end;169
170pure func ScalarFP32OrderKey(value: bits(32)) => bits(32)171begin172    if value[31] == '1' then return NOT(value);173    else return value XOR (Zeros{32} + 0x80000000);174    end;175end;176
177pure func ScalarFPIsNaN(value: Word, source_type: bits(2)) => boolean178begin179    if source_type == '01' then return ScalarFP32IsNaN(value[31:0]);180    else return ScalarFP64IsNaN(value);181    end;182end;183
184pure func ScalarFPIsSignalingNaN(value: Word, source_type: bits(2)) => boolean185begin186    if source_type == '01' then return ScalarFP32IsSignalingNaN(value[31:0]);187    else return ScalarFP64IsSignalingNaN(value);188    end;189end;190
191pure func ScalarFPEncodingEqual(left: Word, right: Word,192                                source_type: bits(2)) => boolean193begin194    if ScalarFPIsNaN(left, source_type) || ScalarFPIsNaN(right, source_type) then195        return FALSE;196    elsif source_type == '01' then197        let left32 = left[31:0];198        let right32 = right[31:0];199        return left32 == right32 ||200               (ScalarFP32IsZero(left32) && ScalarFP32IsZero(right32));201    else202        return left == right ||203               (ScalarFP64IsZero(left) && ScalarFP64IsZero(right));204    end;205end;206
207pure func ScalarFPEncodingLess(left: Word, right: Word,208                               source_type: bits(2)) => boolean209begin210    if ScalarFPIsNaN(left, source_type) || ScalarFPIsNaN(right, source_type) then211        return FALSE;212    elsif source_type == '01' then213        let left32 = left[31:0];214        let right32 = right[31:0];215        if ScalarFP32IsZero(left32) && ScalarFP32IsZero(right32) then return FALSE;216        else return UInt(ScalarFP32OrderKey(left32)) < UInt(ScalarFP32OrderKey(right32));217        end;218    else219        if ScalarFP64IsZero(left) && ScalarFP64IsZero(right) then return FALSE;220        else return UInt(ScalarFP64OrderKey(left)) < UInt(ScalarFP64OrderKey(right));221        end;222    end;223end;224
225pure func ScalarFPEncodingCompare(operation: FloatingCompareOperation,226                                  left: Word, right: Word,227                                  source_type: bits(2)) => boolean228begin229    if ScalarFPIsNaN(left, source_type) || ScalarFPIsNaN(right, source_type) then230        return FALSE;231    end;232    let equal = ScalarFPEncodingEqual(left, right, source_type);233    let less = ScalarFPEncodingLess(left, right, source_type);234    case operation of235        when FloatingCompare_EQ => return equal;236        when FloatingCompare_NE => return !equal;237        when FloatingCompare_LT => return less;238        when FloatingCompare_LE => return less || equal;239        when FloatingCompare_GT => return !less && !equal;240        when FloatingCompare_GE => return !less;241    end;242end;243
244pure func ScalarFPQuietNaN(source_type: bits(2)) => Word245begin246    let data_type = if source_type == '01' then TileDataType_FP32247                    else TileDataType_FP64;248    let (available, value) = TileNumericCanonicalNaN(data_type);249    assert available;250    return value;251end;252
253pure func ScalarFPMinMax(operation: FloatingBinaryOperation,254                         left: Word, right: Word,255                         source_type: bits(2)) => Word256begin257    let left_nan = ScalarFPIsNaN(left, source_type);258    let right_nan = ScalarFPIsNaN(right, source_type);259    if left_nan && right_nan then return ScalarFPQuietNaN(source_type);260    elsif left_nan then return NormalizeScalarFPSource(right, ScalarFPSourceTypeCode(source_type));261    elsif right_nan then return NormalizeScalarFPSource(left, ScalarFPSourceTypeCode(source_type));262    end;263
264    if source_type == '01' then265        let left32 = left[31:0];266        let right32 = right[31:0];267        if ScalarFP32IsZero(left32) && ScalarFP32IsZero(right32) then268            if operation == FloatingBinary_MAX && left32[31] == '1' &&269               right32[31] == '1' then270                return Zeros{PTO_XLEN} + 0x80000000;271            elsif operation == FloatingBinary_MAX then return Zeros{PTO_XLEN};272            elsif left32[31] == '1' || right32[31] == '1' then273                return Zeros{PTO_XLEN} + 0x80000000;274            else return Zeros{PTO_XLEN};275            end;276        end;277    elsif ScalarFP64IsZero(left) && ScalarFP64IsZero(right) then278        if operation == FloatingBinary_MAX && left[63] == '1' &&279           right[63] == '1' then280            return Zeros{PTO_XLEN} + 0x8000000000000000;281        elsif operation == FloatingBinary_MAX then return Zeros{PTO_XLEN};282        elsif left[63] == '1' || right[63] == '1' then283            return Zeros{PTO_XLEN} + 0x8000000000000000;284        else return Zeros{PTO_XLEN};285        end;286    end;287
288    let less = ScalarFPEncodingLess(left, right, source_type);289    if operation == FloatingBinary_MIN then290        if less then return left; else return right; end;291    else292        if less then return right; else return left; end;293    end;294end;295
296impdef func ScalarFPBinaryProfile(operation: FloatingBinaryOperation,297                                  rounding_mode: NumericRoundingMode, source_type: bits(5),298                                  left: Word, right: Word) => (Word, bits(5))299begin300    // Executable identity default. A named numeric profile supplies the301    // correctly rounded arithmetic result and IEEE exception flags.302    assert ScalarFPTypeCodeSupported(source_type);303    return (left, Zeros{5});304end;305
306impdef func ScalarFPUnaryProfile(operation: FloatingUnaryOperation,307                                 rounding_mode: NumericRoundingMode, source_type: bits(5),308                                 value: Word) => (Word, bits(5))309begin310    assert ScalarFPTypeCodeSupported(source_type);311    return (value, Zeros{5});312end;313
314impdef func ScalarFPFusedProfile(operation: FloatingFusedOperation,315                                 rounding_mode: NumericRoundingMode, source_type: bits(5),316                                 addend: Word, left: Word, right: Word)317                                 => (Word, bits(5))318begin319    assert ScalarFPTypeCodeSupported(source_type);320    return (addend, Zeros{5});321end;322
323impdef func ScalarFPToIntegerProfile(rounding_mode: NumericRoundingMode,324                                     destination_type: bits(5),325                                     source_type: bits(5), value: Word)326                                     => (Word, bits(5))327begin328    assert ScalarIntegerTypeCodeSupported(destination_type);329    assert ScalarFPTypeCodeSupported(source_type);330    return (value, Zeros{5});331end;332
333impdef func ScalarFPConvertProfile(rounding_mode: NumericRoundingMode,334                                   destination_type: bits(5),335                                   source_type: bits(5), value: Word)336                                   => (Word, bits(5))337begin338    assert ScalarFPTypeCodeSupported(destination_type);339    assert ScalarFPTypeCodeSupported(source_type);340    return (value, Zeros{5});341end;342
343impdef func ScalarIntegerToFPProfile(rounding_mode: NumericRoundingMode,344                                     source_type: bits(5),345                                     destination_type: bits(5), value: Word)346                                     => (Word, bits(5))347begin348    assert ScalarIntegerTypeCodeSupported(source_type);349    assert ScalarFPTypeCodeSupported(destination_type);350    return (value, Zeros{5});351end;352