@futpib/parser 1.0.2 → 1.0.3

package/build/arbitraryDalvikBytecode.js

@@ -0,0 +1,640 @@
+import * as fc from 'fast-check';
+import { isoIndexIntoStringIds, isoIndexIntoTypeIds, isoIndexIntoMethodIds, isoIndexIntoFieldIds, isoIndexIntoPrototypeIds, } from './dalvikExecutableParser/typedNumbers.js';
+// Arbitrary generators for typed indexes
+const arbitraryIndexIntoStringIds = fc
+    .nat({ max: 65535 })
+    .map(n => isoIndexIntoStringIds.wrap(n));
+const arbitraryIndexIntoTypeIds = fc
+    .nat({ max: 65535 })
+    .map(n => isoIndexIntoTypeIds.wrap(n));
+const arbitraryIndexIntoMethodIds = fc
+    .nat({ max: 65535 })
+    .map(n => isoIndexIntoMethodIds.wrap(n));
+const arbitraryIndexIntoFieldIds = fc
+    .nat({ max: 65535 })
+    .map(n => isoIndexIntoFieldIds.wrap(n));
+const arbitraryIndexIntoPrototypeIds = fc
+    .nat({ max: 65535 })
+    .map(n => isoIndexIntoPrototypeIds.wrap(n));
+// Arbitrary register number (4-bit or 8-bit or 16-bit depending on format)
+const arbitraryRegister4 = fc.nat({ max: 15 });
+const arbitraryRegister8 = fc.nat({ max: 255 });
+const arbitraryRegister16 = fc.nat({ max: 65535 });
+// Arbitrary values for const operations
+const arbitraryNibbleValue = fc.integer({ min: -8, max: 7 }); // 4-bit signed
+const arbitraryByteValue = fc.integer({ min: -128, max: 127 }); // 8-bit signed
+const arbitraryShortValue = fc.integer({ min: -32768, max: 32767 }); // 16-bit signed
+const arbitraryIntValue = fc.integer({ min: -2147483648, max: 2147483647 }); // 32-bit signed
+const arbitraryLongValue = fc.bigInt({ min: -9223372036854775808n, max: 9223372036854775807n }); // 64-bit signed
+// Arbitrary branch offsets (relative)
+const arbitraryBranchOffset8 = fc.integer({ min: -128, max: 127 });
+const arbitraryBranchOffset16 = fc.integer({ min: -32768, max: 32767 });
+const arbitraryBranchOffset32 = fc.integer({ min: -2147483648, max: 2147483647 });
+// No-operation
+const arbitraryNop = fc.constant({
+    operation: 'nop',
+});
+// Move operations (Format 12x)
+const arbitraryMove = fc.record({
+    operation: fc.constant('move'),
+    registers: fc.tuple(arbitraryRegister4, arbitraryRegister4),
+});
+const arbitraryMoveWide = fc.record({
+    operation: fc.constant('move-wide'),
+    registers: fc.tuple(arbitraryRegister4, arbitraryRegister4),
+});
+const arbitraryMoveObject = fc.record({
+    operation: fc.constant('move-object'),
+    registers: fc.tuple(arbitraryRegister4, arbitraryRegister4),
+});
+// Move operations (Format 22x - from16)
+const arbitraryMoveFrom16 = fc.record({
+    operation: fc.constant('move/from16'),
+    registers: fc.tuple(arbitraryRegister8, arbitraryRegister16),
+});
+const arbitraryMoveWideFrom16 = fc.record({
+    operation: fc.constant('move-wide/from16'),
+    registers: fc.tuple(arbitraryRegister8, arbitraryRegister16),
+});
+const arbitraryMoveObjectFrom16 = fc.record({
+    operation: fc.constant('move-object/from16'),
+    registers: fc.tuple(arbitraryRegister8, arbitraryRegister16),
+});
+// Move operations (Format 32x - /16)
+const arbitraryMoveWide16 = fc.record({
+    operation: fc.constant('move-wide/16'),
+    registers: fc.tuple(arbitraryRegister16, arbitraryRegister16),
+});
+// Move-result operations (Format 11x)
+const arbitraryMoveResult = fc.record({
+    operation: fc.constant('move-result'),
+    registers: fc.tuple(arbitraryRegister8),
+});
+const arbitraryMoveResultWide = fc.record({
+    operation: fc.constant('move-result-wide'),
+    registers: fc.tuple(arbitraryRegister8),
+});
+const arbitraryMoveResultObject = fc.record({
+    operation: fc.constant('move-result-object'),
+    registers: fc.tuple(arbitraryRegister8),
+});
+const arbitraryMoveException = fc.record({
+    operation: fc.constant('move-exception'),
+    registers: fc.tuple(arbitraryRegister8),
+});
+// Return operations
+const arbitraryReturnVoid = fc.constant({
+    operation: 'return-void',
+});
+const arbitraryReturn = fc.record({
+    operation: fc.constant('return'),
+    registers: fc.tuple(arbitraryRegister8),
+});
+const arbitraryReturnWide = fc.record({
+    operation: fc.constant('return-wide'),
+    registers: fc.tuple(arbitraryRegister8),
+});
+const arbitraryReturnObject = fc.record({
+    operation: fc.constant('return-object'),
+    registers: fc.tuple(arbitraryRegister8),
+});
+// Const operations
+const arbitraryConst4 = fc.record({
+    operation: fc.constant('const/4'),
+    registers: fc.tuple(arbitraryRegister4),
+    value: arbitraryNibbleValue,
+});
+const arbitraryConst16 = fc.record({
+    operation: fc.constant('const/16'),
+    registers: fc.tuple(arbitraryRegister8),
+    value: arbitraryShortValue,
+});
+const arbitraryConst = fc.record({
+    operation: fc.constant('const'),
+    registers: fc.tuple(arbitraryRegister8),
+    value: arbitraryIntValue,
+});
+const arbitraryConstHigh16 = fc.record({
+    operation: fc.constant('const/high16'),
+    registers: fc.tuple(arbitraryRegister8),
+    // Parser shifts left by 16, so value is stored pre-shifted
+    value: arbitraryShortValue.map(v => v << 16),
+});
+const arbitraryConstWide16 = fc.record({
+    operation: fc.constant('const-wide/16'),
+    registers: fc.tuple(arbitraryRegister8),
+    // Parser stores value as-is (no shift for const-wide/16)
+    value: fc.integer({ min: -32768, max: 32767 }).map(v => BigInt(v)),
+});
+const arbitraryConstWide32 = fc.record({
+    operation: fc.constant('const-wide/32'),
+    registers: fc.tuple(arbitraryRegister8),
+    // Parser stores value as-is (no shift for const-wide/32)
+    value: fc.integer({ min: -2147483648, max: 2147483647 }).map(v => BigInt(v)),
+});
+const arbitraryConstWide = fc.record({
+    operation: fc.constant('const-wide'),
+    registers: fc.tuple(arbitraryRegister8),
+    value: arbitraryLongValue,
+});
+const arbitraryConstWideHigh16 = fc.record({
+    operation: fc.constant('const-wide/high16'),
+    registers: fc.tuple(arbitraryRegister8),
+    // Parser shifts value left by 48 bits, so generate pre-shifted values
+    value: fc.integer({ min: -32768, max: 32767 }).map(v => BigInt(v) << 48n),
+});
+const arbitraryConstString = fc.record({
+    operation: fc.constant('const-string'),
+    registers: fc.tuple(arbitraryRegister8),
+    stringIndex: arbitraryIndexIntoStringIds,
+});
+const arbitraryConstStringJumbo = fc.record({
+    operation: fc.constant('const-string/jumbo'),
+    registers: fc.tuple(arbitraryRegister8),
+    stringIndex: arbitraryIndexIntoStringIds,
+});
+const arbitraryConstClass = fc.record({
+    operation: fc.constant('const-class'),
+    registers: fc.tuple(arbitraryRegister8),
+    typeIndex: arbitraryIndexIntoTypeIds,
+});
+const arbitraryConstMethodHandle = fc.record({
+    operation: fc.constant('const-method-handle'),
+    registers: fc.tuple(arbitraryRegister8),
+    methodIndex: arbitraryIndexIntoMethodIds,
+});
+// Monitor operations
+const arbitraryMonitorEnter = fc.record({
+    operation: fc.constant('monitor-enter'),
+    registers: fc.tuple(arbitraryRegister8),
+});
+const arbitraryMonitorExit = fc.record({
+    operation: fc.constant('monitor-exit'),
+    registers: fc.tuple(arbitraryRegister8),
+});
+// Type operations
+const arbitraryCheckCast = fc.record({
+    operation: fc.constant('check-cast'),
+    registers: fc.tuple(arbitraryRegister8),
+    typeIndex: arbitraryIndexIntoTypeIds,
+});
+const arbitraryInstanceOf = fc.record({
+    operation: fc.constant('instance-of'),
+    registers: fc.tuple(arbitraryRegister4, arbitraryRegister4),
+    typeIndex: arbitraryIndexIntoTypeIds,
+});
+const arbitraryNewInstance = fc.record({
+    operation: fc.constant('new-instance'),
+    registers: fc.tuple(arbitraryRegister8),
+    typeIndex: arbitraryIndexIntoTypeIds,
+});
+const arbitraryNewArray = fc.record({
+    operation: fc.constant('new-array'),
+    registers: fc.tuple(arbitraryRegister4, arbitraryRegister4),
+    typeIndex: arbitraryIndexIntoTypeIds,
+});
+// Array operations
+const arbitraryArrayLength = fc.record({
+    operation: fc.constant('array-length'),
+    registers: fc.tuple(arbitraryRegister4, arbitraryRegister4),
+});
+const arbitraryThrow = fc.record({
+    operation: fc.constant('throw'),
+    registers: fc.tuple(arbitraryRegister8),
+});
+// Goto operations
+const arbitraryGoto = fc.record({
+    operation: fc.constant('goto'),
+    branchOffset: arbitraryBranchOffset8,
+});
+const arbitraryGoto16 = fc.record({
+    operation: fc.constant('goto/16'),
+    branchOffset: arbitraryBranchOffset16,
+});
+const arbitraryGoto32 = fc.record({
+    operation: fc.constant('goto/32'),
+    branchOffset: arbitraryBranchOffset32,
+});
+// Switch operations
+const arbitraryPackedSwitch = fc.record({
+    operation: fc.constant('packed-switch'),
+    registers: fc.tuple(arbitraryRegister8),
+    branchOffset: arbitraryBranchOffset32,
+});
+const arbitrarySparseSwitch = fc.record({
+    operation: fc.constant('sparse-switch'),
+    registers: fc.tuple(arbitraryRegister8),
+    branchOffset: arbitraryBranchOffset32,
+});
+const arbitraryFillArrayData = fc.record({
+    operation: fc.constant('fill-array-data'),
+    registers: fc.tuple(arbitraryRegister8),
+    branchOffset: arbitraryBranchOffset32,
+});
+// Payload operations
+const arbitraryPackedSwitchPayload = fc
+    .nat({ max: 20 })
+    .chain(size => fc.record({
+    operation: fc.constant('packed-switch-payload'),
+    value: arbitraryIntValue,
+    branchOffsets: fc.array(arbitraryBranchOffset32, { minLength: size, maxLength: size }),
+}));
+const arbitrarySparseSwitchPayload = fc
+    .nat({ max: 20 })
+    .chain(size => fc.record({
+    operation: fc.constant('sparse-switch-payload'),
+    keys: fc.array(arbitraryIntValue, { minLength: size, maxLength: size }),
+    branchOffsets: fc.array(arbitraryBranchOffset32, { minLength: size, maxLength: size }),
+}));
+const arbitraryFillArrayDataPayload = fc
+    .record({
+    elementWidth: fc.constantFrom(1, 2, 4, 8),
+    size: fc.nat({ max: 100 }),
+})
+    .chain(({ elementWidth, size }) => fc.record({
+    operation: fc.constant('fill-array-data-payload'),
+    elementWidth: fc.constant(elementWidth),
+    // Data array contains bytes, so length must be size * elementWidth
+    data: fc.array(fc.nat({ max: 255 }), { minLength: size * elementWidth, maxLength: size * elementWidth }),
+}));
+// If-test operations (Format 22t)
+// Commutative operations (if-eq, if-ne) generate sorted registers to match parser behavior
+const arbitraryIfEqual = fc.record({
+    operation: fc.constant('if-eq'),
+    registers: fc.tuple(arbitraryRegister4, arbitraryRegister4).map(([a, b]) => [a, b].sort((x, y) => x - y)),
+    branchOffset: arbitraryBranchOffset16,
+});
+const arbitraryIfNotEqual = fc.record({
+    operation: fc.constant('if-ne'),
+    registers: fc.tuple(arbitraryRegister4, arbitraryRegister4).map(([a, b]) => [a, b].sort((x, y) => x - y)),
+    branchOffset: arbitraryBranchOffset16,
+});
+const arbitraryIfLessThan = fc.record({
+    operation: fc.constant('if-lt'),
+    registers: fc.tuple(arbitraryRegister4, arbitraryRegister4),
+    branchOffset: arbitraryBranchOffset16,
+});
+const arbitraryIfGreaterThanOrEqualTo = fc.record({
+    operation: fc.constant('if-ge'),
+    registers: fc.tuple(arbitraryRegister4, arbitraryRegister4),
+    branchOffset: arbitraryBranchOffset16,
+});
+const arbitraryIfGreaterThan = fc.record({
+    operation: fc.constant('if-gt'),
+    registers: fc.tuple(arbitraryRegister4, arbitraryRegister4),
+    branchOffset: arbitraryBranchOffset16,
+});
+const arbitraryIfLessThanOrEqualTo = fc.record({
+    operation: fc.constant('if-le'),
+    registers: fc.tuple(arbitraryRegister4, arbitraryRegister4),
+    branchOffset: arbitraryBranchOffset16,
+});
+// If-test-zero operations (Format 21t)
+const arbitraryIfEqualZero = fc.record({
+    operation: fc.constant('if-eqz'),
+    registers: fc.tuple(arbitraryRegister8),
+    branchOffset: arbitraryBranchOffset16,
+});
+const arbitraryIfNotEqualZero = fc.record({
+    operation: fc.constant('if-nez'),
+    registers: fc.tuple(arbitraryRegister8),
+    branchOffset: arbitraryBranchOffset16,
+});
+const arbitraryIfLessThanZero = fc.record({
+    operation: fc.constant('if-ltz'),
+    registers: fc.tuple(arbitraryRegister8),
+    branchOffset: arbitraryBranchOffset16,
+});
+const arbitraryIfGreaterThanOrEqualToZero = fc.record({
+    operation: fc.constant('if-gez'),
+    registers: fc.tuple(arbitraryRegister8),
+    branchOffset: arbitraryBranchOffset16,
+});
+const arbitraryIfGreaterThanZero = fc.record({
+    operation: fc.constant('if-gtz'),
+    registers: fc.tuple(arbitraryRegister8),
+    branchOffset: arbitraryBranchOffset16,
+});
+const arbitraryIfLessThanOrEqualToZero = fc.record({
+    operation: fc.constant('if-lez'),
+    registers: fc.tuple(arbitraryRegister8),
+    branchOffset: arbitraryBranchOffset16,
+});
+// Array element operations (Format 23x)
+const createArbitraryArrayElementOperation = (operation) => fc.record({
+    operation: fc.constant(operation),
+    registers: fc.tuple(arbitraryRegister8, arbitraryRegister8, arbitraryRegister8),
+});
+const arbitraryArrayElementGet = createArbitraryArrayElementOperation('aget');
+const arbitraryArrayElementGetWide = createArbitraryArrayElementOperation('aget-wide');
+const arbitraryArrayElementGetObject = createArbitraryArrayElementOperation('aget-object');
+const arbitraryArrayElementGetBoolean = createArbitraryArrayElementOperation('aget-boolean');
+const arbitraryArrayElementGetByte = createArbitraryArrayElementOperation('aget-byte');
+const arbitraryArrayElementGetChar = createArbitraryArrayElementOperation('aget-char');
+const arbitraryArrayElementGetShort = createArbitraryArrayElementOperation('aget-short');
+const arbitraryArrayElementPut = createArbitraryArrayElementOperation('aput');
+const arbitraryArrayElementPutWide = createArbitraryArrayElementOperation('aput-wide');
+const arbitraryArrayElementPutObject = createArbitraryArrayElementOperation('aput-object');
+const arbitraryArrayElementPutBoolean = createArbitraryArrayElementOperation('aput-boolean');
+const arbitraryArrayElementPutByte = createArbitraryArrayElementOperation('aput-byte');
+const arbitraryArrayElementPutChar = createArbitraryArrayElementOperation('aput-char');
+const arbitraryArrayElementPutShort = createArbitraryArrayElementOperation('aput-short');
+// Instance field operations (Format 22c)
+const createArbitraryInstanceFieldOperation = (operation) => fc.record({
+    operation: fc.constant(operation),
+    registers: fc.tuple(arbitraryRegister4, arbitraryRegister4),
+    fieldIndex: arbitraryIndexIntoFieldIds,
+});
+const arbitraryInstanceFieldGet = createArbitraryInstanceFieldOperation('iget');
+const arbitraryInstanceFieldGetWide = createArbitraryInstanceFieldOperation('iget-wide');
+const arbitraryInstanceFieldGetObject = createArbitraryInstanceFieldOperation('iget-object');
+const arbitraryInstanceFieldGetBoolean = createArbitraryInstanceFieldOperation('iget-boolean');
+const arbitraryInstanceFieldGetByte = createArbitraryInstanceFieldOperation('iget-byte');
+const arbitraryInstanceFieldGetChar = createArbitraryInstanceFieldOperation('iget-char');
+const arbitraryInstanceFieldGetShort = createArbitraryInstanceFieldOperation('iget-short');
+const arbitraryInstanceFieldPut = createArbitraryInstanceFieldOperation('iput');
+const arbitraryInstanceFieldPutWide = createArbitraryInstanceFieldOperation('iput-wide');
+const arbitraryInstanceFieldPutObject = createArbitraryInstanceFieldOperation('iput-object');
+const arbitraryInstanceFieldPutBoolean = createArbitraryInstanceFieldOperation('iput-boolean');
+const arbitraryInstanceFieldPutByte = createArbitraryInstanceFieldOperation('iput-byte');
+const arbitraryInstanceFieldPutChar = createArbitraryInstanceFieldOperation('iput-char');
+const arbitraryInstanceFieldPutShort = createArbitraryInstanceFieldOperation('iput-short');
+// Static field operations (Format 21c)
+const createArbitraryStaticFieldOperation = (operation) => fc.record({
+    operation: fc.constant(operation),
+    registers: fc.tuple(arbitraryRegister8),
+    fieldIndex: arbitraryIndexIntoFieldIds,
+});
+const arbitraryStaticFieldGet = createArbitraryStaticFieldOperation('sget');
+const arbitraryStaticFieldGetWide = createArbitraryStaticFieldOperation('sget-wide');
+const arbitraryStaticFieldGetObject = createArbitraryStaticFieldOperation('sget-object');
+const arbitraryStaticFieldGetBoolean = createArbitraryStaticFieldOperation('sget-boolean');
+const arbitraryStaticFieldGetByte = createArbitraryStaticFieldOperation('sget-byte');
+const arbitraryStaticFieldGetChar = createArbitraryStaticFieldOperation('sget-char');
+const arbitraryStaticFieldGetShort = createArbitraryStaticFieldOperation('sget-short');
+const arbitraryStaticFieldPut = createArbitraryStaticFieldOperation('sput');
+const arbitraryStaticFieldPutWide = createArbitraryStaticFieldOperation('sput-wide');
+const arbitraryStaticFieldPutObject = createArbitraryStaticFieldOperation('sput-object');
+const arbitraryStaticFieldPutBoolean = createArbitraryStaticFieldOperation('sput-boolean');
+const arbitraryStaticFieldPutByte = createArbitraryStaticFieldOperation('sput-byte');
+const arbitraryStaticFieldPutChar = createArbitraryStaticFieldOperation('sput-char');
+const arbitraryStaticFieldPutShort = createArbitraryStaticFieldOperation('sput-short');
+// Invoke operations (Format 35c)
+const createArbitraryInvokeOperation = (operation) => fc
+    .nat({ max: 5 })
+    .chain(registerCount => fc.record({
+    operation: fc.constant(operation),
+    registers: fc.array(arbitraryRegister4, {
+        minLength: registerCount,
+        maxLength: registerCount,
+    }),
+    methodIndex: arbitraryIndexIntoMethodIds,
+}));
+const arbitraryInvokeVirtual = createArbitraryInvokeOperation('invoke-virtual');
+const arbitraryInvokeSuper = createArbitraryInvokeOperation('invoke-super');
+const arbitraryInvokeDirect = createArbitraryInvokeOperation('invoke-direct');
+const arbitraryInvokeStatic = createArbitraryInvokeOperation('invoke-static');
+const arbitraryInvokeInterface = createArbitraryInvokeOperation('invoke-interface');
+// Invoke-range operations (Format 3rc)
+const createArbitraryInvokeRangeOperation = (operation) => fc
+    .nat({ max: 255 })
+    .chain(registerCount => fc.record({
+    operation: fc.constant(operation),
+    registers: fc
+        .nat({ max: 65535 - registerCount })
+        .map(startRegister => Array.from({ length: registerCount }, (_, i) => startRegister + i)),
+    methodIndex: arbitraryIndexIntoMethodIds,
+}));
+const arbitraryInvokeVirtualRange = createArbitraryInvokeRangeOperation('invoke-virtual/range');
+const arbitraryInvokeSuperRange = createArbitraryInvokeRangeOperation('invoke-super/range');
+const arbitraryInvokeDirectRange = createArbitraryInvokeRangeOperation('invoke-direct/range');
+const arbitraryInvokeStaticRange = createArbitraryInvokeRangeOperation('invoke-static/range');
+const arbitraryInvokeInterfaceRange = createArbitraryInvokeRangeOperation('invoke-interface/range');
+// Invoke-polymorphic operations
+const arbitraryInvokePolymorphic = fc
+    .nat({ max: 5 })
+    .chain(registerCount => fc.record({
+    operation: fc.constant('invoke-polymorphic'),
+    registers: fc.array(arbitraryRegister4, {
+        minLength: registerCount,
+        maxLength: registerCount,
+    }),
+    methodIndex: arbitraryIndexIntoMethodIds,
+    protoIndex: arbitraryIndexIntoPrototypeIds,
+}));
+const arbitraryInvokePolymorphicRange = fc
+    .nat({ max: 255 })
+    .chain(registerCount => fc.record({
+    operation: fc.constant('invoke-polymorphic/range'),
+    registers: fc
+        .nat({ max: 65535 - registerCount })
+        .map(startRegister => Array.from({ length: registerCount }, (_, i) => startRegister + i)),
+    methodIndex: arbitraryIndexIntoMethodIds,
+    protoIndex: arbitraryIndexIntoPrototypeIds,
+}));
+// Filled-new-array operations
+const arbitraryFilledNewArray = fc
+    .nat({ max: 5 })
+    .chain(registerCount => fc.record({
+    operation: fc.constant('filled-new-array'),
+    registers: fc.array(arbitraryRegister4, {
+        minLength: registerCount,
+        maxLength: registerCount,
+    }),
+    typeIndex: arbitraryIndexIntoTypeIds,
+}));
+const arbitraryFilledNewArrayRange = fc
+    .nat({ max: 255 })
+    .chain(registerCount => fc.record({
+    operation: fc.constant('filled-new-array/range'),
+    registers: fc
+        .nat({ max: 65535 - registerCount })
+        .map(startRegister => Array.from({ length: registerCount }, (_, i) => startRegister + i)),
+    typeIndex: arbitraryIndexIntoTypeIds,
+}));
+// Binary operations (Format 23x)
+const createArbitraryBinaryOperation = (operation) => fc.record({
+    operation: fc.constant(operation),
+    registers: fc.tuple(arbitraryRegister8, arbitraryRegister8, arbitraryRegister8),
+});
+// Int operations
+const arbitraryAddInt = createArbitraryBinaryOperation('add-int');
+const arbitrarySubInt = createArbitraryBinaryOperation('sub-int');
+const arbitraryMulInt = createArbitraryBinaryOperation('mul-int');
+const arbitraryDivInt = createArbitraryBinaryOperation('div-int');
+const arbitraryRemInt = createArbitraryBinaryOperation('rem-int');
+const arbitraryAndInt = createArbitraryBinaryOperation('and-int');
+const arbitraryOrInt = createArbitraryBinaryOperation('or-int');
+const arbitraryXorInt = createArbitraryBinaryOperation('xor-int');
+const arbitraryShlInt = createArbitraryBinaryOperation('shl-int');
+const arbitraryShrInt = createArbitraryBinaryOperation('shr-int');
+const arbitraryUshrInt = createArbitraryBinaryOperation('ushr-int');
+// Long operations
+const arbitraryAddLong = createArbitraryBinaryOperation('add-long');
+const arbitrarySubLong = createArbitraryBinaryOperation('sub-long');
+const arbitraryMulLong = createArbitraryBinaryOperation('mul-long');
+const arbitraryDivLong = createArbitraryBinaryOperation('div-long');
+const arbitraryRemLong = createArbitraryBinaryOperation('rem-long');
+const arbitraryAndLong = createArbitraryBinaryOperation('and-long');
+const arbitraryOrLong = createArbitraryBinaryOperation('or-long');
+const arbitraryXorLong = createArbitraryBinaryOperation('xor-long');
+const arbitraryShlLong = createArbitraryBinaryOperation('shl-long');
+const arbitraryShrLong = createArbitraryBinaryOperation('shr-long');
+const arbitraryUshrLong = createArbitraryBinaryOperation('ushr-long');
+// Float operations
+const arbitraryAddFloat = createArbitraryBinaryOperation('add-float');
+const arbitrarySubFloat = createArbitraryBinaryOperation('sub-float');
+const arbitraryMulFloat = createArbitraryBinaryOperation('mul-float');
+const arbitraryDivFloat = createArbitraryBinaryOperation('div-float');
+// Double operations
+const arbitraryAddDouble = createArbitraryBinaryOperation('add-double');
+const arbitrarySubDouble = createArbitraryBinaryOperation('sub-double');
+const arbitraryMulDouble = createArbitraryBinaryOperation('mul-double');
+const arbitraryDivDouble = createArbitraryBinaryOperation('div-double');
+const arbitraryRemDouble = createArbitraryBinaryOperation('rem-double');
+// Compare operations
+const arbitraryCmpLong = createArbitraryBinaryOperation('cmp-long');
+const arbitraryCmplFloat = createArbitraryBinaryOperation('cmpl-float');
+const arbitraryCmpgFloat = createArbitraryBinaryOperation('cmpg-float');
+const arbitraryCmplDouble = createArbitraryBinaryOperation('cmpl-double');
+const arbitraryCmpgDouble = createArbitraryBinaryOperation('cmpg-double');
+// Binary operations in-place (Format 12x)
+const createArbitraryBinaryOperationInPlace = (operation) => fc.record({
+    operation: fc.constant(operation),
+    registers: fc.tuple(arbitraryRegister4, arbitraryRegister4),
+});
+const arbitraryAddIntInPlace = createArbitraryBinaryOperationInPlace('add-int/2addr');
+const arbitrarySubIntInPlace = createArbitraryBinaryOperationInPlace('sub-int/2addr');
+const arbitraryMulIntInPlace = createArbitraryBinaryOperationInPlace('mul-int/2addr');
+const arbitraryDivIntInPlace = createArbitraryBinaryOperationInPlace('div-int/2addr');
+const arbitraryRemIntInPlace = createArbitraryBinaryOperationInPlace('rem-int/2addr');
+const arbitraryAndIntInPlace = createArbitraryBinaryOperationInPlace('and-int/2addr');
+const arbitraryOrIntInPlace = createArbitraryBinaryOperationInPlace('or-int/2addr');
+const arbitraryXorIntInPlace = createArbitraryBinaryOperationInPlace('xor-int/2addr');
+const arbitraryShlIntInPlace = createArbitraryBinaryOperationInPlace('shl-int/2addr');
+const arbitraryShrIntInPlace = createArbitraryBinaryOperationInPlace('shr-int/2addr');
+const arbitraryUshrIntInPlace = createArbitraryBinaryOperationInPlace('ushr-int/2addr');
+const arbitraryAddLongInPlace = createArbitraryBinaryOperationInPlace('add-long/2addr');
+const arbitrarySubLongInPlace = createArbitraryBinaryOperationInPlace('sub-long/2addr');
+const arbitraryMulLongInPlace = createArbitraryBinaryOperationInPlace('mul-long/2addr');
+const arbitraryDivLongInPlace = createArbitraryBinaryOperationInPlace('div-long/2addr');
+const arbitraryRemLongInPlace = createArbitraryBinaryOperationInPlace('rem-long/2addr');
+const arbitraryAndLongInPlace = createArbitraryBinaryOperationInPlace('and-long/2addr');
+const arbitraryOrLongInPlace = createArbitraryBinaryOperationInPlace('or-long/2addr');
+const arbitraryXorLongInPlace = createArbitraryBinaryOperationInPlace('xor-long/2addr');
+const arbitraryShlLongInPlace = createArbitraryBinaryOperationInPlace('shl-long/2addr');
+const arbitraryShrLongInPlace = createArbitraryBinaryOperationInPlace('shr-long/2addr');
+const arbitraryUshrLongInPlace = createArbitraryBinaryOperationInPlace('ushr-long/2addr');
+const arbitraryAddFloatInPlace = createArbitraryBinaryOperationInPlace('add-float/2addr');
+const arbitrarySubFloatInPlace = createArbitraryBinaryOperationInPlace('sub-float/2addr');
+const arbitraryMulFloatInPlace = createArbitraryBinaryOperationInPlace('mul-float/2addr');
+const arbitraryDivFloatInPlace = createArbitraryBinaryOperationInPlace('div-float/2addr');
+const arbitraryRemFloatInPlace = createArbitraryBinaryOperationInPlace('rem-float/2addr');
+const arbitraryAddDoubleInPlace = createArbitraryBinaryOperationInPlace('add-double/2addr');
+const arbitrarySubDoubleInPlace = createArbitraryBinaryOperationInPlace('sub-double/2addr');
+const arbitraryMulDoubleInPlace = createArbitraryBinaryOperationInPlace('mul-double/2addr');
+const arbitraryDivDoubleInPlace = createArbitraryBinaryOperationInPlace('div-double/2addr');
+const arbitraryRemDoubleInPlace = createArbitraryBinaryOperationInPlace('rem-double/2addr');
+// Binary operations with literal8 (Format 22b)
+const createArbitraryBinaryOperationLiteral8 = (operation) => fc.record({
+    operation: fc.constant(operation),
+    registers: fc.tuple(arbitraryRegister8, arbitraryRegister8),
+    value: arbitraryByteValue,
+});
+const arbitraryAddIntLiteral8 = createArbitraryBinaryOperationLiteral8('add-int/lit8');
+const arbitraryReverseSubtractIntLiteral8 = createArbitraryBinaryOperationLiteral8('rsub-int/lit8');
+const arbitraryMultiplyIntLiteral8 = createArbitraryBinaryOperationLiteral8('mul-int/lit8');
+const arbitraryDivideIntLiteral8 = createArbitraryBinaryOperationLiteral8('div-int/lit8');
+const arbitraryRemainderIntLiteral8 = createArbitraryBinaryOperationLiteral8('rem-int/lit8');
+const arbitraryAndIntLiteral8 = createArbitraryBinaryOperationLiteral8('and-int/lit8');
+const arbitraryOrIntLiteral8 = createArbitraryBinaryOperationLiteral8('or-int/lit8');
+const arbitraryXorIntLiteral8 = createArbitraryBinaryOperationLiteral8('xor-int/lit8');
+const arbitraryShlIntLiteral8 = createArbitraryBinaryOperationLiteral8('shl-int/lit8');
+const arbitraryShrIntLiteral8 = createArbitraryBinaryOperationLiteral8('shr-int/lit8');
+const arbitraryUshrIntLiteral8 = createArbitraryBinaryOperationLiteral8('ushr-int/lit8');
+// Binary operations with literal16 (Format 22s)
+const createArbitraryBinaryOperationLiteral16 = (operation) => fc.record({
+    operation: fc.constant(operation),
+    registers: fc.tuple(arbitraryRegister4, arbitraryRegister4),
+    value: arbitraryShortValue,
+});
+const arbitraryAddIntLiteral16 = createArbitraryBinaryOperationLiteral16('add-int/lit16');
+const arbitraryReverseSubtractIntLiteral16 = createArbitraryBinaryOperationLiteral16('rsub-int');
+const arbitraryMultiplyIntLiteral16 = createArbitraryBinaryOperationLiteral16('mul-int/lit16');
+const arbitraryDivideIntLiteral16 = createArbitraryBinaryOperationLiteral16('div-int/lit16');
+const arbitraryRemainderIntLiteral16 = createArbitraryBinaryOperationLiteral16('rem-int/lit16');
+const arbitraryAndIntLiteral16 = createArbitraryBinaryOperationLiteral16('and-int/lit16');
+const arbitraryOrIntLiteral16 = createArbitraryBinaryOperationLiteral16('or-int/lit16');
+const arbitraryXorIntLiteral16 = createArbitraryBinaryOperationLiteral16('xor-int/lit16');
+// Unary operations (Format 12x)
+const createArbitraryUnaryOperation = (operation) => fc.record({
+    operation: fc.constant(operation),
+    registers: fc.tuple(arbitraryRegister4, arbitraryRegister4),
+});
+const arbitraryNegateInt = createArbitraryUnaryOperation('neg-int');
+const arbitraryNotInt = createArbitraryUnaryOperation('not-int');
+const arbitraryNegateLong = createArbitraryUnaryOperation('neg-long');
+const arbitraryNotLong = createArbitraryUnaryOperation('not-long');
+const arbitraryNegateFloat = createArbitraryUnaryOperation('neg-float');
+const arbitraryNegateDouble = createArbitraryUnaryOperation('neg-double');
+const arbitraryIntToLong = createArbitraryUnaryOperation('int-to-long');
+const arbitraryIntToFloat = createArbitraryUnaryOperation('int-to-float');
+const arbitraryIntToDouble = createArbitraryUnaryOperation('int-to-double');
+const arbitraryLongToInt = createArbitraryUnaryOperation('long-to-int');
+const arbitraryLongToFloat = createArbitraryUnaryOperation('long-to-float');
+const arbitraryLongToDouble = createArbitraryUnaryOperation('long-to-double');
+const arbitraryFloatToInt = createArbitraryUnaryOperation('float-to-int');
+const arbitraryFloatToLong = createArbitraryUnaryOperation('float-to-long');
+const arbitraryFloatToDouble = createArbitraryUnaryOperation('float-to-double');
+const arbitraryDoubleToInt = createArbitraryUnaryOperation('double-to-int');
+const arbitraryDoubleToLong = createArbitraryUnaryOperation('double-to-long');
+const arbitraryDoubleToFloat = createArbitraryUnaryOperation('double-to-float');
+const arbitraryIntToByte = createArbitraryUnaryOperation('int-to-byte');
+const arbitraryIntToChar = createArbitraryUnaryOperation('int-to-char');
+const arbitraryIntToShort = createArbitraryUnaryOperation('int-to-short');
+// Combine all operations
+export const arbitraryDalvikBytecodeOperation = fc.oneof(arbitraryNop, 
+// Move operations
+arbitraryMove, arbitraryMoveWide, arbitraryMoveObject, arbitraryMoveFrom16, arbitraryMoveWideFrom16, arbitraryMoveObjectFrom16, arbitraryMoveWide16, arbitraryMoveResult, arbitraryMoveResultWide, arbitraryMoveResultObject, arbitraryMoveException, 
+// Return operations
+arbitraryReturnVoid, arbitraryReturn, arbitraryReturnWide, arbitraryReturnObject, 
+// Const operations
+arbitraryConst4, arbitraryConst16, arbitraryConst, arbitraryConstHigh16, arbitraryConstWide16, arbitraryConstWide32, arbitraryConstWide, arbitraryConstWideHigh16, arbitraryConstString, arbitraryConstStringJumbo, arbitraryConstClass, arbitraryConstMethodHandle, 
+// Monitor operations
+arbitraryMonitorEnter, arbitraryMonitorExit, 
+// Type operations
+arbitraryCheckCast, arbitraryInstanceOf, arbitraryNewInstance, arbitraryNewArray, 
+// Array operations
+arbitraryArrayLength, arbitraryThrow, 
+// Goto operations
+arbitraryGoto, arbitraryGoto16, arbitraryGoto32, 
+// Switch operations
+arbitraryPackedSwitch, arbitrarySparseSwitch, arbitraryFillArrayData, 
+// Payload operations
+arbitraryPackedSwitchPayload, arbitrarySparseSwitchPayload, arbitraryFillArrayDataPayload, 
+// If-test operations
+arbitraryIfEqual, arbitraryIfNotEqual, arbitraryIfLessThan, arbitraryIfGreaterThanOrEqualTo, arbitraryIfGreaterThan, arbitraryIfLessThanOrEqualTo, 
+// If-test-zero operations
+arbitraryIfEqualZero, arbitraryIfNotEqualZero, arbitraryIfLessThanZero, arbitraryIfGreaterThanOrEqualToZero, arbitraryIfGreaterThanZero, arbitraryIfLessThanOrEqualToZero, 
+// Array element operations
+arbitraryArrayElementGet, arbitraryArrayElementGetWide, arbitraryArrayElementGetObject, arbitraryArrayElementGetBoolean, arbitraryArrayElementGetByte, arbitraryArrayElementGetChar, arbitraryArrayElementGetShort, arbitraryArrayElementPut, arbitraryArrayElementPutWide, arbitraryArrayElementPutObject, arbitraryArrayElementPutBoolean, arbitraryArrayElementPutByte, arbitraryArrayElementPutChar, arbitraryArrayElementPutShort, 
+// Instance field operations
+arbitraryInstanceFieldGet, arbitraryInstanceFieldGetWide, arbitraryInstanceFieldGetObject, arbitraryInstanceFieldGetBoolean, arbitraryInstanceFieldGetByte, arbitraryInstanceFieldGetChar, arbitraryInstanceFieldGetShort, arbitraryInstanceFieldPut, arbitraryInstanceFieldPutWide, arbitraryInstanceFieldPutObject, arbitraryInstanceFieldPutBoolean, arbitraryInstanceFieldPutByte, arbitraryInstanceFieldPutChar, arbitraryInstanceFieldPutShort, 
+// Static field operations
+arbitraryStaticFieldGet, arbitraryStaticFieldGetWide, arbitraryStaticFieldGetObject, arbitraryStaticFieldGetBoolean, arbitraryStaticFieldGetByte, arbitraryStaticFieldGetChar, arbitraryStaticFieldGetShort, arbitraryStaticFieldPut, arbitraryStaticFieldPutWide, arbitraryStaticFieldPutObject, arbitraryStaticFieldPutBoolean, arbitraryStaticFieldPutByte, arbitraryStaticFieldPutChar, arbitraryStaticFieldPutShort, 
+// Invoke operations
+arbitraryInvokeVirtual, arbitraryInvokeSuper, arbitraryInvokeDirect, arbitraryInvokeStatic, arbitraryInvokeInterface, arbitraryInvokeVirtualRange, arbitraryInvokeSuperRange, arbitraryInvokeDirectRange, arbitraryInvokeStaticRange, arbitraryInvokeInterfaceRange, arbitraryInvokePolymorphic, arbitraryInvokePolymorphicRange, 
+// Filled-new-array operations
+arbitraryFilledNewArray, arbitraryFilledNewArrayRange, 
+// Binary operations
+arbitraryAddInt, arbitrarySubInt, arbitraryMulInt, arbitraryDivInt, arbitraryRemInt, arbitraryAndInt, arbitraryOrInt, arbitraryXorInt, arbitraryShlInt, arbitraryShrInt, arbitraryUshrInt, arbitraryAddLong, arbitrarySubLong, arbitraryMulLong, arbitraryDivLong, arbitraryRemLong, arbitraryAndLong, arbitraryOrLong, arbitraryXorLong, arbitraryShlLong, arbitraryShrLong, arbitraryUshrLong, arbitraryAddFloat, arbitrarySubFloat, arbitraryMulFloat, arbitraryDivFloat, arbitraryAddDouble, arbitrarySubDouble, arbitraryMulDouble, arbitraryDivDouble, arbitraryRemDouble, arbitraryCmpLong, arbitraryCmplFloat, arbitraryCmpgFloat, arbitraryCmplDouble, arbitraryCmpgDouble, 
+// Binary operations in-place
+arbitraryAddIntInPlace, arbitrarySubIntInPlace, arbitraryMulIntInPlace, arbitraryDivIntInPlace, arbitraryRemIntInPlace, arbitraryAndIntInPlace, arbitraryOrIntInPlace, arbitraryXorIntInPlace, arbitraryShlIntInPlace, arbitraryShrIntInPlace, arbitraryUshrIntInPlace, arbitraryAddLongInPlace, arbitrarySubLongInPlace, arbitraryMulLongInPlace, arbitraryDivLongInPlace, arbitraryRemLongInPlace, arbitraryAndLongInPlace, arbitraryOrLongInPlace, arbitraryXorLongInPlace, arbitraryShlLongInPlace, arbitraryShrLongInPlace, arbitraryUshrLongInPlace, arbitraryAddFloatInPlace, arbitrarySubFloatInPlace, arbitraryMulFloatInPlace, arbitraryDivFloatInPlace, arbitraryRemFloatInPlace, arbitraryAddDoubleInPlace, arbitrarySubDoubleInPlace, arbitraryMulDoubleInPlace, arbitraryDivDoubleInPlace, arbitraryRemDoubleInPlace, 
+// Binary operations with literal8
+arbitraryAddIntLiteral8, arbitraryReverseSubtractIntLiteral8, arbitraryMultiplyIntLiteral8, arbitraryDivideIntLiteral8, arbitraryRemainderIntLiteral8, arbitraryAndIntLiteral8, arbitraryOrIntLiteral8, arbitraryXorIntLiteral8, arbitraryShlIntLiteral8, arbitraryShrIntLiteral8, arbitraryUshrIntLiteral8, 
+// Binary operations with literal16
+arbitraryAddIntLiteral16, arbitraryReverseSubtractIntLiteral16, arbitraryMultiplyIntLiteral16, arbitraryDivideIntLiteral16, arbitraryRemainderIntLiteral16, arbitraryAndIntLiteral16, arbitraryOrIntLiteral16, arbitraryXorIntLiteral16, 
+// Unary operations
+arbitraryNegateInt, arbitraryNotInt, arbitraryNegateLong, arbitraryNotLong, arbitraryNegateFloat, arbitraryNegateDouble, arbitraryIntToLong, arbitraryIntToFloat, arbitraryIntToDouble, arbitraryLongToInt, arbitraryLongToFloat, arbitraryLongToDouble, arbitraryFloatToInt, arbitraryFloatToLong, arbitraryFloatToDouble, arbitraryDoubleToInt, arbitraryDoubleToLong, arbitraryDoubleToFloat, arbitraryIntToByte, arbitraryIntToChar, arbitraryIntToShort);
+// Arbitrary for complete Dalvik bytecode (array of operations)
+export const arbitraryDalvikBytecode = fc.array(arbitraryDalvikBytecodeOperation, { minLength: 0, maxLength: 100 });

package/build/arbitraryDalvikExecutable.d.ts

@@ -0,0 +1,3 @@
+import * as fc from 'fast-check';
+import { type DalvikExecutable } from './dalvikExecutable.js';
+export declare const createArbitraryDalvikExecutable: <Instructions>(arbitraryInstructions: fc.Arbitrary<Instructions>) => fc.Arbitrary<DalvikExecutable<Instructions>>;