PTO-SCALAR-MODEL-ALU-SEMANTICS

PTO-SCALAR-MODEL-ALU-SEMANTICS

ASL pseudocode

The complete ASL owner is shown directly below.

1// PTO-UNIT: {"id":"PTO-SCALAR-MODEL-ALU-SEMANTICS","surface":"scalar","classification":["model","alu","semantics"],"depends_on":["PTO-SCALAR-MODEL-TYPES-OPERANDS"]}2// PTO-REQ-SCALAR-ALU-001: PTO integer, logic, and shift value rules.3
4pure func MultiplyWord(left: Word, right: Word) => Word5begin6    var result: Word = Zeros{PTO_XLEN};7    for bit_index = 0 to PTO_XLEN - 1 do8        if right[bit_index] == '1' then9            result = result + LSL(left, bit_index);10        end;11    end;12    return result;13end;14
15pure func DivideWordUnsigned(dividend: Word, divisor: Word) => Word16begin17    assert !IsZero(divisor);18    var quotient: Word = Zeros{PTO_XLEN};19    var remainder: bits(PTO_XLEN + 1) = Zeros{PTO_XLEN + 1};20    let extended_divisor: bits(PTO_XLEN + 1) = ZeroExtend{PTO_XLEN + 1}(divisor);21    for bit_index = PTO_XLEN - 1 downto 0 do22        remainder = LSL(remainder, 1);23        remainder[0] = dividend[bit_index];24        if UInt(remainder) >= UInt(extended_divisor) then25            remainder = remainder - extended_divisor;26            quotient[bit_index] = '1';27        end;28    end;29    return quotient;30end;31
32pure func ScalarDivideUnsigned(dividend: Word, divisor: Word) => Word33begin34    if IsZero(divisor) then return Zeros{PTO_XLEN};35    else return DivideWordUnsigned(dividend, divisor);36    end;37end;38
39pure func ScalarRemainderUnsigned(dividend: Word, divisor: Word) => Word40begin41    if IsZero(divisor) then return dividend; end;42    let quotient = DivideWordUnsigned(dividend, divisor);43    return dividend - MultiplyWord(quotient, divisor);44end;45
46pure func ScalarDivideSigned(dividend: Word, divisor: Word) => Word47begin48    if IsZero(divisor) then return Zeros{PTO_XLEN}; end;49    let dividend_negative = dividend[PTO_XLEN - 1] == '1';50    let divisor_negative = divisor[PTO_XLEN - 1] == '1';51    let dividend_magnitude = if dividend_negative then Zeros{PTO_XLEN} - dividend else dividend;52    let divisor_magnitude = if divisor_negative then Zeros{PTO_XLEN} - divisor else divisor;53    let magnitude = DivideWordUnsigned(dividend_magnitude, divisor_magnitude);54    if dividend_negative != divisor_negative then return Zeros{PTO_XLEN} - magnitude;55    else return magnitude;56    end;57end;58
59pure func ScalarRemainderSigned(dividend: Word, divisor: Word) => Word60begin61    if IsZero(divisor) then return dividend; end;62    let quotient = ScalarDivideSigned(dividend, divisor);63    return dividend - MultiplyWord(quotient, divisor);64end;65
66pure func ScalarDivideUnsignedW(dividend: Word, divisor: Word) => Word67begin68    let dividend32 = ZeroExtend{PTO_XLEN}(dividend[31:0]);69    let divisor32 = ZeroExtend{PTO_XLEN}(divisor[31:0]);70    let quotient = ScalarDivideUnsigned(dividend32, divisor32);71    return SignExtend{PTO_XLEN}(quotient[31:0]);72end;73
74pure func ScalarRemainderUnsignedW(dividend: Word, divisor: Word) => Word75begin76    let dividend32 = ZeroExtend{PTO_XLEN}(dividend[31:0]);77    let divisor32 = ZeroExtend{PTO_XLEN}(divisor[31:0]);78    let remainder = ScalarRemainderUnsigned(dividend32, divisor32);79    return SignExtend{PTO_XLEN}(remainder[31:0]);80end;81
82pure func ScalarDivideSignedW(dividend: Word, divisor: Word) => Word83begin84    let dividend32 = SignExtend{PTO_XLEN}(dividend[31:0]);85    let divisor32 = SignExtend{PTO_XLEN}(divisor[31:0]);86    let quotient = ScalarDivideSigned(dividend32, divisor32);87    return SignExtend{PTO_XLEN}(quotient[31:0]);88end;89
90pure func ScalarRemainderSignedW(dividend: Word, divisor: Word) => Word91begin92    let dividend32 = SignExtend{PTO_XLEN}(dividend[31:0]);93    let divisor32 = SignExtend{PTO_XLEN}(divisor[31:0]);94    let remainder = ScalarRemainderSigned(dividend32, divisor32);95    return SignExtend{PTO_XLEN}(remainder[31:0]);96end;97
98pure func ScalarMultiplyW(left: Word, right: Word) => Word99begin100    let left32 = ZeroExtend{PTO_XLEN}(left[31:0]);101    let right32 = ZeroExtend{PTO_XLEN}(right[31:0]);102    let product = MultiplyWord(left32, right32);103    return SignExtend{PTO_XLEN}(product[31:0]);104end;105
106pure func MultiplyWideUnsigned(left: Word, right: Word) => DoubleWord107begin108    var result: DoubleWord = Zeros{PTO_XLEN * 2};109    let extended_left: DoubleWord = ZeroExtend{PTO_XLEN * 2}(left);110    for bit_index = 0 to PTO_XLEN - 1 do111        if right[bit_index] == '1' then result = result + LSL(extended_left, bit_index); end;112    end;113    return result;114end;115
116pure func MultiplyWideSigned(left: Word, right: Word) => DoubleWord117begin118    let left_negative = left[PTO_XLEN - 1] == '1';119    let right_negative = right[PTO_XLEN - 1] == '1';120    let left_magnitude = if left_negative then Zeros{PTO_XLEN} - left else left;121    let right_magnitude = if right_negative then Zeros{PTO_XLEN} - right else right;122    let magnitude = MultiplyWideUnsigned(left_magnitude, right_magnitude);123    if left_negative != right_negative then return Zeros{PTO_XLEN * 2} - magnitude;124    else return magnitude;125    end;126end;127
128pure func RotateRightWord(value: Word, amount: integer {0..63}) => Word129begin130    if amount == 0 then return value;131    else return LSR(value, amount) OR LSL(value, PTO_XLEN - amount);132    end;133end;134
135pure func RotateLeftWord(value: Word, amount: integer {0..63}) => Word136begin137    if amount == 0 then return value;138    else return LSL(value, amount) OR LSR(value, PTO_XLEN - amount);139    end;140end;141
142pure func ExtractBitfield(value: Word, width: integer {1..64},143                          offset: integer {0..63}, signed_result: boolean) => Word144begin145    let rotated = RotateRightWord(value, offset);146    var result: Word = Zeros{PTO_XLEN};147    for bit_index = 0 to width - 1 do result[bit_index] = rotated[bit_index]; end;148    if signed_result && result[width - 1] == '1' then149        for bit_index = width to PTO_XLEN - 1 do result[bit_index] = '1'; end;150    end;151    return result;152end;153
154pure func CountBitfield(value: Word, width: integer {1..64},155                        offset: integer {0..63}, leading: boolean,156                        population: boolean) => Word157begin158    let field = ExtractBitfield(value, width, offset, FALSE);159    var count: integer = 0;160    if population then161        for bit_index = 0 to width - 1 do162            if field[bit_index] == '1' then count = count + 1; end;163        end;164    elsif leading then165        var searching = TRUE;166        for bit_index = 0 to width - 1 do167            let selected = (width - 1) - bit_index;168            if searching && field[selected] == '0' then count = count + 1;169            else searching = FALSE;170            end;171        end;172    else173        var searching = TRUE;174        for bit_index = 0 to width - 1 do175            if searching && field[bit_index] == '0' then count = count + 1;176            else searching = FALSE;177            end;178        end;179    end;180    assert count <= 64;181    return NaturalToWord(count as integer {0..262144});182end;183
184pure func ModifyBitfield(value: Word, width: integer {1..64},185                         offset: integer {0..63}, set_bits: boolean) => Word186begin187    var rotated = RotateRightWord(value, offset);188    for bit_index = 0 to width - 1 do189        rotated[bit_index] = if set_bits then '1' else '0';190    end;191    return RotateLeftWord(rotated, offset);192end;193
194pure func ReverseBitfieldBytes(value: Word, width: integer {1..64},195                               offset: integer {0..63}) => Word196begin197    if width MOD 8 != 0 then return Zeros{PTO_XLEN}; end;198    let field = ExtractBitfield(value, width, offset, FALSE);199    let byte_count = width DIV 8;200    var result: Word = Zeros{PTO_XLEN};201    for byte_index = 0 to byte_count - 1 do202        result[(((byte_count - 1) - byte_index) * 8) +: 8] = field[(byte_index * 8) +: 8];203    end;204    return result;205end;206
207pure func ScalarMultiplyAdd(addend: Word, left: Word, right: Word) => Word208begin209    return addend + MultiplyWord(left, right);210end;211
212pure func ScalarMultiplyAddW(addend: Word, left: Word, right: Word) => Word213begin214    let product = MultiplyWord(left, right);215    let result: bits(32) = product[31:0] + addend[31:0];216    return SignExtend{PTO_XLEN}(result);217end;218
219pure func ScalarConditionalSelect(predicate: Word, selected_true: Word,220                                  selected_false: Word) => Word221begin222    if !IsZero(predicate) then return selected_true; else return selected_false; end;223end;224
225pure func ApplyScalarRightModifier(value: Word, modifier: ScalarRightModifier,226                                   logical_family: boolean) => Word227begin228    case modifier of229        when ScalarRight_None => return value;230        when ScalarRight_SignedWord => return SignExtend{PTO_XLEN}(value[31:0]);231        when ScalarRight_UnsignedWord => return ZeroExtend{PTO_XLEN}(value[31:0]);232        when ScalarRight_NegateOrNot =>233            if logical_family then return NOT(value);234            else return Zeros{PTO_XLEN} - value;235            end;236    end;237end;238
239pure func ApplyRestrictedCompareModifier(value: Word,240                                         modifier: ScalarRightModifier) => Word241begin242    if modifier == ScalarRight_NegateOrNot then return value;243    else return ApplyScalarRightModifier(value, modifier, FALSE);244    end;245end;246
247pure func ApplySelectModifier(value: Word, modifier: ScalarRightModifier) => Word248begin249    if modifier == ScalarRight_NegateOrNot then return Zeros{PTO_XLEN} - value;250    else return value;251    end;252end;253
254pure func PrepareScalarRight(value: Word, modifier: ScalarRightModifier,255                             shift_amount: integer {0..63},256                             logical_family: boolean) => Word257begin258    return LSL(ApplyScalarRightModifier(value, modifier, logical_family), shift_amount);259end;260
261pure func MaterializeLUI(immediate: bits(20)) => Word262begin263    return LSL(SignExtend{PTO_XLEN}(immediate), 12);264end;265
266pure func MaterializeLongSigned(immediate: bits(32)) => Word267begin268    return SignExtend{PTO_XLEN}(immediate);269end;270
271pure func MaterializeLongUpper(immediate: bits(32)) => Word272begin273    return LSL(ZeroExtend{PTO_XLEN}(immediate), 32);274end;275
276pure func MaterializeLongUnsigned(immediate: bits(32)) => Word277begin278    return ZeroExtend{PTO_XLEN}(immediate);279end;280
281// The move primitive is explicit so catalog handler identity and decoded282// operand-to-effect binding do not rely on an unrelated modifier helper.283pure func MoveScalarValue(value: Word) => Word284begin285    return value;286end;287
288pure func ExtendScalarValue(value: Word, width: integer {8,16,32},289                            signed_result: boolean) => Word290begin291    case width of292        when 8 =>293            if signed_result then return SignExtend{PTO_XLEN}(value[7:0]);294            else return ZeroExtend{PTO_XLEN}(value[7:0]); end;295        when 16 =>296            if signed_result then return SignExtend{PTO_XLEN}(value[15:0]);297            else return ZeroExtend{PTO_XLEN}(value[15:0]); end;298        when 32 =>299            if signed_result then return SignExtend{PTO_XLEN}(value[31:0]);300            else return ZeroExtend{PTO_XLEN}(value[31:0]); end;301    end;302end;303
304pure func ScalarMultiplyImmediateAdd(left: Word, right: Word,305                                    immediate: bits(19), subtract: boolean) => Word306begin307    let product = MultiplyWord(right, ZeroExtend{PTO_XLEN}(immediate));308    if subtract then return left - product; else return left + product; end;309end;310
311pure func InsertBitfield(base: Word, source: Word,312                         first: integer {0..63}, last: integer {0..63}) => Word313begin314    let width: integer = (((last - first) + 64) MOD 64) + 1;315    var result = base;316    for bit_index = 0 to width - 1 do317        let destination = ((first + bit_index) MOD 64) as integer {0..63};318        result[destination] = source[bit_index];319    end;320    return result;321end;322
323func ExecuteConcatenatePair(destination_low: Reg5Selector,324                            destination_high: Reg5Selector,325                            left: Word, right: Word,326                            shift_amount: integer {0..127})327begin328    let low = InstructionContractLowResult_HL_CCAT(329        left,330        right,331        shift_amount);332    let high = InstructionContractHighResult_HL_CCAT(333        left,334        right,335        shift_amount);336    WriteScalarDestination(destination_low, low);337    WriteScalarDestination(destination_high, high);338end;339
340func ExecuteConcatenatePairW(destination_low: Reg5Selector,341                             destination_high: Reg5Selector,342                             left: Word, right: Word,343                             shift_amount: integer {0..127})344begin345    let low = InstructionContractLowResult_HL_CCATW(346        left,347        right,348        shift_amount);349    let high = InstructionContractHighResult_HL_CCATW(350        left,351        right,352        shift_amount);353    WriteScalarDestination(destination_low, low);354    WriteScalarDestination(destination_high, high);355end;356
357func ExecuteScalarDividePair(destination_quotient: Reg5Selector,358                             destination_remainder: Reg5Selector,359                             left: Word, right: Word, signed_operation: boolean)360begin361    let quotient = if signed_operation then ScalarDivideSigned(left, right)362                   else ScalarDivideUnsigned(left, right);363    let remainder = if signed_operation then ScalarRemainderSigned(left, right)364                    else ScalarRemainderUnsigned(left, right);365    WriteScalarDestination(destination_quotient, quotient);366    WriteScalarDestination(destination_remainder, remainder);367end;368
369func ExecuteScalarRemainderPair(destination_remainder: Reg5Selector,370                                destination_quotient: Reg5Selector,371                                left: Word, right: Word,372                                signed_operation: boolean)373begin374    let quotient = if signed_operation then ScalarDivideSigned(left, right)375                   else ScalarDivideUnsigned(left, right);376    let remainder = if signed_operation then ScalarRemainderSigned(left, right)377                    else ScalarRemainderUnsigned(left, right);378    WriteScalarDestination(destination_remainder, remainder);379    WriteScalarDestination(destination_quotient, quotient);380end;381
382func ExecuteScalarDividePairW(destination_quotient: Reg5Selector,383                              destination_remainder: Reg5Selector,384                              left: Word, right: Word, signed_operation: boolean)385begin386    let quotient = if signed_operation then ScalarDivideSignedW(left, right)387                   else ScalarDivideUnsignedW(left, right);388    let remainder = if signed_operation then ScalarRemainderSignedW(left, right)389                    else ScalarRemainderUnsignedW(left, right);390    WriteScalarDestination(destination_quotient, quotient);391    WriteScalarDestination(destination_remainder, remainder);392end;393
394func ExecuteScalarRemainderPairW(destination_remainder: Reg5Selector,395                                 destination_quotient: Reg5Selector,396                                 left: Word, right: Word,397                                 signed_operation: boolean)398begin399    let quotient = if signed_operation then ScalarDivideSignedW(left, right)400                   else ScalarDivideUnsignedW(left, right);401    let remainder = if signed_operation then ScalarRemainderSignedW(left, right)402                    else ScalarRemainderUnsignedW(left, right);403    WriteScalarDestination(destination_remainder, remainder);404    WriteScalarDestination(destination_quotient, quotient);405end;406
407func ExecuteScalarMultiplyPair(destination_low: Reg5Selector, destination_high: Reg5Selector,408                               left: Word, right: Word, signed_operation: boolean)409begin410    let product = if signed_operation then MultiplyWideSigned(left, right)411                  else MultiplyWideUnsigned(left, right);412    WriteScalarDestination(destination_low, product[63:0]);413    WriteScalarDestination(destination_high, product[127:64]);414end;415
416func ExecuteScalarMultiplyAddPair(destination_low: Reg5Selector,417                                  destination_high: Reg5Selector,418                                  addend: Word, left: Word, right: Word,419                                  word_operation: boolean)420begin421    let effective_addend = if word_operation then SignExtend{PTO_XLEN}(addend[31:0]) else addend;422    let effective_left = if word_operation then SignExtend{PTO_XLEN}(left[31:0]) else left;423    let effective_right = if word_operation then SignExtend{PTO_XLEN}(right[31:0]) else right;424    let product = MultiplyWideSigned(effective_left, effective_right);425    let accumulator = product + SignExtend{PTO_XLEN * 2}(effective_addend);426    if word_operation then427        WriteScalarDestination(428            destination_low,429            SignExtend{PTO_XLEN}(accumulator[31:0]));430        WriteScalarDestination(431            destination_high,432            SignExtend{PTO_XLEN}(accumulator[63:32]));433    else434        WriteScalarDestination(destination_low, accumulator[63:0]);435        WriteScalarDestination(destination_high, accumulator[127:64]);436    end;437end;438
439pure func NaturalToWord(value: integer {0..262144}) => Word440begin441    var result: Word = Zeros{PTO_XLEN};442    for step = 1 to value looplimit 262145 do443        result = result + 1;444    end;445    return result;446end;447
448pure func ScalarBinary(op: ScalarBinaryOperation, left: Word, right: Word) => Word449begin450    case op of451        when ScalarBinary_ADD => return left + right;452        when ScalarBinary_SUB => return left - right;453        when ScalarBinary_AND => return left AND right;454        when ScalarBinary_OR  => return left OR right;455        when ScalarBinary_XOR => return left XOR right;456        when ScalarBinary_SLL => return LSL(left, UInt(right[5:0]));457        when ScalarBinary_SRL => return LSR(left, UInt(right[5:0]));458        when ScalarBinary_SRA => return ASR(left, UInt(right[5:0]));459        when ScalarBinary_MIN =>460            if SInt(left) < SInt(right) then return left; else return right; end;461        when ScalarBinary_MINU =>462            if UInt(left) < UInt(right) then return left; else return right; end;463        when ScalarBinary_MAX =>464            if SInt(left) > SInt(right) then return left; else return right; end;465        when ScalarBinary_MAXU =>466            if UInt(left) > UInt(right) then return left; else return right; end;467    end;468end;469
470pure func ScalarBinaryW(op: ScalarBinaryOperation, left: Word, right: Word) => Word471begin472    let left32: bits(32) = left[31:0];473    let right32: bits(32) = right[31:0];474    var result32: bits(32);475    case op of476        when ScalarBinary_ADD => result32 = left32 + right32;477        when ScalarBinary_SUB => result32 = left32 - right32;478        when ScalarBinary_AND => result32 = left32 AND right32;479        when ScalarBinary_OR  => result32 = left32 OR right32;480        when ScalarBinary_XOR => result32 = left32 XOR right32;481        when ScalarBinary_SLL => result32 = LSL(left32, UInt(right[4:0]));482        when ScalarBinary_SRL => result32 = LSR(left32, UInt(right[4:0]));483        when ScalarBinary_SRA => result32 = ASR(left32, UInt(right[4:0]));484        otherwise => assert FALSE;485    end;486    return SignExtend{PTO_XLEN}(result32);487end;488
489func ExecuteScalarBinary(op: ScalarBinaryOperation, destination: GPRIndex,490                         source_left: GPRIndex, source_right: GPRIndex)491begin492    let left = ReadGPR(source_left);493    let right = ReadGPR(source_right);494    let result = ScalarBinary(op, left, right);495    WriteGPR(destination, result);496end;497

Architecture behavior

This internal model unit is documented through its normative ASL/NDF owners and validation evidence; it has no reader-guide migration target.

NDF clauses

Bodies come from owning ASL. Dragging or buttons change only this page-session view order.

No NDF clause is attached to this unit.

Evidence index

15 matching entries

Executable evidence10

materialization, move, and control forms resolve queue selectors
1. surfaceSCALAR
2. ownerPTO-SCALAR-MODEL-ALU-SEMANTICS
3. categoryEXECUTION
4. case004
Show exact test source
Sources and references
Complete stable ID
PTO-AVS-SCALAR-ALU-CONTROL-ALIAS-EXEC-004
Path
tests/asl/scalar/model/alu/semantics/scalar-exec-alu-control-alias-004.asl
Kind / role
execution
Pass condition
materialization, move, control, and implicit queue assertions hold
SHA-256
7deb6f22ba07e2d7816988cd46db6fe2baebdfa7f68c7e80422ea3e74119768a
Open exact source ↗ for PTO-AVS-SCALAR-ALU-CONTROL-ALIAS-EXEC-004
scalar ALU GPR aliases snapshot sources before destination writes
1. surfaceSCALAR
2. ownerPTO-SCALAR-MODEL-ALU-SEMANTICS
3. categoryEXECUTION
4. case001
Show exact test source
Sources and references
Complete stable ID
PTO-AVS-SCALAR-ALU-GPR-ALIAS-EXEC-001
Path
tests/asl/scalar/model/alu/semantics/scalar-exec-alu-alias-matrix-001.asl
Kind / role
execution
Pass condition
GPR overlap, zero, and discard-destination assertions hold
SHA-256
d6169122913c70a70484bd3bdaffe717eef5213b2effa13fe01d52bed89669a1
Open exact source ↗ for PTO-AVS-SCALAR-ALU-GPR-ALIAS-EXEC-001
ternary, bitfield, and select operations snapshot overlapping operands
1. surfaceSCALAR
2. ownerPTO-SCALAR-MODEL-ALU-SEMANTICS
3. categoryEXECUTION
4. case003
Show exact test source
Sources and references
Complete stable ID
PTO-AVS-SCALAR-ALU-MULTI-ALIAS-EXEC-003
Path
tests/asl/scalar/model/alu/semantics/scalar-exec-alu-multi-alias-003.asl
Kind / role
execution
Pass condition
ternary, bitfield, and select alias assertions hold
SHA-256
4fd371542d5ef8137c75f8675442735fb959e276aae1e28645dfe828df4a4b1b
Open exact source ↗ for PTO-AVS-SCALAR-ALU-MULTI-ALIAS-EXEC-003
pair-result operations snapshot sources before ordered destinations
1. surfaceSCALAR
2. ownerPTO-SCALAR-MODEL-ALU-SEMANTICS
3. categoryEXECUTION
4. case005
Show exact test source
Sources and references
Complete stable ID
PTO-AVS-SCALAR-ALU-PAIR-ALIAS-EXEC-005
Path
tests/asl/scalar/model/alu/semantics/scalar-exec-alu-pair-alias-005.asl
Kind / role
execution
Pass condition
GPR and queue pair-result alias assertions hold
SHA-256
71b5ee4ea1364a14400e3f50542907b9b3178fa4084c5f59bebf79922af4e6be
Open exact source ↗ for PTO-AVS-SCALAR-ALU-PAIR-ALIAS-EXEC-005
scalar ALU queue operands snapshot every T and U source position
1. surfaceSCALAR
2. ownerPTO-SCALAR-MODEL-ALU-SEMANTICS
3. categoryEXECUTION
4. case002
Show exact test source
Sources and references
Complete stable ID
PTO-AVS-SCALAR-ALU-QUEUE-ALIAS-EXEC-002
Path
tests/asl/scalar/model/alu/semantics/scalar-exec-alu-queue-alias-002.asl
Kind / role
execution
Pass condition
queue source and same-queue push assertions hold
SHA-256
bd8d11adf8ef588a78afd1c8f9840afe44a8d9f47acf699c63460f5a8de61960
Open exact source ↗ for PTO-AVS-SCALAR-ALU-QUEUE-ALIAS-EXEC-002
PTO-SCALAR-MODEL-ALU-SEMANTICS compiles as an independent normative unit
1. surfaceSCALAR
2. ownerPTO-SCALAR-MODEL-ALU-SEMANTICS
3. categorySTATIC-INVARIANT
4. case001
Show exact test source
Sources and references
Complete stable ID
PTO-AVS-SCALAR-MODEL-ALU-SEMANTICS-STATIC-001
Path
tests/asl/scalar/model/alu/semantics/scalar-static-semantics-contract-001.asl
Kind / role
static-invariant
Pass condition
the complete model and this unit's static invariant compile
SHA-256
f2fcf690dd21b67855c017e5a0005a0ce55dcf6e470a232c702736ed1cbd44ac
Open exact source ↗ for PTO-AVS-SCALAR-MODEL-ALU-SEMANTICS-STATIC-001
Covers Scalar Aliasing Order.
1. surfaceSCALAR
2. ownerPTO-SCALAR-MODEL-ALU-SEMANTICS
3. categoryEXECUTION
4. case001
Show exact test source
Sources and references
Complete stable ID
PTO-AVS-SCALAR-TESTSCALARALIASINGORDER-EXECUTION-001
Path
tests/asl/scalar/model/alu/semantics/scalar-exec-aliasing-order-001.asl
Kind / role
execution
Pass condition
TestScalarAliasingOrder completes without assertion failure
SHA-256
9726119c4fc203d1e27fd2b16203fd1e7cd6c267f8dab064ac5966986242d0a6
Open exact source ↗ for PTO-AVS-SCALAR-TESTSCALARALIASINGORDER-EXECUTION-001
Covers Scalar ALU Boundary Matrix.
1. surfaceSCALAR
2. ownerPTO-SCALAR-MODEL-ALU-SEMANTICS
3. categoryBOUNDARY
4. case001
Show exact test source
Sources and references
Complete stable ID
PTO-AVS-SCALAR-TESTSCALARALUBOUNDARYMATRIX-BOUNDARY-001
Path
tests/asl/scalar/model/alu/semantics/scalar-bound-alu-matrix-001.asl
Kind / role
boundary
Pass condition
TestScalarALUBoundaryMatrix completes without assertion failure
SHA-256
d3fe194b51027d06f800382c4324b7248aa84f5fa336683ca2974c3b9a5baf96
Open exact source ↗ for PTO-AVS-SCALAR-TESTSCALARALUBOUNDARYMATRIX-BOUNDARY-001
Covers Scalar Bitfield Boundary Contract.
1. surfaceSCALAR
2. ownerPTO-SCALAR-MODEL-ALU-SEMANTICS
3. categoryBOUNDARY
4. case001
Show exact test source
Sources and references
Complete stable ID
PTO-AVS-SCALAR-TESTSCALARBITFIELDBOUNDARYCONTRACT-BOUNDARY-001
Path
tests/asl/scalar/model/alu/semantics/scalar-bound-bitfield-contract-001.asl
Kind / role
boundary
Pass condition
TestScalarBitfieldBoundaryContract completes without assertion failure
SHA-256
ac3d7fcae6ee548bb5f952c4d96a00319fd72305ff6bb29703f0124af2d0b71d
Open exact source ↗ for PTO-AVS-SCALAR-TESTSCALARBITFIELDBOUNDARYCONTRACT-BOUNDARY-001
Covers Scalar Dispatch Effects.
1. surfaceSCALAR
2. ownerPTO-SCALAR-MODEL-ALU-SEMANTICS
3. categoryEXECUTION
4. case001
Show exact test source
Sources and references
Complete stable ID
PTO-AVS-SCALAR-TESTSCALARDISPATCHEFFECTS-EXECUTION-001
Path
tests/asl/scalar/model/alu/semantics/scalar-exec-dispatch-effects-001.asl
Kind / role
execution
Pass condition
TestScalarDispatchEffects completes without assertion failure
SHA-256
b2e34b975d57c396f462c5cc52557e1b88185859c2feff013ebf3baf9b0ba0aa
Open exact source ↗ for PTO-AVS-SCALAR-TESTSCALARDISPATCHEFFECTS-EXECUTION-001

Commit-scoped evidence5

spec/evidence/release-traceability-readiness.json · closedPTO-EVIDENCE-RELEASE-TRACEABILITY
Sources and references
Complete stable ID
PTO-EVIDENCE-RELEASE-TRACEABILITY
Path
spec/evidence/release-traceability-readiness.json
Kind / role
ASL/NDF/documentation/AVS traceability
SHA-256
c7327021d39dc67ac5564bc55073b3870a397d79ac8d9648284d56e33bc14a3e
Open exact source ↗ for PTO-EVIDENCE-RELEASE-TRACEABILITY
spec/evidence/instruction-contract-closure.json · closedPTO-EVIDENCE-INSTRUCTION-CONTRACT-CLOSURE
Sources and references
Complete stable ID
PTO-EVIDENCE-INSTRUCTION-CONTRACT-CLOSURE
Path
spec/evidence/instruction-contract-closure.json
Kind / role
mnemonic and encoding contract closure
SHA-256
3ef2bb62421c79dff8fa77a1c7983923b523244b8090812883ef81286ca8106a
Open exact source ↗ for PTO-EVIDENCE-INSTRUCTION-CONTRACT-CLOSURE
spec/evidence/architecture-readiness.json · openPTO-EVIDENCE-ARCHITECTURE-READINESS
Sources and references
Complete stable ID
PTO-EVIDENCE-ARCHITECTURE-READINESS
Path
spec/evidence/architecture-readiness.json
Kind / role
architecture maturity and blockers
SHA-256
4b0b85199101251bea744e0f3591cc31906909dc80d5ab651c417a936036a004
Open exact source ↗ for PTO-EVIDENCE-ARCHITECTURE-READINESS
spec/evidence/release-gate-readiness.json · ready-for-exact-head-verificationPTO-EVIDENCE-RELEASE-GATE-READINESS
Sources and references
Complete stable ID
PTO-EVIDENCE-RELEASE-GATE-READINESS
Path
spec/evidence/release-gate-readiness.json
Kind / role
exact-head gate readiness
SHA-256
a0f4d2b6920c08981ea55fd8ef820708a40d4feb5402c5150e8e9ab532d84ce0
Open exact source ↗ for PTO-EVIDENCE-RELEASE-GATE-READINESS
spec/release-manifest.json · draftPTO-EVIDENCE-RELEASE-MANIFEST
Sources and references
Complete stable ID
PTO-EVIDENCE-RELEASE-MANIFEST
Path
spec/release-manifest.json
Kind / role
release content and encoding fingerprints
SHA-256
1a64c109ed7a90351c41e2a418b3c0ebaf8ad975838986d2101385186b85c0d8
Open exact source ↗ for PTO-EVIDENCE-RELEASE-MANIFEST

Unit metadata

Open 4 generated metadata fields

id: PTO-SCALAR-MODEL-ALU-SEMANTICS
surface: scalar
classification: [ "model", "alu", "semantics" ]
depends_on: [ "PTO-SCALAR-MODEL-TYPES-OPERANDS" ]

Open generated traceability record

{
  "classification": [
    "model",
    "alu",
    "semantics"
  ],
  "documentation": "docs/scalar/model/alu/semantics.md",
  "id": "PTO-SCALAR-MODEL-ALU-SEMANTICS",
  "mnemonic": null,
  "readiness_subjects": [],
  "semantic_tests": [
    "PTO-AVS-SCALAR-ALU-CONTROL-ALIAS-EXEC-004",
    "PTO-AVS-SCALAR-ALU-GPR-ALIAS-EXEC-001",
    "PTO-AVS-SCALAR-ALU-MULTI-ALIAS-EXEC-003",
    "PTO-AVS-SCALAR-ALU-PAIR-ALIAS-EXEC-005",
    "PTO-AVS-SCALAR-ALU-QUEUE-ALIAS-EXEC-002",
    "PTO-AVS-SCALAR-TESTSCALARALIASINGORDER-EXECUTION-001",
    "PTO-AVS-SCALAR-TESTSCALARALUBOUNDARYMATRIX-BOUNDARY-001",
    "PTO-AVS-SCALAR-TESTSCALARBITFIELDBOUNDARYCONTRACT-BOUNDARY-001",
    "PTO-AVS-SCALAR-TESTSCALARDISPATCHEFFECTS-EXECUTION-001"
  ],
  "source": "asl/scalar/model/alu/semantics.asl",
  "surface": "scalar",
  "tests": [
    "PTO-AVS-SCALAR-ALU-CONTROL-ALIAS-EXEC-004",
    "PTO-AVS-SCALAR-ALU-GPR-ALIAS-EXEC-001",
    "PTO-AVS-SCALAR-ALU-MULTI-ALIAS-EXEC-003",
    "PTO-AVS-SCALAR-ALU-PAIR-ALIAS-EXEC-005",
    "PTO-AVS-SCALAR-ALU-QUEUE-ALIAS-EXEC-002",
    "PTO-AVS-SCALAR-MODEL-ALU-SEMANTICS-STATIC-001",
    "PTO-AVS-SCALAR-TESTSCALARALIASINGORDER-EXECUTION-001",
    "PTO-AVS-SCALAR-TESTSCALARALUBOUNDARYMATRIX-BOUNDARY-001",
    "PTO-AVS-SCALAR-TESTSCALARBITFIELDBOUNDARYCONTRACT-BOUNDARY-001",
    "PTO-AVS-SCALAR-TESTSCALARDISPATCHEFFECTS-EXECUTION-001"
  ]
}

Sources and release identity

Show commit, paths, hashes, version, and canonical owners

Release: 0.58.5 · Release candidate
Commit: 7dc8b7e5b121d2b2499a2273bebff29e2cd86812
Original ASL: asl/scalar/model/alu/semantics.asl
ASL SHA-256: 3ea286b50965fd9a218d6a5ef9a1f8f230638d0163a734d536b3b6158039ca47
Generated documentation: docs/scalar/model/alu/semantics.md · embedded in this page
Documentation SHA-256: 8cb1eabc757c3ff2d1572a665fcafb85e06dd08136f2156f04959cb9140c8a2f

Exact owners

ASL PTO-SCALAR-MODEL-ALU-SEMANTICS asl/scalar/model/alu/semantics.asl