X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/e5149b6787696e0041d192b0573dd0882a296c73..066ae3631a383ef0338cccfb8e153df1c7f13995:/src/mc/mc_dwarf_expression.c diff --git a/src/mc/mc_dwarf_expression.c b/src/mc/mc_dwarf_expression.c index 7653210faf..adcf360b80 100644 --- a/src/mc/mc_dwarf_expression.c +++ b/src/mc/mc_dwarf_expression.c @@ -11,7 +11,6 @@ #include #include "mc_object_info.h" -#include "mc_snapshot.h" #include "mc_private.h" static int mc_dwarf_push_value(mc_expression_state_t state, Dwarf_Off value) @@ -23,6 +22,12 @@ static int mc_dwarf_push_value(mc_expression_state_t state, Dwarf_Off value) return 0; } +/** Convert a DWARF register into a libunwind register + * + * DWARF and libunwind does not use the same convention for numbering the + * registers on some architectures. The function makes the necessary + * convertion. + */ static int mc_dwarf_register_to_libunwind(int dwarf_register) { #if defined(UNW_TARGET_X86_64) @@ -84,7 +89,7 @@ static int mc_dwarf_register_to_libunwind(int dwarf_register) xbt_die("Bad/unknown register number."); } #else -#error This architecture is not supported yet. +#error This architecture is not supported yet for DWARF expression evaluation. #endif } @@ -168,15 +173,16 @@ int mc_dwarf_execute_expression(size_t n, const Dwarf_Op * ops, { if (!state->frame_base) return MC_EXPRESSION_E_MISSING_FRAME_BASE; - error = - mc_dwarf_push_value(state, - ((uintptr_t) state->frame_base) + op->number); + uintptr_t fb = ((uintptr_t) state->frame_base) + op->number; + error = mc_dwarf_push_value(state, fb); break; } - // Constants: + // ***** Constants: + // Short constant literals: + // DW_OP_lit15 pushed the 15 on the stack. case DW_OP_lit0: case DW_OP_lit1: case DW_OP_lit2: @@ -212,17 +218,20 @@ int mc_dwarf_execute_expression(size_t n, const Dwarf_Op * ops, error = mc_dwarf_push_value(state, atom - DW_OP_lit0); break; + // Address from the base address of this ELF object. + // Push the address on the stack (base_address + argument). case DW_OP_addr: if (!state->object_info) return MC_EXPRESSION_E_NO_BASE_ADDRESS; if (state->stack_size == MC_EXPRESSION_STACK_SIZE) return MC_EXPRESSION_E_STACK_OVERFLOW; - error = mc_dwarf_push_value(state, - (Dwarf_Off) (uintptr_t) - MC_object_base_address(state->object_info) + - op->number); + Dwarf_Off addr = (Dwarf_Off) (uintptr_t) + MC_object_base_address(state->object_info) + op->number; + error = mc_dwarf_push_value(state, addr); break; + // General constants: + // Push the constant argument on the stack. case DW_OP_const1u: case DW_OP_const2u: case DW_OP_const4u: @@ -238,9 +247,9 @@ int mc_dwarf_execute_expression(size_t n, const Dwarf_Op * ops, error = mc_dwarf_push_value(state, op->number); break; - // Stack manipulation: + // ***** Stack manipulation: - // Push the value at the top of the stack: + // Push another copy/duplicate the value at the top of the stack: case DW_OP_dup: if (state->stack_size == 0) return MC_EXPRESSION_E_STACK_UNDERFLOW; @@ -248,6 +257,7 @@ int mc_dwarf_execute_expression(size_t n, const Dwarf_Op * ops, error = mc_dwarf_push_value(state, state->stack[state->stack_size - 1]); break; + // Pop/drop the top of the stack: case DW_OP_drop: if (state->stack_size == 0) return MC_EXPRESSION_E_STACK_UNDERFLOW; @@ -255,6 +265,7 @@ int mc_dwarf_execute_expression(size_t n, const Dwarf_Op * ops, state->stack_size--; break; + // Swap the two top-most value of the stack: case DW_OP_swap: if (state->stack_size < 2) return MC_EXPRESSION_E_STACK_UNDERFLOW; @@ -266,13 +277,17 @@ int mc_dwarf_execute_expression(size_t n, const Dwarf_Op * ops, } break; + // Duplicate the value under the top of the stack: case DW_OP_over: if (state->stack_size < 2) return MC_EXPRESSION_E_STACK_UNDERFLOW; error = mc_dwarf_push_value(state, state->stack[state->stack_size - 2]); break; - // Operations: + // ***** Operations: + // Those usually take the top of the stack and the next value as argument + // and replace the top of the stack with the computed value + // (stack.top() += stack.before_top()). case DW_OP_plus: if (state->stack_size < 2) @@ -373,7 +388,8 @@ int mc_dwarf_execute_expression(size_t n, const Dwarf_Op * ops, case DW_OP_nop: break; - // Dereference: + // ***** Deference (memory fetch) + case DW_OP_deref_size: return MC_EXPRESSION_E_UNSUPPORTED_OPERATION; @@ -383,9 +399,12 @@ int mc_dwarf_execute_expression(size_t n, const Dwarf_Op * ops, { // Computed address: uintptr_t address = (uintptr_t) state->stack[state->stack_size - 1]; - uintptr_t temp; - uintptr_t* res = (uintptr_t*) mc_snapshot_read((void*) address, state->snapshot, state->process_index, &temp, sizeof(uintptr_t)); - state->stack[state->stack_size - 1] = *res; + if (!state->address_space) + xbt_die("Missing address space"); + MC_address_space_read( + state->address_space, MC_ADDRESS_SPACE_READ_FLAGS_NONE, + &state->stack[state->stack_size - 1], (const void*) address, + sizeof(uintptr_t), state->process_index); } break; @@ -410,13 +429,13 @@ void mc_dwarf_resolve_location(mc_location_t location, mc_object_info_t object_info, unw_cursor_t * c, void *frame_pointer_address, - mc_snapshot_t snapshot, int process_index) + mc_address_space_t address_space, int process_index) { s_mc_expression_state_t state; memset(&state, 0, sizeof(s_mc_expression_state_t)); state.frame_base = frame_pointer_address; state.cursor = c; - state.snapshot = snapshot; + state.address_space = address_space; state.object_info = object_info; state.process_index = process_index; @@ -459,7 +478,7 @@ void mc_dwarf_resolve_locations(mc_location_t location, mc_object_info_t object_info, unw_cursor_t * c, void *frame_pointer_address, - mc_snapshot_t snapshot, int process_index) + mc_address_space_t address_space, int process_index) { unw_word_t ip = 0; @@ -472,7 +491,7 @@ void mc_dwarf_resolve_locations(mc_location_t location, if (expression) { mc_dwarf_resolve_location(location, expression, object_info, c, - frame_pointer_address, snapshot, process_index); + frame_pointer_address, address_space, process_index); } else { xbt_die("Could not resolve location"); }