PTO-SCALAR-MODEL-DISPATCH-DECODE

1// PTO-UNIT: {"id":"PTO-SCALAR-MODEL-DISPATCH-DECODE","surface":"scalar","classification":["model","dispatch","decode"],"depends_on":["generated:decoders","PTO-BLOCK-MODEL-SCHEMA-PROFILE-ENCODING"]}2// PTO-REQ-SCALAR-DISPATCH-001, PTO-REQ-SCALAR-CONSTRAINT-001: decoded scalar3// execution with catalog-generated form and family legality.4//5// Every accepted scalar family has a form-to-effect binding. Unknown or6// operand-illegal encodings are rejected; there is no silent unsupported path.7
8type ScalarExecutionStatus of enumeration {9    ScalarExecution_Executed,10    ScalarExecution_Rejected11};12
13pure func ScalarHandlerWritesTPC(handler: ScalarSemanticHandler) => boolean14begin15    return handler == ScalarHandler_JumpRelative ||16           handler == ScalarHandler_JumpRegister ||17           handler == ScalarHandler_ArchitectureEnterRequest;18end;19
20pure func ScalarDecodedSelector(instruction: bits(48),21                                form: integer {0..PTO_SCALAR_FORM_COUNT-1},22                                field: ScalarOperandField) => Reg5Selector23begin24    let raw = DecodeScalarOperandRaw(instruction, form, field);25    return UInt(raw[4:0]) as Reg5Selector;26end;27
28pure func ScalarDecodedWord(instruction: bits(48),29                            form: integer {0..PTO_SCALAR_FORM_COUNT-1},30                            field: ScalarOperandField) => Word31begin32    let raw = DecodeScalarOperandRaw(instruction, form, field);33    if ScalarOperandSignedness(form, field) == ScalarField_Signed then34        case ScalarOperandWidth(form, field) of35            when 5  => return SignExtend{PTO_XLEN}(raw[4:0]);36            when 12 => return SignExtend{PTO_XLEN}(raw[11:0]);37            when 17 => return SignExtend{PTO_XLEN}(raw[16:0]);38            when 22 => return SignExtend{PTO_XLEN}(raw[21:0]);39            when 24 => return SignExtend{PTO_XLEN}(raw[23:0]);40            when 29 => return SignExtend{PTO_XLEN}(raw[28:0]);41            when 32 => return SignExtend{PTO_XLEN}(raw[31:0]);42            otherwise => unreachable;43        end;44    end;45    return ZeroExtend{PTO_XLEN}(raw);46end;47
48pure func ScalarDecodedBits19(instruction: bits(48),49                              form: integer {0..PTO_SCALAR_FORM_COUNT-1},50                              field: ScalarOperandField) => bits(19)51begin52    return DecodeScalarOperandRaw(instruction, form, field)[18:0];53end;54
55pure func ScalarDecodedBits20(instruction: bits(48),56                              form: integer {0..PTO_SCALAR_FORM_COUNT-1},57                              field: ScalarOperandField) => bits(20)58begin59    return DecodeScalarOperandRaw(instruction, form, field)[19:0];60end;61
62pure func ScalarDecodedBits4(instruction: bits(48),63                             form: integer {0..PTO_SCALAR_FORM_COUNT-1},64                             field: ScalarOperandField) => bits(4)65begin66    return DecodeScalarOperandRaw(instruction, form, field)[3:0];67end;68
69pure func ScalarDecodedBits5(instruction: bits(48),70                             form: integer {0..PTO_SCALAR_FORM_COUNT-1},71                             field: ScalarOperandField) => bits(5)72begin73    return DecodeScalarOperandRaw(instruction, form, field)[4:0];74end;75
76pure func ScalarDecodedSystemRegisterAddress(77    instruction: bits(48), form: integer {0..PTO_SCALAR_FORM_COUNT-1},78    field: ScalarOperandField) => SystemRegisterAddress79begin80    return DecodeScalarOperandRaw(instruction, form, field)[23:0];81end;82
83pure func ScalarDecodedBoolean(instruction: bits(48),84                               form: integer {0..PTO_SCALAR_FORM_COUNT-1},85                               field: ScalarOperandField) => boolean86begin87    return DecodeScalarOperandRaw(instruction, form, field)[0] == '1';88end;89
90pure func ScalarDecodedMemoryOrder(91    instruction: bits(48), form: integer {0..PTO_SCALAR_FORM_COUNT-1})92    => MemoryOrder93begin94    let acquire = ScalarDecodedBoolean(instruction, form, ScalarField_aq);95    let release = ScalarDecodedBoolean(instruction, form, ScalarField_rl);96    if acquire && release then return MemoryOrder_AcquireRelease;97    elsif acquire then return MemoryOrder_Acquire;98    elsif release then return MemoryOrder_Release;99    else return MemoryOrder_Relaxed;100    end;101end;102
103readonly func ScalarDecodedAtomicAddress(104    instruction: bits(48), form: integer {0..PTO_SCALAR_FORM_COUNT-1},105    field: ScalarOperandField) => Word106begin107    let address = ReadDecodedScalarRegister(instruction, form, field);108    let far = ScalarDecodedBoolean(instruction, form, ScalarField_far);109    return AtomicAddress(address, far);110end;111
112pure func ScalarDecodedBits32(instruction: bits(48),113                              form: integer {0..PTO_SCALAR_FORM_COUNT-1},114                              field: ScalarOperandField) => bits(32)115begin116    return DecodeScalarOperandRaw(instruction, form, field)[31:0];117end;118
119pure func ScalarDecodedUInt6(instruction: bits(48),120                             form: integer {0..PTO_SCALAR_FORM_COUNT-1},121                             field: ScalarOperandField) => integer {0..63}122begin123    return UInt(DecodeScalarOperandRaw(instruction, form, field)[5:0]);124end;125
126pure func ScalarDecodedUInt7(instruction: bits(48),127                             form: integer {0..PTO_SCALAR_FORM_COUNT-1},128                             field: ScalarOperandField) => integer {0..127}129begin130    return UInt(DecodeScalarOperandRaw(instruction, form, field)[6:0]);131end;132
133pure func ScalarDecodedBitfieldWidth(instruction: bits(48),134                                     form: integer {0..PTO_SCALAR_FORM_COUNT-1})135                                     => integer {1..64}136begin137    return UInt(DecodeScalarOperandRaw(instruction, form, ScalarField_imml)[5:0]) + 1;138end;139
140pure func DecodeScalarBinaryRightModifier(raw: bits(2))141                                           => ScalarRightModifier142begin143    case raw of144        when '00' => return ScalarRight_SignedWord;145        when '01' => return ScalarRight_UnsignedWord;146        when '10' => return ScalarRight_NegateOrNot;147        when '11' => return ScalarRight_None;148    end;149end;150
151pure func DecodeScalarComparisonRightModifier(raw: bits(2))152                                               => ScalarRightModifier153begin154    case raw of155        when '00' => return ScalarRight_None;156        when '01' => return ScalarRight_SignedWord;157        when '10' => return ScalarRight_UnsignedWord;158        when '11' => return ScalarRight_NegateOrNot;159    end;160end;161
162pure func DecodeScalarSelectRightModifier(raw: bits(2))163                                          => ScalarRightModifier164begin165    if raw == '11' then166        return ScalarRight_NegateOrNot;167    else168        return ScalarRight_None;169    end;170end;171
172pure func DecodeScalarAddressRightModifier(raw: bits(2))173                                           => ScalarRightModifier174begin175    case raw of176        when '00' => return ScalarRight_None;177        when '01' => return ScalarRight_SignedWord;178        when '10' => return ScalarRight_UnsignedWord;179        when '11' => return ScalarRight_NegateOrNot;180    end;181end;182
183pure func ScalarDecodedBinaryRightModifier(184    instruction: bits(48), form: integer {0..PTO_SCALAR_FORM_COUNT-1})185    => ScalarRightModifier186begin187    let raw = DecodeScalarOperandRaw(188        instruction,189        form,190        ScalarField_SrcRType)[1:0];191    return DecodeScalarBinaryRightModifier(raw);192end;193
194pure func ScalarDecodedComparisonRightModifier(195    instruction: bits(48), form: integer {0..PTO_SCALAR_FORM_COUNT-1})196    => ScalarRightModifier197begin198    let raw = DecodeScalarOperandRaw(199        instruction,200        form,201        ScalarField_SrcRType)[1:0];202    return DecodeScalarComparisonRightModifier(raw);203end;204
205pure func ScalarDecodedSelectRightModifier(206    instruction: bits(48), form: integer {0..PTO_SCALAR_FORM_COUNT-1})207    => ScalarRightModifier208begin209    let raw = DecodeScalarOperandRaw(210        instruction,211        form,212        ScalarField_SrcRType)[1:0];213    return DecodeScalarSelectRightModifier(raw);214end;215
216pure func ScalarDecodedAddressRightModifier(217    instruction: bits(48), form: integer {0..PTO_SCALAR_FORM_COUNT-1})218    => ScalarRightModifier219begin220    let raw = DecodeScalarOperandRaw(221        instruction,222        form,223        ScalarField_SrcRType)[1:0];224    return DecodeScalarAddressRightModifier(raw);225end;226
227readonly func ReadDecodedScalarRegister(instruction: bits(48),228                                        form: integer {0..PTO_SCALAR_FORM_COUNT-1},229                                        field: ScalarOperandField) => Word230begin231    return ReadScalarRegisterOperand(ScalarDecodedSelector(instruction, form, field));232end;233