X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/dc9d4601416c48fbfed05be80d69cb7fd0d56794..4fd2f97dd395fdec3a097054bb19ab70e7e99380:/src/mc/mc_dwarf_expression.c diff --git a/src/mc/mc_dwarf_expression.c b/src/mc/mc_dwarf_expression.c index a73ac2f52a..caaf9322ce 100644 --- a/src/mc/mc_dwarf_expression.c +++ b/src/mc/mc_dwarf_expression.c @@ -43,6 +43,26 @@ int mc_dwarf_execute_expression( break; } + // Push the CFA (Canonical Frame Addresse): + case DW_OP_call_frame_cfa: + { + // UNW_X86_64_CFA does not return the CFA DWARF expects + // (it is a synonym for UNW_X86_64_RSP) so copy the cursor, + // unwind it once in order to find the parent SP: + + if(!state->cursor) + return MC_EXPRESSION_E_MISSING_STACK_CONTEXT; + + // Get frame: + unw_cursor_t cursor = *(state->cursor); + unw_step(&cursor); + + unw_word_t res; + unw_get_reg(&cursor, UNW_TDEP_SP, &res); + error = mc_dwarf_push_value(state, res); + break; + } + // Frame base: case DW_OP_fbreg: @@ -53,6 +73,7 @@ int mc_dwarf_execute_expression( break; } + // Constants: case DW_OP_lit0: case DW_OP_lit1: case DW_OP_lit2: case DW_OP_lit3: @@ -67,6 +88,13 @@ int mc_dwarf_execute_expression( break; 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)MC_object_base_address(state->object_info) + op->number); + break; + case DW_OP_const1u: case DW_OP_const2u: case DW_OP_const4u: @@ -204,9 +232,19 @@ int mc_dwarf_execute_expression( // Dereference: case DW_OP_deref_size: - case DW_OP_deref: return MC_EXPRESSION_E_UNSUPPORTED_OPERATION; + case DW_OP_deref: + if(state->stack_size==0) + return MC_EXPRESSION_E_STACK_UNDERFLOW; + { + // Computed address: + uintptr_t address = (uintptr_t) state->stack[state->stack_size-1]; + uintptr_t* p = (uintptr_t*)mc_translate_address(address, state->snapshot); + state->stack[state->stack_size-1] = *p; + } + break; + // Not handled: default: return MC_EXPRESSION_E_UNSUPPORTED_OPERATION; @@ -222,11 +260,13 @@ int mc_dwarf_execute_expression( /** \brief Resolve a location expression * \deprecated Use mc_dwarf_resolve_expression */ -Dwarf_Off mc_dwarf_resolve_location(mc_expression_t expression, unw_cursor_t* c, void* frame_pointer_address) { +Dwarf_Off mc_dwarf_resolve_location(mc_expression_t expression, mc_object_info_t object_info, unw_cursor_t* c, void* frame_pointer_address, mc_snapshot_t snapshot) { 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.object_info = object_info; if(mc_dwarf_execute_expression(expression->size, expression->ops, &state)) xbt_die("Error evaluating DWARF expression"); @@ -236,3 +276,100 @@ Dwarf_Off mc_dwarf_resolve_location(mc_expression_t expression, unw_cursor_t* c, return (Dwarf_Off) state.stack[state.stack_size-1]; } +Dwarf_Off mc_dwarf_resolve_locations(mc_location_list_t locations, mc_object_info_t object_info, unw_cursor_t* c, void* frame_pointer_address, mc_snapshot_t snapshot) { + + unw_word_t ip; + if(c) { + if(unw_get_reg(c, UNW_REG_IP, &ip)) + xbt_die("Could not resolve IP"); + } + + for(size_t i=0; i!=locations->size; ++i) { + mc_expression_t expression = locations->locations + i; + if( (expression->lowpc==NULL && expression->highpc==NULL) + || (c && ip >= (unw_word_t) expression->lowpc && ip < (unw_word_t) expression->highpc)) { + return mc_dwarf_resolve_location(expression, object_info, c, frame_pointer_address, snapshot); + } + } + xbt_die("Could not resolve location"); +} + +/** \brief Find the frame base of a given frame + * + * \param frame + * \param unw_cursor + */ +void* mc_find_frame_base(dw_frame_t frame, mc_object_info_t object_info, unw_cursor_t* unw_cursor) { + return (void*) mc_dwarf_resolve_locations(&frame->frame_base, object_info, unw_cursor, NULL, NULL); +} + +void mc_dwarf_expression_clear(mc_expression_t expression) { + free(expression->ops); + expression->ops = NULL; + expression->size = 0; + expression->lowpc = NULL; + expression->highpc = NULL; +} + +void mc_dwarf_location_list_clear(mc_location_list_t list) { + for(size_t i=0; i!=list->size; ++i) { + mc_dwarf_expression_clear(list->locations + i); + } + free(list->locations); + list->locations = NULL; + list->size = 0; +} + +void mc_dwarf_expression_init(mc_expression_t expression, size_t len, Dwarf_Op* ops) { + if(expression->ops) { + free(expression->ops); + } + expression->lowpc = NULL; + expression->highpc = NULL; + expression->size = len; + expression->ops = xbt_malloc(len*sizeof(Dwarf_Op)); + memcpy(expression->ops, ops, len*sizeof(Dwarf_Op)); +} + +void mc_dwarf_location_list_init_from_expression(mc_location_list_t target, size_t len, Dwarf_Op* ops) { + if(target->locations) { + mc_dwarf_location_list_clear(target); + } + target->size = 1; + target->locations = (mc_expression_t) xbt_malloc(sizeof(s_mc_expression_t)); + mc_dwarf_expression_init(target->locations, len, ops); +} + +void mc_dwarf_location_list_init(mc_location_list_t list, mc_object_info_t info, Dwarf_Die* die, Dwarf_Attribute* attr) { + if(list->locations) { + mc_dwarf_location_list_clear(list); + } + list->size = 0; + + ptrdiff_t offset = 0; + Dwarf_Addr base, start, end; + Dwarf_Op *ops; + size_t len; + + while (1) { + + offset = dwarf_getlocations(attr, offset, &base, &start, &end, &ops, &len); + if (offset==0) + return; + else if (offset==-1) + xbt_die("Error while loading location list"); + + int i = list->size; + list->size++; + list->locations = (mc_expression_t) realloc(list->locations, list->size*sizeof(s_mc_expression_t)); + mc_expression_t expression = list->locations + i; + + void* base = info->flags & MC_OBJECT_INFO_EXECUTABLE ? 0 : MC_object_base_address(info); + mc_dwarf_expression_init(expression, len, ops); + + // If start == 0, this is not a location list: + expression->lowpc = start == 0 ? NULL : (char*) base + start; + expression->highpc = start == 0 ? NULL : (char*) base + end; + } + +}