Commit 54c7f8b1 authored by Cédric VALENSI's avatar Cédric VALENSI

Sync

parent 4840ed79
......@@ -319,7 +319,7 @@ find_path(DPKG_DEB_PATH NAMES dpkg-deb) # look for dpkg-deb
SET(CPACK_PACKAGE_VERSION_MAJOR "2")
SET(CPACK_PACKAGE_VERSION_MINOR "6")
SET(CPACK_PACKAGE_VERSION_PATCH "0")
SET(CPACK_PACKAGE_VERSION_PATCH "4")
# ---- Check if at least one package generator has been found
IF ((NOT (${RPMBUILD_PATH} STREQUAL "RPMBUILD_PATH-NOTFOUND"))
......
......@@ -141,71 +141,77 @@ static void* grouping_init(fct_t* f, adfa_cntxt_t* useless)
* \param arch current architecture
* \param buff an allocated string where to save the key
*/
static void grouping_to_key(adfa_val_t* val, arch_t* arch, char* buff,
static void grouping_to_key(adfa_val_t* val, arch_t* arch, char** buff, unsigned *buflen,
int is_mem)
{
if (val == NULL || arch == NULL || buff == NULL)
if (val == NULL || arch == NULL || *buff == NULL)
return;
int _is_mem = (is_mem == 1) ? 1 : val->is_mem;
if (_is_mem == 0 && val->op != ADFA_OP_ADD && val->op != ADFA_OP_SUB
&& val->op != ADFA_OP_NULL)
_is_mem = 1;
// Assuming terminal calls of this function never print more than 100 chars
if (strlen (*buff) > *buflen - 100) {
*buflen *= 2;
*buff = lc_realloc (*buff, *buflen);
}
if (val->op == ADFA_OP_SQRT)
sprintf(buff, "%sSQRT(", buff);
sprintf(*buff, "%sSQRT(", *buff);
if (val->is_mem)
sprintf(buff, "%s@[", buff);
sprintf(*buff, "%s@[", *buff);
switch (val->type) {
case ADFA_TYPE_IMM:
if (_is_mem == 1)
sprintf(buff, "%s0x%"PRIx64, buff, val->data.imm);
sprintf(*buff, "%s0x%"PRIx64, *buff, val->data.imm);
break;
case ADFA_TYPE_REG:
sprintf(buff, "%s%s_%d", buff,
sprintf(*buff, "%s%s_%d", *buff,
arch_get_reg_name(arch, val->data.reg->reg->type,
val->data.reg->reg->name), val->data.reg->index);
break;
case ADFA_TYPE_SONS:
if (val->op == ADFA_OP_ADD) {
if (val->data.sons[0])
grouping_to_key(val->data.sons[0], arch, buff, _is_mem);
sprintf(buff, "%s+", buff);
grouping_to_key(val->data.sons[0], arch, buff, buflen, _is_mem);
sprintf(*buff, "%s+", *buff);
if (val->data.sons[1])
grouping_to_key(val->data.sons[1], arch, buff, _is_mem);
grouping_to_key(val->data.sons[1], arch, buff, buflen, _is_mem);
} else {
sprintf(buff, "%s(", buff);
sprintf(*buff, "%s(", *buff);
if (val->data.sons[0])
grouping_to_key(val->data.sons[0], arch, buff, _is_mem);
grouping_to_key(val->data.sons[0], arch, buff, buflen, _is_mem);
switch (val->op) {
case ADFA_OP_SUB:
sprintf(buff, "%s)-(", buff);
sprintf(*buff, "%s)-(", *buff);
break;
case ADFA_OP_MUL:
sprintf(buff, "%s)*(", buff);
sprintf(*buff, "%s)*(", *buff);
break;
case ADFA_OP_DIV:
sprintf(buff, "%s)/(", buff);
sprintf(*buff, "%s)/(", *buff);
break;
case ADFA_OP_SL:
sprintf(buff, "%s)<<(", buff);
sprintf(*buff, "%s)<<(", *buff);
break;
case ADFA_OP_SR:
sprintf(buff, "%s)>>(", buff);
sprintf(*buff, "%s)>>(", *buff);
break;
}
if (val->data.sons[1])
grouping_to_key(val->data.sons[1], arch, buff, _is_mem);
sprintf(buff, "%s)", buff);
grouping_to_key(val->data.sons[1], arch, buff, buflen, _is_mem);
sprintf(*buff, "%s)", *buff);
}
break;
}
if (val->is_mem)
sprintf(buff, "%s]", buff);
sprintf(*buff, "%s]", *buff);
if (val->op == ADFA_OP_SQRT)
sprintf(buff, "%s)", buff);
sprintf(*buff, "%s)", *buff);
}
/*
......@@ -254,6 +260,10 @@ static void grouping_insn_execute(ssa_insn_t* ssain, adfa_val_t* result,
int i = 0;
insn_t* in = ssain->in;
// Buffer used to forge keys, allocated/reallocated on demand
unsigned key_len = 8192; // initial size
char *key = NULL;
// Iterates over operands to analysis memory operands
for (i = 0; i < insn_get_nb_oprnds(in); i++) {
oprnd_t* op = insn_get_oprnd(in, i);
......@@ -297,9 +307,9 @@ static void grouping_insn_execute(ssa_insn_t* ssain, adfa_val_t* result,
if (oprnd_is_dst(op))
pattern = 'S';
char key[8192];
if (key == NULL) key = lc_malloc (key_len);
key[0] = '\0';
grouping_to_key(val, ssain->in->block->function->asmfile->arch, key,
grouping_to_key(val, ssain->in->block->function->asmfile->arch, &key, &key_len,
0);
lc_free(val);
......@@ -327,6 +337,7 @@ static void grouping_insn_execute(ssa_insn_t* ssain, adfa_val_t* result,
group_add_elem(group, gdat);
}
}
lc_free (key);
}
/*
......
......@@ -41,6 +41,7 @@ typedef struct global_s {
order_t *order; /**<*/
list_t *Bstack; /**<*/
list_t* remove_from_stack; /**<*/
int order_sz; /**Number of elements in order*/
} global_t;
/*
......@@ -355,8 +356,16 @@ static void build_loops(fct_t *f, global_t* global)
block_get_last_insn_addr(GET_DATA_T(block_t*, dbgiter)));
dbgiter = list_getnext(dbgiter);
})
//------ Initialization of the structure order ----------------------------
global->order = lc_malloc0((Nblocks + 1) * sizeof(order_t));
//------ Renitialization of the structure order ----------------------------
//Reallocating if for some reason the number of blocks has increased
/**\todo (2018-10-19) I'm doing this because I'm not 100% sure that the number of blocks never increases
* during the execution of this algorithm. When/if we are sure of that, we can remove the snippet of code below
* and order_sz*/
if (Nblocks > global->order_sz) {
global->order = lc_realloc(global->order, (Nblocks + 1) * sizeof(order_t));
global->order_sz = Nblocks;
}
memset(global->order, 0, Nblocks + 1);
// Apply the algorithm to each block without predecessors (potential connected component)
FOREACH_INLIST(initheads, blockiter) {
......@@ -375,7 +384,6 @@ static void build_loops(fct_t *f, global_t* global)
list_free(global->remove_from_stack, &lc_free);
global->remove_from_stack = NULL;
global->Bstack = NULL;
lc_free(global->order);
}
/**
......@@ -522,17 +530,27 @@ void lcore_analyze_loops(asmfile_t *asmfile)
return;
}
int Nblocks = asmfile->n_blocks;
if (Nblocks == 0)
return;
global_t global;
global.order = NULL;
global.Bstack = NULL;
global.remove_from_stack = NULL;
//------ Initialization of the structure order ----------------------------
global.order = lc_malloc0((Nblocks + 1) * sizeof(order_t));
global.order_sz = Nblocks;
DBGMSG0("computing loops\n");
FOREACH_INQUEUE(asmfile->functions, iter) {
f = GET_DATA_T(fct_t*, iter);
DBGMSG("Analyzing loops of function %s\n", fct_get_name(f));
build_loops(f, &global);
}
lc_free(global.order);
asmfile->analyze_flag |= LOO_ANALYZE;
//Special case where an independent loop is not recognized as a CC
lcore_loop_find_orphan_CC(asmfile);
......
......@@ -38,7 +38,7 @@
*/
char* lc_basename(const char* path)
{
if (!path) return strdup (".");
if (!path) return lc_strdup (".");
char *basec = lc_strdup(path); // don't want path to be modified: save it
char *fname = lc_strdup(basename(basec)); // basename return value cannotq be freed
......
......@@ -557,37 +557,12 @@ static int asmfile_parse(parsedfile_t* pf, asmfile_t* af, int options)
if (ISERROR(res))
return res;
//Adds labels for the PLT section
res = asmfile_add_plt_labels(af);
res = asmfile_upd_labels_from_bin(af);
if (ISERROR(res)) {
DBGMSG("%s: %s (%x)",
errcode_getmsg(WRN_DISASS_EXT_FCTS_LBLS_NOT_RETRIEVED),
errcode_getmsg(WRN_DISASS_LBLS_NOT_RETRIEVED),
errcode_getmsg(res), res);
res = WRN_DISASS_EXT_FCTS_LBLS_NOT_RETRIEVED;
}
//Loads the labels list and hashtable into the ASM file
if (efile->labels != NULL) {
/**\todo Fill in the type and target for the labels. Find a more efficient way to fill this table
* than by scanning another table*/
FOREACH_INHASHTABLE(efile->labels, iter)
{
//Creates the label
label_t* lbl = elffile_label_getaslabel(efile,
GET_DATA_T(tableentry_t*, iter));
DBGMSG("Added label %s (pointing to %#"PRIx64") to asmfile\n",
label_get_name(lbl), label_get_addr(lbl));
//Adds the label into the label hashtable and to the ordered list of labels
asmfile_add_label(af, lbl);
}
}
//ADD LABELS FROM DEBUG SECTIONS
res = asmfile_add_debug_labels(af);
if (ISERROR(res)) {
DBGMSG("%s: %s (%x)",
errcode_getmsg(WRN_DISASS_DBG_LBLS_NOT_RETRIEVED),
errcode_getmsg(res), res);
res = WRN_DISASS_DBG_LBLS_NOT_RETRIEVED;
res = WRN_DISASS_LBLS_NOT_RETRIEVED;
}
//Finalises the update of the labels
......
......@@ -77,6 +77,7 @@ struct _DwarfFile {
hashtable_t* fcts_ao; /**< An hashtable containing functions indexed by their abstract objects*/
char *name; /**< The current filename*/
char *bname; /**< Basename of the current filename*/
char *dir; /**< The directory where the source file has been compiled*/
char *vendor; /**< Compiler vendor name, e.g. "GNU", "Intel"*/
char *version; /**< Compiler version ,e.g. "4.4.2", "12.1.4"*/
......@@ -84,6 +85,7 @@ struct _DwarfFile {
char *language; /**< Compiler language, e.g. "C", "C++", "Fortran"*/
char *producer; /**< Compiler string saved in DWARF*/
char ** filenames; /**< A list of file names */
char ** basenames; /**< List of file basenames (same indexes as in filenames)*/
char * command_line_opts; /**< Extracted from ELF, contains command line data*/
int64_t lowpc; /**< Low_pc member*/
queue_t *functions; /**< Queue of (DwarfFunctions*) in this DwarfFile*/
......@@ -368,6 +370,7 @@ static DwarfFile* __file_new(DwarfAPI* api, Dwarf_Die* die, long int off)
case DW_AT_name:
file->name = lc_strdup(
__dwarf_reader_attr_init_data(form, &dwarf_attrs[i], api));
file->bname = lc_basename(file->name);
break;
case DW_AT_language:
dwarf_lang = (long int) __dwarf_reader_attr_init_data(form,
......@@ -517,6 +520,8 @@ static void __file_free(void* f)
lc_free(file->producer);
if (file->name)
lc_free(file->name);
if (file->bname)
lc_free(file->bname);
if (file->dir)
lc_free(file->dir);
if (file->d_die)
......@@ -525,12 +530,19 @@ static void __file_free(void* f)
lc_free(file->version);
if (file->global_var != NULL)
queue_free(file->global_var, __var_free);
int i = 0;
if (file->filenames != NULL) {
int i = 0;
for (i = 0; i < file->filenames_size; i++)
lc_free(file->filenames[i]);
lc_free(file->filenames);
}
if (file->basenames != NULL) {
for (i = 0; i < file->filenames_size; i++)
lc_free(file->basenames[i]);
lc_free(file->basenames);
}
if (file->short_version)
lc_free(file->short_version);
lc_free(file);
}
......@@ -682,11 +694,18 @@ static DwarfFunction* __function_new(DwarfAPI* api, Dwarf_Die *d_die,
break;
case DW_AT_MIPS_linkage_name:
case DW_AT_linkage_name:
func->linkage_name = lc_strdup(
__dwarf_reader_attr_init_data(form, &dwarf_attrs[i], api));
if (func->linkage_name != NULL)
{
/**\note (2018-10-18) Apparently there can be multiple linkage_name entries for the same object...
* For the sake of simplicity, I am using only the first one. Otherwise if we want to be really thorough,
* we would have to replace linkage_name with a queue or array in case there can be different linkage_name
* (I have no idea if this is possible*/
char* linkage_name = __dwarf_reader_attr_init_data(form, &dwarf_attrs[i], api);
if (linkage_name != NULL && func->linkage_name == NULL) { //No linkage_name found so far
func->linkage_name = lc_strdup(linkage_name);
hashtable_insert(api->functions_linkname, (char*)func->linkage_name, func);
}
break;
}
case DW_AT_low_pc:
func->low_pc = (Dwarf_Addr) __dwarf_reader_attr_init_data(form,
&dwarf_attrs[i], api);
......@@ -1341,9 +1360,11 @@ static void __load_lines_from_file(DwarfAPI* api, Dwarf_Die *d_die,
dwarf_srcfiles(*d_die, &file_buff, &line_count, &err);
file->filenames_size = line_count;
file->filenames = lc_malloc(line_count * sizeof(char*));
file->basenames = lc_malloc(line_count * sizeof(char*));
if (file_buff != NULL) {
for (i = 0; i < file->filenames_size; i++) {
file->filenames[i] = lc_strdup(file_buff[i]);
file->basenames[i] = lc_basename(file->filenames[i]);
/*
if (file_buff[i] != NULL
&& file_buff[i][0] != '<')
......@@ -2040,16 +2061,30 @@ DwarfFunction* dwarf_api_get_function_by_interval(DwarfAPI *api,
DwarfFunction* dwarf_api_get_function_by_src(DwarfAPI *api, const char* name,
int srcl)
{
char* base = lc_basename(name);
DwarfFile* match = NULL;
FOREACH_INQUEUE(api->files, file_link) {
DwarfFile *file = GET_DATA_T(DwarfFile*, file_link);
int i = 0;
if (strcmp(file->bname, base) == 0) {
DBGMSG("File %s matches with file %s from debug data\n", name, file->name)
break;
}
if (strcmp(lc_basename(file->name), lc_basename(name)) == 0)
return (dwarf_file_get_function_by_src(file, srcl));
for (i = 0; i < file->filenames_size; i++)
if (strcmp(lc_basename(file->filenames[i]), lc_basename(name)) == 0)
return (dwarf_file_get_function_by_src(file, srcl));
for (i = 0; i < file->filenames_size; i++) {
if (strcmp(file->basenames[i], base) == 0) {
DBGMSG("File %s matches with file %s from debug data\n", name, file->filenames[i])
break;
}
}
if (i < file->filenames_size)
break; //Above loop was interrupted: exiting the main one
}
lc_free(base);
if (file_link != NULL) {
DBGMSG("File is %s\n", GET_DATA_T(DwarfFile*, file_link)->name)
return (dwarf_file_get_function_by_src(GET_DATA_T(DwarfFile*, file_link),
srcl));
}
return NULL;
}
......
......@@ -6348,12 +6348,12 @@ static char* generate_label_name (hashtable_t* table, int64_t addr)
}
/*
/**
* Update labels of .plt section using .rela.plt table and .got section
* \param An asmfile to update
* \return EXIT_SUCCESS or error code
*/
int asmfile_add_plt_labels (asmfile_t* asmf)
static int asmfile_add_plt_labels (asmfile_t* asmf)
{
if (asmf == NULL)
return ERR_LIBASM_MISSING_ASMFILE;
......@@ -6495,12 +6495,13 @@ int asmfile_add_plt_labels (asmfile_t* asmf)
}
/*
/**
* Update labels of the given asmfile in using debug info if they are available.
* \param asmfile The asmfile to update
* \param lbls_by_addr Hashtable of labels present in the file, indexed by their addresses
* \return EXIT_SUCCESS or error code
*/
int asmfile_add_debug_labels (asmfile_t* asmfile)
static int asmfile_add_debug_labels (asmfile_t* asmfile, hashtable_t* lbls_by_addr)
{
elffile_t* efile = NULL;
int res = EXIT_SUCCESS;
......@@ -6518,6 +6519,7 @@ int asmfile_add_debug_labels (asmfile_t* asmfile)
{
dwarfInfo = efile->dwarf;
dwarfFunctionsInfo = dwarf_api_get_functions(dwarfInfo);
//Sorts the existing labels in the file to allow a search by address
asmfile_sort_labels(asmfile);
//FOR EACH DWARF FUNCTION
......@@ -6530,9 +6532,9 @@ int asmfile_add_debug_labels (asmfile_t* asmfile)
//ADDRESS IS CORRECT?
if ( low_pc_addr != -1)
{
label_t* label = asmfile_get_last_label (asmfile, low_pc_addr, NULL);
label_t* label = hashtable_lookup(lbls_by_addr, low_pc_addr);
//LABEL IS ALREADY PRESENT IN THE LIST (FROM .symtab)
if (label!= NULL && label->address == low_pc_addr)
if (label!= NULL)
{
DBGMSGLVL(2,"%s LABEL MATCH WITH DWARF INFO\n",label->name);
}
......@@ -6585,6 +6587,7 @@ int asmfile_add_debug_labels (asmfile_t* asmfile)
}
}
}
queue_free(dwarfFunctionsInfo, NULL);
}
} else {
res = ERR_BINARY_MISSING_BINFILE;
......@@ -6592,6 +6595,62 @@ int asmfile_add_debug_labels (asmfile_t* asmfile)
return res;
}
/*
* Fills the labels structure in an asmfile with every labels that could be gathered from the binary file
* This include the symbols, labels deduced from the plt, and the debug labels
* \param asmfile The asmfile
* */
int asmfile_upd_labels_from_bin(asmfile_t* asmfile)
{
int res = EXIT_SUCCESS;
if (asmfile == NULL)
return ERR_LIBASM_MISSING_ASMFILE;
elffile_t* efile = asmfile_get_origin(asmfile);
if (efile == NULL)
return ERR_BINARY_MISSING_BINFILE;
//Adds labels for the PLT section
res = asmfile_add_plt_labels(asmfile);
if (ISERROR(res)) {
DBGMSG("%s: %s (%x)",
errcode_getmsg(WRN_DISASS_EXT_FCTS_LBLS_NOT_RETRIEVED),
errcode_getmsg(res), res);
res = WRN_DISASS_EXT_FCTS_LBLS_NOT_RETRIEVED;
}
//Builds a temporary hashtable of labels indexed by their addresses to allow an easier search
hashtable_t* lbls_by_addr = hashtable_new(direct_hash, direct_equal);
//Loads the labels list and hashtable into the ASM file
if (efile->labels != NULL) {
/**\todo Fill in the type and target for the labels. Find a more efficient way to fill this table
* than by scanning another table*/
FOREACH_INHASHTABLE(efile->labels, iter)
{
//Creates the label
label_t* lbl = elffile_label_getaslabel(efile,
GET_DATA_T(tableentry_t*, iter));
DBGMSG("Added label %s (pointing to %#"PRIx64") to asmfile\n",
label_get_name(lbl), label_get_addr(lbl));
//Adds the label into the label hashtable and to the ordered list of labels
asmfile_add_label(asmfile, lbl);
//Stores the label in the temporary hashtable indexed on its address
hashtable_insert(lbls_by_addr, label_get_addr(lbl), lbl);
}
}
//ADD LABELS FROM DEBUG SECTIONS
res = asmfile_add_debug_labels(asmfile, lbls_by_addr);
if (ISERROR(res)) {
DBGMSG("%s: %s (%x)",
errcode_getmsg(WRN_DISASS_DBG_LBLS_NOT_RETRIEVED),
errcode_getmsg(res), res);
res = WRN_DISASS_DBG_LBLS_NOT_RETRIEVED;
}
hashtable_free(lbls_by_addr, NULL, NULL);
return res;
}
/*
* Changes a dynamic library in a file (used to replace a dynamic library by its patched version)
......
......@@ -419,18 +419,11 @@ extern elffile_t* parse_elf_file(char* filename, FILE* filedes,
elffile_t*** armbrs, int *n_armbrs, asmfile_t* asmf);
/**
* Update labels of .plt section using .rela.plt table and .got section
* \param asmf An asmfile to update
* \return EXIT_SUCCESS or error code
*/
extern int asmfile_add_plt_labels(asmfile_t* asmf);
/**
* Update labels of the given asmfile in using debug info if they are available.
* \param asmfile The asmfile to update
* \return EXIT_SUCCESS or error code
*/
extern int asmfile_add_debug_labels(asmfile_t* asmfile);
* Fills the labels structure in an asmfile with every labels that could be gathered from the binary file
* This include the symbols, labels deduced from the plt, and the debug labels
* \param asmfile The asmfile
* */
extern int asmfile_upd_labels_from_bin(asmfile_t* asmfile);
/**
* Returns the name of the file the structure contains the parsing of
......
......@@ -101,6 +101,8 @@ static void analyze_disassembled_file(project_t* project, asmfile_t* asmfile)
// At this point, data structures (functions, loops) are not modified, so
// ids for loops and blocks can be updated
DBGMSG0("update ids ...\n");
size_t flags_sz = asmfile->n_blocks+asmfile->n_functions; //Needs to be the size of blocks and we will be adding at least one block by function
char* flags = lc_malloc(flags_sz * sizeof(char));
FOREACH_INQUEUE(asmfile->functions, it__f) {
fct_t* f = GET_DATA_T(fct_t*, it__f);
//*
......@@ -130,7 +132,7 @@ static void analyze_disassembled_file(project_t* project, asmfile_t* asmfile)
{
block_t* b = GET_DATA_T(block_t*, it_en);
graph_add_edge(virtual->cfg_node, b->cfg_node, NULL);
DBGMSG("Add edge from virtual node %d to CC entry %d\n",
DBGMSGLVL (2, "Add edge from virtual node %d to CC entry %d\n",
virtual->global_id, b->global_id)
}
}
......@@ -141,13 +143,22 @@ static void analyze_disassembled_file(project_t* project, asmfile_t* asmfile)
block_t* b = GET_DATA_T(block_t*, it_b);
if (b->cfg_node->in == NULL) {
graph_add_edge(virtual->cfg_node, b->cfg_node, NULL);
DBGMSG("Add edge from virtual node %d to block %d\n",
DBGMSGLVL (2, "Add edge from virtual node %d to block %d\n",
virtual->global_id, b->global_id)
}
}
// Resets the flags and expand them if necessary
if (flags_sz < asmfile->n_blocks) {
flags_sz = asmfile->n_blocks;
/**\todo (2018-10-24) Check if this can happen (i.e. can blocks be created during this phase
* apart from the virtual block above). If it does, we may want to increase the size of flags
* by more than by one (*2 for instance) to avoid too many reallocs
* Otherwise we could simply remove this test*/
flags = lc_realloc(flags, flags_sz * sizeof(char));
}
memset(flags, 0, asmfile->n_blocks);
// Third step: check that all blocks are "linked" to the virtual block
char* flags = lc_malloc0(f->asmfile->n_blocks * sizeof(char));
graph_node_DFS(virtual->cfg_node, &f_node_before, NULL, NULL, flags);
FOREACH_INQUEUE(f->blocks, it_b0) {
......@@ -160,12 +171,12 @@ static void analyze_disassembled_file(project_t* project, asmfile_t* asmfile)
graph_add_edge(virtual->cfg_node, b->cfg_node, NULL);
}
}
lc_free(flags);
queue_add_head(f->blocks, virtual);
} //*/
fct_upd_loops_id(f);
fct_upd_blocks_id(f);
}
lc_free(flags);
#ifdef _MAQAO_TIMER_
t2 = clock();
printf ("update ids ...[%.2f s]\n", (float) (t2-t1) / CLOCKS_PER_SEC);
......
......@@ -397,6 +397,8 @@ char* errcode_getmsg(const int errcode) {
return "Unable to retrieve labels for external functions"; /**<Unable to retrieve labels for external functions*/
case WRN_DISASS_DBG_LBLS_NOT_RETRIEVED:
return "Unable to retrieve debug labels"; /**<Unable to retrieve debug labels*/
case WRN_DISASS_LBLS_NOT_RETRIEVED:
return "Unable to retrieve labels from binary file"; /**Unable to retrieve labels from binary file*/
case WRN_DISASS_FSM_RESET_ADDRESS_OUT_OF_RANGE:
return "Reset of the parser was requested to an out of range address"; /**<Requested parser reset to an out of range address*/
......
......@@ -311,6 +311,7 @@
#define WRN_DISASS_EXT_FCTS_LBLS_NOT_RETRIEVED ERRORCODE_DECLARE(ERRLVL_WRN, MODULE_DISASS, 0x0001) /**<Unable to retrieve labels for external functions*/
#define WRN_DISASS_DBG_LBLS_NOT_RETRIEVED ERRORCODE_DECLARE(ERRLVL_WRN, MODULE_DISASS, 0x0002) /**<Unable to retrieve debug labels*/
#define WRN_DISASS_LBLS_NOT_RETRIEVED ERRORCODE_DECLARE(ERRLVL_WRN, MODULE_DISASS, 0x0003) /**<Unable to retrieve labels from binary file*/
#define WRN_DISASS_FSM_RESET_ADDRESS_OUT_OF_RANGE ERRORCODE_DECLARE(ERRLVL_WRN, MODULE_DISASS, 0x0010) /**<Requested parser reset to an out of range address*/
#define WRN_DISASS_FSM_RESET_ADDRESS_PARSING_IN_PROGRESS ERRORCODE_DECLARE(ERRLVL_WRN, MODULE_DISASS, 0x0011) /**<Requested parser reset while parsing in progress*/
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment