compiles

Author: mjain-jump

src/flamenco/runtime/fd_executor.c

@@ -405,22 +405,6 @@ fd_executor_verify_transaction( fd_bank_t *         bank,
   return FD_RUNTIME_EXECUTE_SUCCESS;
 }
 
-static void
-fd_executor_setup_instr_infos_from_txn_instrs( fd_runtime_t *      runtime,
-                                               fd_bank_t *         bank,
-                                               fd_txn_in_t const * txn_in,
-                                               fd_txn_out_t *      txn_out ) {
-  ushort instr_cnt = TXN( txn_in->txn )->instr_cnt;
-
-  /* Set up the instr infos for the transaction */
-  for( ushort i=0; i<instr_cnt; i++ ) {
-    fd_txn_instr_t const * instr = &TXN( txn_in->txn )->instr[i];
-    fd_instr_info_init_from_txn_instr( &runtime->instr.infos[i], bank, txn_in, txn_out, instr );
-  }
-
-  runtime->instr.info_cnt = instr_cnt;
-}
-
 /* https://github.com/anza-xyz/agave/blob/v2.0.9/svm/src/account_loader.rs#L410-427 */
 static int
 accumulate_and_check_loaded_account_data_size( ulong   acc_size,
@@ -1173,11 +1157,13 @@ fd_txn_ctx_push( fd_runtime_t *      runtime,
     }
   }
 
-  /* https://github.com/anza-xyz/agave/blob/c4b42ab045860d7b13b3912eafb30e6d2f4e593f/sdk/src/transaction_context.rs#L347-L351 */
-  if( FD_UNLIKELY( runtime->instr.trace_length>=FD_MAX_INSTRUCTION_TRACE_LENGTH ) ) {
+  /* Note that we don't update the trace length here - since the caller
+     allocates out of the trace array, they are also responsible for
+     incrementing the trace length variable.
+     https://github.com/anza-xyz/agave/blob/c4b42ab045860d7b13b3912eafb30e6d2f4e593f/sdk/src/transaction_context.rs#L347-L351 */
+  if( FD_UNLIKELY( runtime->instr.trace_length>FD_MAX_INSTRUCTION_TRACE_LENGTH ) ) {
     return FD_EXECUTOR_INSTR_ERR_MAX_INSN_TRACE_LENS_EXCEEDED;
   }
-  runtime->instr.trace_length++;
 
   /* https://github.com/anza-xyz/agave/blob/c4b42ab045860d7b13b3912eafb30e6d2f4e593f/sdk/src/transaction_context.rs#L352-L356 */
   if( FD_UNLIKELY( runtime->instr.stack_sz>=FD_MAX_INSTRUCTION_STACK_DEPTH ) ) {
@@ -1355,11 +1341,6 @@ fd_execute_instr( fd_runtime_t *      runtime,
   };
   fd_base58_encode_32( txn_out->accounts.accounts[ instr->program_id ].pubkey->uc, NULL, ctx->program_id_base58 );
 
-  runtime->instr.trace[ runtime->instr.trace_length - 1 ] = (fd_exec_instr_trace_entry_t) {
-    .instr_info = instr,
-    .stack_height = runtime->instr.stack_sz,
-  };
-
   /* Look up the native program. We check for precompiles within the lookup function as well.
      https://github.com/anza-xyz/agave/blob/v2.1.6/svm/src/message_processor.rs#L88 */
   fd_exec_instr_fn_t native_prog_fn;
@@ -1601,9 +1582,6 @@ fd_executor_setup_accounts_for_txn( fd_runtime_t *      runtime,
 
   txn_out->accounts.nonce_idx_in_txn = ULONG_MAX;
   runtime->executable.cnt            = executable_idx;
-
-  /* Set up instr infos from the txn descriptor. No Agave equivalent to this function. */
-  fd_executor_setup_instr_infos_from_txn_instrs( runtime, bank, txn_in, txn_out );
 }
 
 int
@@ -1633,19 +1611,41 @@ fd_execute_txn( fd_runtime_t *      runtime,
   bool dump_insn = runtime->log.capture_ctx && fd_bank_slot_get( bank ) >= runtime->log.capture_ctx->dump_proto_start_slot && runtime->log.capture_ctx->dump_instr_to_pb;
   (void)dump_insn;
 
+  fd_txn_t const * txn = TXN( txn_in->txn );
+
   /* Initialize log collection. */
   fd_log_collector_init( runtime->log.log_collector, runtime->log.enable_log_collector );
 
   for( ushort i=0; i<TXN( txn_in->txn )->instr_cnt; i++ ) {
-    runtime->instr.current_idx = i;
+    /* Set up the instr info for the current instruction */
+    fd_instr_info_init_from_txn_instr(
+        &runtime->instr.trace[runtime->instr.trace_length],
+        bank,
+        txn_in,
+        txn_out,
+        &txn->instr[i]
+    );
+
 #   if FD_HAS_FLATCC
     if( FD_UNLIKELY( dump_insn ) ) {
       // Capture the input and convert it into a Protobuf message
-      fd_dump_instr_to_protobuf( runtime, bank, txn_in, txn_out, &runtime->instr.infos[i], i );
+      fd_dump_instr_to_protobuf(
+          runtime,
+          bank,
+          txn_in,
+          txn_out,
+          &runtime->instr.trace[runtime->instr.trace_length],
+          i
+      );
     }
 #   endif
 
-    int instr_exec_result = fd_execute_instr( runtime, bank, txn_in, txn_out, &runtime->instr.infos[i] );
+    /* Update the current executing instruction index and trace length */
+    runtime->instr.current_idx = i;
+    runtime->instr.trace_length++;
+
+    /* Execute the current instruction */
+    int instr_exec_result = fd_execute_instr( runtime, bank, txn_in, txn_out, &runtime->instr.trace[i] );
     if( FD_UNLIKELY( instr_exec_result!=FD_EXECUTOR_INSTR_SUCCESS ) ) {
       if( txn_out->err.exec_err_idx==INT_MAX ) {
         txn_out->err.exec_err_idx = i;

src/flamenco/runtime/fd_runtime.c

@@ -1341,7 +1341,6 @@ fd_runtime_prepare_and_execute_txn( fd_runtime_t *       runtime,
 
   runtime->executable.cnt = 0UL;
   runtime->log.enable_log_collector = 0;
-  runtime->instr.info_cnt     = 0UL;
   runtime->instr.trace_length = 0UL;
   runtime->instr.current_idx  = 0;
   runtime->instr.stack_sz     = 0;

src/flamenco/runtime/fd_runtime.h

@@ -13,22 +13,19 @@ struct fd_runtime {
     uchar                       stack_sz;                                /* Current depth of the instruction execution stack. */
     fd_exec_instr_ctx_t         stack[ FD_MAX_INSTRUCTION_STACK_DEPTH ]; /* Instruction execution stack. */
     /* The memory for all of the instructions in the transaction
-       (including CPI instructions) are preallocated.  However, the order
-       in which the instructions are executed does not match the order in
-       which they are allocated.  The instr_trace will instead be used to
-       track the order in which the instructions are executed.  We leave
-       space for an extra instruction to account for the case where the
-       transaction has too many instructions leading to
-       FD_EXECUTOR_INSTR_ERR_MAX_INSN_TRACE_LENS_EXCEEDED.
-       TODO: In reality, we should just be allocating instr_infos per
-       instruction and not up front.  The dependency on using instr_info
-       for the sysvar instruction setup is not needed and should be
-       removed.  At this point, instr_info and instr_trace should be
-       combined. */
-    fd_instr_info_t             infos[ FD_MAX_INSTRUCTION_TRACE_LENGTH * 2UL ];
-    ulong                       info_cnt;
-    fd_exec_instr_trace_entry_t trace[ FD_MAX_INSTRUCTION_TRACE_LENGTH ]; /* Instruction trace */
-    ulong                       trace_length;                           /* Number of instructions in the trace */
+       (including CPI instructions) are preallocated.  However, the
+       order in which the instructions are executed does not match the
+       order in which they are allocated.  The instr_trace will instead
+       be used to track the order in which the instructions are
+       executed. We add a +1 to allow any instructions past the max
+       instr trace limit to be safely allocated, so that we can fail
+       out like Agave does later at the stack push step within
+       fd_execute_instr.
+
+       The caller is responsible for updating the trace_length for the
+       callee. */
+    fd_instr_info_t             trace[ FD_MAX_INSTRUCTION_TRACE_LENGTH+1UL ];
+    ulong                       trace_length;
     /* The current instruction index being executed */
     int current_idx;
   } instr;

src/flamenco/runtime/fd_runtime_helpers.h

@@ -32,16 +32,6 @@ typedef struct fd_txn_return_data fd_txn_return_data_t;
 
 /* fd_exec_txn_ctx_t is the context needed to execute a transaction. */
 
-/* An entry in the instruction trace */
-struct fd_exec_instr_trace_entry {
-  /* Metadata about the instruction */
-  fd_instr_info_t * instr_info;
-  /* Stack height when this instruction was pushed onto the stack (including itself)
-     https://github.com/anza-xyz/agave/blob/d87e23d8d91c32d5f2be2bb3557c730bee1e9434/sdk/src/transaction_context.rs#L475-L480 */
-  ulong stack_height;
-};
-typedef struct fd_exec_instr_trace_entry fd_exec_instr_trace_entry_t;
-
 FD_PROTOTYPES_BEGIN
 
 /* Returns 0 on success, and non zero otherwise.  On failure, the out

src/flamenco/runtime/info/fd_instr_info.h

@@ -44,6 +44,9 @@ struct fd_instr_info {
   fd_instruction_account_t accounts[ FD_INSTR_ACCT_MAX ];
   uchar                    is_duplicate[ FD_INSTR_ACCT_MAX ];
 
+  /* Stack height when this instruction was pushed onto the stack (including itself) */
+  ulong stack_height;
+
   /* TODO: convert to fd_uwide_t representation of uint_128 */
   ulong                    starting_lamports_h;
   ulong                    starting_lamports_l;

src/flamenco/runtime/program/fd_native_cpi.c

@@ -14,9 +14,9 @@ fd_native_cpi_native_invoke( fd_exec_instr_ctx_t *             ctx,
                              fd_pubkey_t const *               signers,
                              ulong                             signers_cnt ) {
   /* Set up the instr info */
-  fd_instr_info_t instr_info[ 1 ];
+  fd_instr_info_t *        instr_info = &ctx->runtime->instr.trace[ ctx->runtime->instr.trace_length++ ];
   fd_instruction_account_t instruction_accounts[ FD_INSTR_ACCT_MAX ];
-  ulong instruction_accounts_cnt;
+  ulong                    instruction_accounts_cnt;
 
   /* fd_vm_prepare_instruction will handle missing/invalid account case */
   instr_info->program_id = UCHAR_MAX;

src/flamenco/runtime/program/fd_precompiles.c

@@ -100,8 +100,11 @@ fd_precompile_get_instr_data( fd_exec_instr_ctx_t * ctx,
     if( FD_UNLIKELY( index>=TXN( ctx->txn_in->txn )->instr_cnt ) )
       return FD_EXECUTOR_PRECOMPILE_ERR_DATA_OFFSET;
 
-    fd_instr_info_t const * instr = &ctx->runtime->instr.infos[ index ];
-    data    = instr->dogtor;
+    fd_txn_t const *       txn     = TXN( ctx->txn_in->txn );
+    uchar const *          payload = ctx->txn_in->txn->payload;
+    fd_txn_instr_t const * instr   = &txn->instr[ index ];
+
+    data    = fd_txn_get_instr_data( instr, payload );
     data_sz = instr->data_sz;
 
   }

src/flamenco/runtime/tests/fd_instr_harness.c

@@ -104,8 +104,7 @@ fd_solfuzz_pb_instr_ctx_create( fd_solfuzz_runner_t *                runner,
 
   runtime->log.capture_ctx   = NULL;
 
-  runtime->instr.info_cnt     = 0UL;
-  runtime->instr.trace_length = 0UL;
+  runtime->instr.trace_length = 1UL;
 
   txn_out->err.exec_err       = 0;
   txn_out->err.exec_err_kind  = FD_EXECUTOR_ERR_KIND_NONE;
@@ -114,15 +113,14 @@ fd_solfuzz_pb_instr_ctx_create( fd_solfuzz_runner_t *                runner,
   txn_in->txn                                                = txn;
   txn_out->details.compute_budget.compute_unit_limit = test_ctx->cu_avail;
   txn_out->details.compute_budget.compute_meter      = test_ctx->cu_avail;
-  runtime->instr.info_cnt                                    = 1UL;
   runtime->log.enable_vm_tracing                             = runner->enable_vm_tracing;
   runtime->log.tracing_mem                                   = runner->enable_vm_tracing ?
                                                                fd_spad_alloc_check( runner->spad, FD_RUNTIME_VM_TRACE_STATIC_ALIGN, FD_RUNTIME_VM_TRACE_STATIC_FOOTPRINT * FD_MAX_INSTRUCTION_STACK_DEPTH ) :
                                                                NULL;
 
   /* Set up instruction context */
 
-  fd_instr_info_t * info = fd_spad_alloc( runner->spad, 8UL, sizeof(fd_instr_info_t) );
+  fd_instr_info_t * info = &runtime->instr.trace[ 0UL ];
   assert( info );
   memset( info, 0, sizeof(fd_instr_info_t) );
 
@@ -131,8 +129,6 @@ fd_solfuzz_pb_instr_ctx_create( fd_solfuzz_runner_t *                runner,
     memcpy( info->dogtor, test_ctx->data->bytes, info->data_sz );
   }
 
-  runtime->instr.infos[ 0UL ] = *info;
-
   /* Prepare borrowed account table (correctly handles aliasing) */
 
   if( FD_UNLIKELY( test_ctx->accounts_count > MAX_TX_ACCOUNT_LOCKS ) ) {

src/flamenco/runtime/tests/fd_txn_harness.c

@@ -444,8 +444,9 @@ fd_solfuzz_pb_txn_run( fd_solfuzz_runner_t * runner,
     } else {
       /* Capture the instruction error code */
       if( exec_res==FD_RUNTIME_TXN_ERR_INSTRUCTION_ERROR ) {
-        int instr_err_idx                   = txn_out->err.exec_err_idx;
-        int program_id_idx                  = runtime->instr.infos[instr_err_idx].program_id;
+        fd_txn_t const * txn            = TXN( txn_in->txn );
+        int              instr_err_idx  = txn_out->err.exec_err_idx;
+        int              program_id_idx = txn->instr[instr_err_idx].program_id;
 
         txn_result->instruction_error       = (uint32_t) -txn_out->err.exec_err;
         txn_result->instruction_error_index = (uint32_t) instr_err_idx;

src/flamenco/runtime/tests/fd_vm_harness.c

@@ -403,7 +403,6 @@ fd_solfuzz_pb_syscall_run( fd_solfuzz_runner_t * runner,
   if( !fd_solfuzz_pb_instr_ctx_create( runner, ctx, input_instr_ctx, skip_extra_checks ) )
     goto error;
 
-  ctx->runtime->instr.trace[0].instr_info = (fd_instr_info_t *)ctx->instr;
   ctx->runtime->instr.trace[0].stack_height = 1;
   ctx->txn_out->err.exec_err = 0;
   ctx->txn_out->err.exec_err_kind = FD_EXECUTOR_ERR_KIND_NONE;