wip cfg

Author: acuarica

src/ast.ts

@@ -1,6 +1,6 @@
-import type { Block } from './sevm.ts';
+import type { State } from './sevm.ts';
 
-export function buildAST(bbs: Map<number, Block[]>) {
+export function buildAST(bbs: Map<number, State[]>) {
     const preds = f(bbs);
     const { tree } = domTree(preds);
     return ast(0, tree, preds);
@@ -112,12 +112,12 @@ function domTree(cfg: Map<number, Set<number>>) {
     }
 }
 
-function f(bbs: Map<number, Block[]>) {
+function f(bbs: Map<number, State[]>) {
     const cfg = new Map<number, Set<number>>();
 
     for (const [pc, bs] of bbs.entries()) {
         for (const b of bs) {
-            for (const t of b.targets) {
+            for (const t of b.branches) {
                 let entry = cfg.get(t.pc);
                 if (entry === undefined) {
                     entry = new Set();

src/bytes.ts

@@ -44,3 +44,16 @@ export function arrayify(data: Uint8Array | ArrayLike<number> | string): Uint8Ar
 export function hexlify(data: Uint8Array): string {
     return data.reduce((str, elem) => str + elem.toString(16).padStart(2, '0'), '');
 }
+
+/**
+ * 
+ * @param data 
+ * @returns 
+ */
+export function bigintify(data: Uint8Array): bigint {
+    let result = 0n;
+    for (let i = data.length - 1, s = 0n; i >= 0; i--, s += 8n) 
+        result += BigInt(data[i]) << s;
+
+    return result;
+}

src/contract.ts

@@ -1,10 +1,10 @@
 import { arrayify } from './bytes.ts';
 import { type Metadata, parseMetadata } from './metadata.ts';
-import { type Block, Sevm } from './sevm.ts';
+import { type State, Sevm } from './sevm.ts';
 import { Shanghai } from './forks.ts';
 // import { buildAST } from './ast.ts';
 // import { yul } from './yul.ts';
-import { Selectors } from './selectors.ts';
+// import { Selectors } from './selectors.ts';
 
 // export function x(bytecode: Uint8Array) {
 //     return sevm(bytecode, 0, undefined as unknown as State, new Frontier());
@@ -22,23 +22,29 @@ export class Contract {
      */
     readonly metadata: Metadata | undefined;
 
-    readonly states: Map<number, Block[]>;
+    readonly step;
+
+    readonly states: Map<number, State[]>;
 
     /**
      *
      * @param bytecode the Contract's bytecode to analyze.
      */
-    constructor(bytecode: Parameters<typeof arrayify>[0]) {
+    constructor(bytecode: Parameters<typeof arrayify>[0], Step = /*Selectors*/(Shanghai)) {
         this.bytecode = arrayify(bytecode);
         this.metadata = parseMetadata(this.bytecode).metadata;
-        this.states = new Sevm(new (Selectors(Shanghai))(), this.bytecode).run();
-
-        // const K = Selectors(Shanghai);
-        // const s = new K();
-        // s.decode()
-        // s.publicBranches
+        this.step = new Step();
+        // this.states = new Sevm(this.step, this.bytecode).run();
+        this.states = new Sevm(this.step, this.bytecode).go();
     }
 
+    /**
+     * 
+     */
+    // get selectors(): string[] {
+    //     return [...this.step.publicBranches.keys()];
+    // }
+
     /**
      * https://docs.soliditylang.org/en/latest/yul.html
      */

src/forks.ts

@@ -1,41 +1,41 @@
 import { mapValues, range, zip } from './lib/object.ts';
-import { hexlify } from './bytes.ts';
+import { bigintify } from './bytes.ts';
 import { Dispatch, type Opcode } from './decode.ts';
 import { Inst, Local, Lit, SExpr, Def } from './sexpr.ts';
 import type { State, StepFn, Step } from './sevm.ts';
 
-function addLocal({ insts, stack }: State, expr: SExpr, pc: number) {
-    const local = new Local(insts.length, expr);
-    insts.push(new Def(local, pc));
-    stack.push(local);
+const sexpr = (inputs: number) => function (this: IAddLocal, state: State, op: Opcode) {
+    return this.addLocal(state, new SExpr(op.mnemonic.toLowerCase(), state.stack.popn(inputs)), op.pc);
 }
 
-const sexpr = (inputs: number) => function (state: State, op: Opcode) {
-    addLocal(state, new SExpr(op.mnemonic.toLowerCase(), state.stack.popn(inputs)), op.pc);
+const sinst = (inputs: number) => function (state: State, op: Opcode) {
+    return new Inst(op.mnemonic.toLowerCase(), state.stack.popn(inputs), op.pc);
 }
 
-const sinst = (inputs: number) => function ({ insts, stack }: State, op: Opcode) {
-    insts.push(new Inst(op.mnemonic.toLowerCase(), stack.popn(inputs), op.pc));
+interface IAddLocal {
+    addLocal(state: State, expr: SExpr, pc: number): Inst;
 }
 
 function ForkFactory<M extends string>(
     def: { [m in M]: { op: number, size?: number, step: StepFn } },
     invalid: NoInfer<M>,
 ): new () => Dispatch<M> & Step<M> {
-    class Fork extends Dispatch<M> {
+    class Fork extends Dispatch<M> implements IAddLocal {
+        readonly #locals = new WeakMap<State, number>();
+
         constructor() {
             super(def, invalid);
         }
 
-        decode1() {
-            return this.decode(null as unknown as Uint8Array, 0);
-        }
-        *decode2() {
-            yield this.decode(null as unknown as Uint8Array, 0);
+        addLocal(state: State, expr: SExpr, pc: number) {
+            const id = this.#locals.get(state) ?? 0;
+            this.#locals.set(state, id + 1);
+
+            const local = new Local(state.pcbegin, id, expr);
+            state.stack.push(local);
+            // state.insts.push(new Def(local, pc));
+            return new Def(local, pc);
         }
-        // *decode3(pc0: number): Generator<Opcode & {mnemonic: number}, void, unknown> {
-        //     yield* this.decode(null as unknown as Uint8Array, pc0);
-        // }
     }
     Object.assign(Fork.prototype, mapValues(def, op => op.step));
     return Fork as (new () => Dispatch<M> & Step<M>);
@@ -48,15 +48,20 @@ const FlowDef = {
     JUMPDEST: { op: 0x5B, step: sinst(0) },
     ...zip(range(32).map(i => [
         `PUSH${i + 1 as Size<32>}`,
-        { op: 0x60 + i, size: i + 1, step: (state, op) => addLocal(state, new Lit(BigInt('0x' + hexlify(op.data!))), op.pc) }
+        {
+            op: 0x60 + i, size: i + 1, step: function (this: IAddLocal, state, op) {
+                // return this.addLocal(state, new Lit(BigInt('0x' + hexlify(op.data!))), op.pc);
+                return this.addLocal(state, new Lit(bigintify(op.data!)), op.pc);
+            }
+        }
     ] as const)),
     ...zip(range(16).map(i => [
         `DUP${i + 1 as Size<16>}`,
-        { op: 0x80 + i, step: ({ stack }) => stack.dup(i) }
+        { op: 0x80 + i, step: ({ stack }) => (stack.dup(i), undefined) }
     ] as const)),
     ...zip(range(16).map(i => [
         `SWAP${i + 1 as Size<16>}`,
-        { op: 0x90 + i, step: ({ stack }) => stack.swap(i + 1) }
+        { op: 0x90 + i, step: ({ stack }) => (stack.swap(i + 1), undefined) }
     ] as const)),
     INVALID: { op: 0xfe, step: sinst(0) },
 } satisfies Parameters<typeof ForkFactory>[0];
@@ -157,7 +162,11 @@ const ParisDef = {
 
 const ShanghaiDef = {
     ...ParisDef,
-    PUSH0: { op: 0x5F, step: (state, op) => addLocal(state, new Lit(0n), op.pc) },
+    PUSH0: {
+        op: 0x5F, step: function (this: IAddLocal, state, op) {
+            this.addLocal(state, new Lit(0n), op.pc)
+        }
+    },
 } satisfies Parameters<typeof ForkFactory>[0];
 
 export const Flow = ForkFactory(FlowDef, 'INVALID');

src/selectors.ts

@@ -1,8 +1,8 @@
 import type { Opcode } from './decode.ts';
-import { Lit, type Local, type SExpr } from './sexpr.ts';
+import { type Inst, Lit, type Local, type SExpr } from './sexpr.ts';
 import type { State, Step } from './sevm.ts';
 
-interface IPublicBranches {
+export interface IPublicBranches {
 
     /**
      * 
@@ -25,19 +25,21 @@ function JMP<T extends Cons<Step<'JUMPI'>>>(Klass: T): T & Cons<IPublicBranches>
         readonly selectors: IPublicBranches['selectors'] = new WeakMap();
         readonly publicBranches: IPublicBranches['publicBranches'] = new Map();
 
-        JUMPI = (state: State, opcode: Opcode) => {
-            super.JUMPI(state, opcode);
-            const [offset, cond] = state.insts.at(-1)!.args;
+        JUMPI = (state: State, opcode: Opcode): Inst => {
+            const inst = super.JUMPI(state, opcode)!;
+            const [offset, cond] = inst.args;
 
-            // const selector = cond.props['selector'];
             const selector = this.selectors.get(cond);
             if (typeof selector === 'string') {
+                console.log('selector')
                 // const [pc, contBranch] = cond.positive ? [destpc, fallBranch] : [opcode.pc + 1, destBranch];
                 if (offset.expr instanceof Lit) {
                     const pc = Number(offset.expr.value);
                     this.publicBranches.set(selector, { pc, state });
                 }
             }
+
+            return inst;
         }
     };
 }
@@ -49,9 +51,8 @@ function JMP<T extends Cons<Step<'JUMPI'>>>(Klass: T): T & Cons<IPublicBranches>
  */
 function DivExpEQ<T extends Cons<Step<'EQ'>>>(Klass: T): T {
     return class extends Klass {
-        EQ = (state: State, opcode: Opcode) => {
-            super.EQ(state, opcode);
-
+        EQ = (state: State, opcode: Opcode): Inst => {
+            const inst = super.EQ(state, opcode)!;
             const [left, right] = state.stack.top!;
 
             const rr = right.args[1];
@@ -71,6 +72,8 @@ function DivExpEQ<T extends Cons<Step<'EQ'>>>(Klass: T): T {
                     console.log(s);
                 }
             }
+
+            return inst;
         }
     };
 }
@@ -91,8 +94,8 @@ function isSelectorCallData(expr: SExpr) {
 
 function ShrEQ<T extends Cons<IPublicBranches & Step<'EQ'>>>(Klass: T): T {
     return class extends Klass {
-        override EQ = (state: State, opcode: Opcode) => {
-            super.EQ(state, opcode);
+        override EQ = (state: State, opcode: Opcode): Inst => {
+            const inst = super.EQ(state, opcode)!;
 
             const SHRsig = (left: SExpr, right: SExpr): string | undefined => {
                 return left instanceof Lit && isSelectorCallData(right)
@@ -105,6 +108,8 @@ function ShrEQ<T extends Cons<IPublicBranches & Step<'EQ'>>>(Klass: T): T {
                 this.selectors.set(state.stack.top!, sig);
                 // state.stack.top!.props['selector'] = sig;
             }
+
+            return inst;
         }
     };
 }