mirror/pstrace
4
0
Fork 0
Code Activity

all code except of pst_function & pst_handler rewritten on C language.

Browse Source 
Logger nad Allocator decided to be a global for all library
This commit is contained in:
nnosov
2020-02-01 15:19:55 +04:00
parent fcdb15ba95
commit 8251ba526f
30 changed files with 2073 additions and 2068 deletions
Download Patch File Download Diff File Expand all files Collapse all files
framework/dwarf_parameter.cpp
+304
View File
@@ -0,0 +1,304 @@
/*
* dwarf_parameter.cpp
*
* Created on: Feb 1, 2020
* Author: nnosov
*/
#include <dwarf.h>
#include "dwarf_parameter.h"
//
// pst_type
//
void pst_type_init(pst_type* t, const char* name, uint32_t type)
{
list_node_init(&t->node);
t->name = pst_dup(&allocator, name);
t->type = type;
t->allocated = false;
}
pst_type* pst_type_new(const char* name, uint32_t type)
{
pst_type* nt = (pst_type*)allocator.alloc(&allocator, sizeof(pst_type));
if(nt) {
pst_type_init(nt, name, type);
nt->allocated = true;
}
return nt;
}
void pst_type_fini(pst_type* t)
{
allocator.free(&allocator, t->name);
if(t->allocated) {
allocator.free(&allocator, t);
}
}
//
// pst_parameter
//
bool param_print_dwarf(pst_parameter* param)
{
if(list_count(&param->types)) {
if(!param->is_return) {
if(param->has_value) {
param->ctx->print(param->ctx, "%s %s = 0x%lX", param->next_type(NULL)->name, param->name, param->location.value);
} else {
param->ctx->print(param->ctx, "%s %s = <undefined>", param->next_type(NULL)->name, param->name);
}
} else {
param->ctx->print(param->ctx, "%s", param->next_type(NULL)->name);
}
} else {
if(param->has_value) {
param->ctx->print(param->ctx, "%s = 0x%lX", param->name, param->location.value);
} else {
param->ctx->print(param->ctx, "%s = <undefined>", param->name);
}
}
return true;
}
bool param_handle_type(pst_parameter* param, Dwarf_Attribute* base)
{
Dwarf_Attribute attr_mem;
Dwarf_Attribute* attr;
// get DIE of return type
Dwarf_Die ret_die;
if(!dwarf_formref_die(base, &ret_die)) {
logger.log(SEVERITY_ERROR, "Failed to get parameter DIE");
return false;
}
switch (dwarf_tag(&ret_die)) {
case DW_TAG_base_type: {
// get Size attribute and it's value
param->size = 0;
attr = dwarf_attr(&ret_die, DW_AT_byte_size, &attr_mem);
if(attr) {
dwarf_formudata(attr, &param->size);
}
logger.log(SEVERITY_DEBUG, "base type '%s'(%lu)", dwarf_diename(&ret_die), param->size);
param->add_type(dwarf_diename(&ret_die), DW_TAG_base_type);
param->type = DW_TAG_base_type;
attr = dwarf_attr(&ret_die, DW_AT_encoding, &attr_mem);
if(attr) {
param->enc_type = 0;
dwarf_formudata(attr, &param->enc_type);
}
break;
}
case DW_TAG_array_type:
logger.log(SEVERITY_DEBUG, "array type");
param->add_type("[]", DW_TAG_array_type);
break;
case DW_TAG_structure_type:
logger.log(SEVERITY_DEBUG, "structure type");
param->add_type("struct", DW_TAG_structure_type);
break;
case DW_TAG_union_type:
logger.log(SEVERITY_DEBUG, "union type");
param->add_type("union", DW_TAG_union_type);
break;
case DW_TAG_class_type:
logger.log(SEVERITY_DEBUG, "class type");
param->add_type("class", DW_TAG_class_type);
break;
case DW_TAG_pointer_type:
logger.log(SEVERITY_DEBUG, "pointer type");
param->add_type("*", DW_TAG_pointer_type);
break;
case DW_TAG_enumeration_type:
logger.log(SEVERITY_DEBUG, "enumeration type");
param->add_type("enum", DW_TAG_enumeration_type);
break;
case DW_TAG_const_type:
logger.log(SEVERITY_DEBUG, "constant type");
param->add_type("const", DW_TAG_const_type);
break;
case DW_TAG_subroutine_type:
logger.log(SEVERITY_DEBUG, "Skipping subroutine type");
break;
case DW_TAG_typedef:
logger.log(SEVERITY_DEBUG, "typedef '%s' type", dwarf_diename(&ret_die));
param->add_type(dwarf_diename(&ret_die), DW_TAG_typedef);
break;
default:
logger.log(SEVERITY_WARNING, "Unknown 0x%X tag type", dwarf_tag(&ret_die));
break;
}
attr = dwarf_attr(&ret_die, DW_AT_type, &attr_mem);
if(attr) {
return param->handle_type(attr);
}
return true;
}
pst_type* param_add_type(pst_parameter* param, const char* name, int type)
{
pst_alloc(pst_type, t, name, type);
list_add_bottom(&param->types, &t->node);
return t;
}
void param_clear(pst_parameter* param)
{
pst_type* t = NULL;
struct list_node *pos, *tn;
list_for_each_entry_safe(t, pos, tn, &param->types, node) {
list_del(&t->node);
pst_type_fini(t);
}
}
pst_type* param_next_type(pst_parameter* param, pst_type* t)
{
list_node* n = (t == NULL) ? list_first(&param->types) : list_next(&t->node);
pst_type* ret = NULL;
if(n) {
ret = list_entry(n, pst_type, node);
}
return ret;
}
bool param_handle_dwarf(pst_parameter* param, Dwarf_Die* result, __pst_function* fun)
{
param->die = result;
Dwarf_Attribute attr_mem;
Dwarf_Attribute* attr;
param->name = pst_dup(&allocator, dwarf_diename(result));
param->is_variable = (dwarf_tag(result) == DW_TAG_variable);
dwarf_decl_line(result, (int*)&param->line);
// Get reference to attribute type of the parameter/variable
attr = dwarf_attr(result, DW_AT_type, &attr_mem);
logger.log(SEVERITY_DEBUG, "---> Handle '%s' %s", param->name, dwarf_tag(result) == DW_TAG_formal_parameter ? "parameter" : "variable");
if(attr) {
param->handle_type(param, attr);
}
if(dwarf_hasattr(result, DW_AT_location)) {
// determine location of parameter in stack/heap or CPU registers
attr = dwarf_attr(result, DW_AT_location, &attr_mem);
Dwarf_Addr pc;
unw_get_reg(param->ctx->curr_frame, UNW_REG_IP, &pc);
if(handle_location(param->ctx, attr, &param->location, pc, fun)) {
param->has_value = true;
} else {
logger.log(SEVERITY_ERROR, "Failed to calculate DW_AT_location expression: %s", param->ctx->buff);
return false;
}
} else if(dwarf_hasattr(result, DW_AT_const_value)) {
// no locations definitions, value is constant, known by DWARF directly
attr = dwarf_attr(result, DW_AT_const_value, &attr_mem);
switch (dwarf_whatform(attr)) {
case DW_FORM_string:
// do nothing for now
logger.log(SEVERITY_WARNING, "Const value form DW_FORM_string value = %s.", dwarf_formstring(attr));
break;
case DW_FORM_data1:
case DW_FORM_data2:
case DW_FORM_data4:
case DW_FORM_data8:
dwarf_formudata(attr, &param->location.value);
param->has_value = true;
break;
case DW_FORM_sdata:
dwarf_formsdata(attr, (int64_t*)&param->location.value);
param->has_value = true;
break;
case DW_FORM_udata:
dwarf_formudata(attr, &param->location.value);
param->has_value = true;
break;
}
if(param->has_value) {
logger.log(SEVERITY_DEBUG, "Parameter constant value: 0x%lX", param->location.value);
}
}
// Additionally handle these attributes:
// 1. DW_AT_default_value to get information about default value for DW_TAG_formal_parameter type of function
// A DW_AT_default_value attribute for a formal parameter entry. The value of
// this attribute may be a constant, or a reference to the debugging information
// entry for a variable, or a reference to a debugging information entry containing a DWARF procedure
// 2. DW_AT_variable_parameter
// A DW_AT_variable_parameter attribute, which is a flag, if a formal
// parameter entry represents a parameter whose value in the calling function
// may be modified by the callee. The absence of this attribute implies that the
// parameter’s value in the calling function cannot be modified by the callee.
// 3. DW_AT_abstract_origin
// In place of these omitted attributes, each concrete inlined instance entry has a DW_AT_abstract_origin attribute that may be used to obtain the
// missing information (indirectly) from the associated abstract instance entry. The value of the abstract origin attribute is a reference to the associated abstract
// instance entry.
return true;
}
void pst_parameter_init(pst_parameter*param, pst_context* ctx)
{
// methods
param->clear = param_clear;
param->add_type = param_add_type;
param->next_type = param_next_type;
param->handle_dwarf = param_handle_dwarf;
param->handle_type = param_handle_type;
param->print_dwarf = param_print_dwarf;
// fields
list_node_init(&param->node);
param->die = NULL;
param->name = NULL;
param->line = 0;
param->size = 0;
param->type = 0;
param->enc_type = 0;
list_head_init(&param->types);
param->is_return = false;
param->is_variable = false;
param->has_value = false;
param->ctx = ctx;
pst_dwarf_expr_init(&param->location);
param->allocated = false;
}
pst_parameter* pst_parameter_new(pst_context* ctx)
{
pst_parameter* param = (pst_parameter*)allocator.alloc(&allocator, sizeof(pst_parameter));
if(param) {
pst_parameter_init(param, ctx);
param->allocated = true;
}
return param;
}
void pst_parameter_fini(pst_parameter* param)
{
param->clear();
if(param->name) {
allocator.free(param->name);
}
if(param->allocated) {
allocator.free(&allocator, param);
}
}