[WIP ]Execution implementation

src/instruction.h

@@ -88,6 +88,8 @@ enum VirtualMachineError {
 	InvalidRes,
 	InvalidOpcode,
 	InvalidApUpdate,
+	MemoryError,
+	None
 };
 
 union ResultInstructionValue {

src/main.c

@@ -4,7 +4,6 @@
 #include <stdio.h>
 
 int main(__attribute__((unused)) int argc, __attribute__((unused)) char **argv) {
-	printf("Hello World!\n");
-
+	printf("hello word");
 	return 0;
 }

src/memory.c

@@ -28,27 +28,27 @@ memory memory_new(void) {
 ResultMemory memory_get(memory *mem, relocatable ptr) {
 	maybe_relocatable *value = NULL;
 	if (cc_hashtable_get(mem->data, &ptr, (void *)&value) == CC_OK) {
-		ResultMemory ok = {.is_error = false, .value = {.memory_value = *value}};
+		ResultMemory ok = {.type = MaybeRelocatable, .value = {.memory_value = *value}};
 		return ok;
 	}
-	ResultMemory error = {.is_error = true, .value = {.error = Get}};
+	ResultMemory error = {.type = Err, .value = {.error = Get}};
 	return error;
 }
 
 ResultMemory memory_insert(memory *mem, relocatable ptr, maybe_relocatable value) {
 	// Guard out of bounds writes
 	if (ptr.segment_index >= mem->num_segments) {
-		ResultMemory error = {.is_error = true, .value = {.error = Insert}};
+		ResultMemory error = {.type = Err, .value = {.error = Insert}};
 		return error;
 	}
 	// Guard overwrites
 	maybe_relocatable *prev_value = NULL;
 	if (cc_hashtable_get(mem->data, &ptr, (void *)&prev_value) == CC_OK) {
 		if (maybe_relocatable_equal(prev_value, &value)) {
-			ResultMemory ok = {.is_error = false, .value = {.none = 0}};
+			ResultMemory ok = {.type = Int, .value = {.none = 0}};
 			return ok;
 		} else {
-			ResultMemory error = {.is_error = true, .value = {.error = Insert}};
+			ResultMemory error = {.type = Err, .value = {.error = Insert}};
 			return error;
 		}
 	}
@@ -59,10 +59,10 @@ ResultMemory memory_insert(memory *mem, relocatable ptr, maybe_relocatable value
 	maybe_relocatable *value_alloc = malloc(sizeof(maybe_relocatable));
 	*value_alloc = value;
 	if (cc_hashtable_add(mem->data, ptr_alloc, value_alloc) == CC_OK) {
-		ResultMemory ok = {.is_error = false, .value = {.none = 0}};
+		ResultMemory ok = {.type = Int, .value = {.none = 0}};
 		return ok;
 	}
-	ResultMemory error = {.is_error = true, .value = {.error = Insert}};
+	ResultMemory error = {.type = Err, .value = {.error = Insert}};
 	return error;
 }
 
@@ -72,21 +72,22 @@ relocatable memory_add_segment(memory *memory) {
 	return rel;
 }
 
+
 ResultMemory memory_load_data(memory *mem, relocatable ptr, CC_Array *data) {
 	// Load each value sequentially
 	CC_ArrayIter data_iter;
 	cc_array_iter_init(&data_iter, data);
 	maybe_relocatable *value = NULL;
 	while (cc_array_iter_next(&data_iter, (void *)&value) != CC_ITER_END) {
 		// Insert Value
-		if (memory_insert(mem, ptr, *value).is_error) {
-			ResultMemory error = {.is_error = true, .value = {.error = LoadData}};
+		if (memory_insert(mem, ptr, *value).type == Err) {
+			ResultMemory error = {.type = Err, .value = {.error = LoadData}};
 			return error;
 		}
 		// Advance ptr
 		ptr.offset += 1;
 	}
-	ResultMemory ok = {.is_error = false, .value = {.ptr = ptr}};
+	ResultMemory ok = {.type = Err, .value = {.ptr = ptr}};
 	return ok;
 }
 
@@ -96,7 +97,7 @@ void print_memory(memory *mem) {
 		relocatable ptr = {i, 0};
 		while (true) {
 			ResultMemory result = memory_get(mem, ptr);
-			if (result.is_error) {
+			if (result.type == Err) {
 				break;
 			}
 			maybe_relocatable v = result.value.memory_value;

src/memory.h

@@ -21,6 +21,8 @@ enum MemoryError {
 	LoadData,
 };
 
+enum ResultMemoryType { Felt, Relocatable, MaybeRelocatable, Int, Err };
+
 union ResultMemoryValue {
 	enum MemoryError error;
 	maybe_relocatable memory_value;
@@ -29,7 +31,7 @@ union ResultMemoryValue {
 };
 
 typedef struct ResultMemory {
-	bool is_error;
+	enum ResultMemoryType type;
 	union ResultMemoryValue value;
 } ResultMemory;
 

src/relocatable.c

@@ -1,6 +1,39 @@
 #include "relocatable.h"
 #include "utils.h"
 
+// --------------------------------
+// Sign operations for relocatable
+// --------------------------------
+
+// TODO: fix this to thrown an error if off < other
+relocatable sub_relocatable(relocatable a, uint64_t other) {
+	unsigned int offset = a.offset;
+	unsigned int new_offset = offset - other;
+	relocatable result = {.segment_index = a.segment_index, .offset = new_offset};
+
+	return result;
+}
+
+uint64_t checked_add(uint64_t a, uint64_t b) {
+	uint64_t res = a + b;
+	if (res <= a || res <= b)
+		return 0;
+	else
+		return res;
+}
+
+// TODO: fix this to thrown an error. if add overflows
+relocatable add_relocatable(relocatable a, uint64_t other) {
+	unsigned int off = a.offset;
+	uint64_t check_sum = checked_add(off, other);
+	relocatable res = {.segment_index = a.segment_index, .offset = check_sum};
+	return res;
+}
+
+// -----------------------------------
+//  operations for maybe_relocatable
+// -----------------------------------
+
 bool maybe_relocatable_equal(maybe_relocatable *a, maybe_relocatable *b) {
 	if (a->is_felt && b->is_felt) {
 		return felt_equal(a->value.felt, b->value.felt);

src/relocatable.h

@@ -1,7 +1,9 @@
 #ifndef RELOCATABLE_H
 #define RELOCATABLE_H
+
 #include "../lambdaworks/lib/lambdaworks.h"
 #include <stdbool.h>
+#include <stdio.h>
 
 typedef struct relocatable {
 	unsigned int segment_index;
@@ -18,8 +20,9 @@ typedef struct maybe_relocatable {
 	bool is_felt;
 } maybe_relocatable;
 
+relocatable sub_relocatable(relocatable a, uint64_t other);
+relocatable add_relocatable(relocatable a, uint64_t other);
 bool maybe_relocatable_equal(maybe_relocatable *a, maybe_relocatable *b);
-
 maybe_relocatable maybe_relocatable_from_felt_limbs(limb_t *felt);
 
 #endif

src/run_context.c

@@ -0,0 +1,75 @@
+#include "run_context.h"
+#include "instruction.h"
+
+relocatable compute_dst_addr(run_context run_ctx, Instruction instr) {
+	struct relocatable base_addr;
+	switch (instr.dst_register) {
+	case REG_AP: {
+		base_addr = run_ctx.ap;
+	} break;
+	default: {
+		base_addr = run_ctx.fp;
+	} break;
+	}
+
+	relocatable res_base_addr;
+	if (instr.off0 < 0) {
+		res_base_addr = sub_relocatable(base_addr, (uint64_t)absolute(instr.off0));
+	} else {
+		res_base_addr = add_relocatable(base_addr, (uint64_t)instr.off0);
+	}
+
+	return res_base_addr;
+}
+
+relocatable compute_op0_addr(run_context run_ctx, Instruction instr) {
+	struct relocatable base_addr;
+	switch (instr.op0_register) {
+	case REG_AP: {
+		base_addr = run_ctx.ap;
+	} break;
+	default: {
+		base_addr = run_ctx.fp;
+	} break;
+	}
+
+	relocatable res_base_addr;
+	if (instr.off0 < 0) {
+		res_base_addr = sub_relocatable(base_addr, (uint64_t)absolute(instr.off1));
+	} else {
+		res_base_addr = add_relocatable(base_addr, (uint64_t)instr.off1);
+	}
+	return res_base_addr;
+}
+
+relocatable compute_op1_addr(run_context run_ctx, Instruction instr, maybe_relocatable op0) {
+	relocatable base_addr;
+	switch (instr.op1_addr) {
+	case OP_FP:
+		base_addr = run_ctx.fp;
+		break;
+	case OP_AP:
+		base_addr = run_ctx.ap;
+		break;
+	case Imm:
+		if (instr.off2 == 1)
+			base_addr = run_ctx.pc;
+		break;
+	case Op0: {
+		if (!op0.is_felt) {
+			base_addr = op0.value.relocatable;
+		}
+	} break;
+	default: {
+		base_addr = (relocatable){.segment_index = 0, .offset = 0};
+	} break;
+	}
+
+	relocatable res_base_addr;
+	if (instr.off2 < 0) {
+		res_base_addr = sub_relocatable(base_addr, (uint64_t)absolute(instr.off2));
+	} else {
+		res_base_addr = add_relocatable(base_addr, (uint64_t)instr.off2);
+	}
+	return res_base_addr;
+}

src/run_context.h

@@ -1,12 +1,18 @@
 #ifndef RUN_CONTEXT_H
 #define RUN_CONTEXT_H
 
+#include "instruction.h"
 #include "relocatable.h"
+#include "utils.h"
 
 typedef struct run_context {
 	relocatable pc;
 	relocatable ap;
 	relocatable fp;
 } run_context;
 
+relocatable compute_dst_addr(run_context run_ctx, Instruction instr);
+relocatable compute_op0_addr(run_context run_ctx, Instruction instr);
+relocatable compute_op1_addr(run_context run_ctx, Instruction instr, maybe_relocatable op0);
+
 #endif