[BACK]Return to compile-c-symbols.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / external / gpl3 / gdb.old / dist / gdb / compile

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/external/gpl3/gdb.old/dist/gdb/compile/compile-c-symbols.c between version 1.2 and 1.3

version 1.2, 2016/10/09 07:31:25 version 1.3, 2016/10/13 00:55:21
Line 20 
Line 20 
   
 #include "defs.h"  #include "defs.h"
 #include "compile-internal.h"  #include "compile-internal.h"
 #include "gdb_assert.h"  
 #include "symtab.h"  #include "symtab.h"
 #include "parser-defs.h"  #include "parser-defs.h"
 #include "block.h"  #include "block.h"
Line 187  convert_one_symbol (struct compile_c_ins
Line 186  convert_one_symbol (struct compile_c_ins
         case LOC_BLOCK:          case LOC_BLOCK:
           kind = GCC_C_SYMBOL_FUNCTION;            kind = GCC_C_SYMBOL_FUNCTION;
           addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));            addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
             if (is_global && TYPE_GNU_IFUNC (SYMBOL_TYPE (sym)))
               addr = gnu_ifunc_resolve_addr (target_gdbarch (), addr);
           break;            break;
   
         case LOC_CONST:          case LOC_CONST:
Line 336  convert_symbol_sym (struct compile_c_ins
Line 337  convert_symbol_sym (struct compile_c_ins
           && block_found != block_static_block (block_found))            && block_found != block_static_block (block_found))
         {          {
           if (compile_debug)            if (compile_debug)
             fprintf_unfiltered (gdb_stdout,              fprintf_unfiltered (gdb_stdlog,
                                 "gcc_convert_symbol \"%s\": global symbol\n",                                  "gcc_convert_symbol \"%s\": global symbol\n",
                                 identifier);                                  identifier);
           convert_one_symbol (context, global_sym, 1, 0);            convert_one_symbol (context, global_sym, 1, 0);
Line 344  convert_symbol_sym (struct compile_c_ins
Line 345  convert_symbol_sym (struct compile_c_ins
     }      }
   
   if (compile_debug)    if (compile_debug)
     fprintf_unfiltered (gdb_stdout,      fprintf_unfiltered (gdb_stdlog,
                         "gcc_convert_symbol \"%s\": local symbol\n",                          "gcc_convert_symbol \"%s\": local symbol\n",
                         identifier);                          identifier);
   convert_one_symbol (context, sym, 0, is_local_symbol);    convert_one_symbol (context, sym, 0, is_local_symbol);
Line 365  convert_symbol_bmsym (struct compile_c_i
Line 366  convert_symbol_bmsym (struct compile_c_i
   gcc_decl decl;    gcc_decl decl;
   CORE_ADDR addr;    CORE_ADDR addr;
   
     addr = MSYMBOL_VALUE_ADDRESS (objfile, msym);
   
   /* Conversion copied from write_exp_msymbol.  */    /* Conversion copied from write_exp_msymbol.  */
   switch (MSYMBOL_TYPE (msym))    switch (MSYMBOL_TYPE (msym))
     {      {
Line 376  convert_symbol_bmsym (struct compile_c_i
Line 379  convert_symbol_bmsym (struct compile_c_i
       break;        break;
   
     case mst_text_gnu_ifunc:      case mst_text_gnu_ifunc:
       type = objfile_type (objfile)->nodebug_text_gnu_ifunc_symbol;        /* nodebug_text_gnu_ifunc_symbol would cause:
            function return type cannot be function  */
         type = objfile_type (objfile)->nodebug_text_symbol;
       kind = GCC_C_SYMBOL_FUNCTION;        kind = GCC_C_SYMBOL_FUNCTION;
         addr = gnu_ifunc_resolve_addr (target_gdbarch (), addr);
       break;        break;
   
     case mst_data:      case mst_data:
Line 400  convert_symbol_bmsym (struct compile_c_i
Line 406  convert_symbol_bmsym (struct compile_c_i
     }      }
   
   sym_type = convert_type (context, type);    sym_type = convert_type (context, type);
   addr = MSYMBOL_VALUE_ADDRESS (objfile, msym);  
   decl = C_CTX (context)->c_ops->build_decl (C_CTX (context),    decl = C_CTX (context)->c_ops->build_decl (C_CTX (context),
                                              MSYMBOL_NATURAL_NAME (msym),                                               MSYMBOL_NATURAL_NAME (msym),
                                              kind, sym_type, NULL, addr,                                               kind, sym_type, NULL, addr,
Line 418  gcc_convert_symbol (void *datum,
Line 423  gcc_convert_symbol (void *datum,
 {  {
   struct compile_c_instance *context = datum;    struct compile_c_instance *context = datum;
   domain_enum domain;    domain_enum domain;
   volatile struct gdb_exception e;  
   int found = 0;    int found = 0;
   
   switch (request)    switch (request)
Line 438  gcc_convert_symbol (void *datum,
Line 442  gcc_convert_symbol (void *datum,
   
   /* We can't allow exceptions to escape out of this callback.  Safest    /* We can't allow exceptions to escape out of this callback.  Safest
      is to simply emit a gcc error.  */       is to simply emit a gcc error.  */
   TRY_CATCH (e, RETURN_MASK_ALL)    TRY
     {      {
       struct symbol *sym;        struct symbol *sym;
   
Line 461  gcc_convert_symbol (void *datum,
Line 465  gcc_convert_symbol (void *datum,
         }          }
     }      }
   
   if (e.reason < 0)    CATCH (e, RETURN_MASK_ALL)
     C_CTX (context)->c_ops->error (C_CTX (context), e.message);      {
         C_CTX (context)->c_ops->error (C_CTX (context), e.message);
       }
     END_CATCH
   
   if (compile_debug && !found)    if (compile_debug && !found)
     fprintf_unfiltered (gdb_stdout,      fprintf_unfiltered (gdb_stdlog,
                         "gcc_convert_symbol \"%s\": lookup_symbol failed\n",                          "gcc_convert_symbol \"%s\": lookup_symbol failed\n",
                         identifier);                          identifier);
   return;    return;
Line 478  gcc_symbol_address (void *datum, struct 
Line 485  gcc_symbol_address (void *datum, struct 
                     const char *identifier)                      const char *identifier)
 {  {
   struct compile_c_instance *context = datum;    struct compile_c_instance *context = datum;
   volatile struct gdb_exception e;  
   gcc_address result = 0;    gcc_address result = 0;
   int found = 0;    int found = 0;
   
   /* We can't allow exceptions to escape out of this callback.  Safest    /* We can't allow exceptions to escape out of this callback.  Safest
      is to simply emit a gcc error.  */       is to simply emit a gcc error.  */
   TRY_CATCH (e, RETURN_MASK_ERROR)    TRY
     {      {
       struct symbol *sym;        struct symbol *sym;
   
Line 493  gcc_symbol_address (void *datum, struct 
Line 499  gcc_symbol_address (void *datum, struct 
       if (sym != NULL && SYMBOL_CLASS (sym) == LOC_BLOCK)        if (sym != NULL && SYMBOL_CLASS (sym) == LOC_BLOCK)
         {          {
           if (compile_debug)            if (compile_debug)
             fprintf_unfiltered (gdb_stdout,              fprintf_unfiltered (gdb_stdlog,
                                 "gcc_symbol_address \"%s\": full symbol\n",                                  "gcc_symbol_address \"%s\": full symbol\n",
                                 identifier);                                  identifier);
           result = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));            result = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
             if (TYPE_GNU_IFUNC (SYMBOL_TYPE (sym)))
               result = gnu_ifunc_resolve_addr (target_gdbarch (), result);
           found = 1;            found = 1;
         }          }
       else        else
Line 507  gcc_symbol_address (void *datum, struct 
Line 515  gcc_symbol_address (void *datum, struct 
           if (msym.minsym != NULL)            if (msym.minsym != NULL)
             {              {
               if (compile_debug)                if (compile_debug)
                 fprintf_unfiltered (gdb_stdout,                  fprintf_unfiltered (gdb_stdlog,
                                     "gcc_symbol_address \"%s\": minimal "                                      "gcc_symbol_address \"%s\": minimal "
                                     "symbol\n",                                      "symbol\n",
                                     identifier);                                      identifier);
               result = BMSYMBOL_VALUE_ADDRESS (msym);                result = BMSYMBOL_VALUE_ADDRESS (msym);
                 if (MSYMBOL_TYPE (msym.minsym) == mst_text_gnu_ifunc)
                   result = gnu_ifunc_resolve_addr (target_gdbarch (), result);
               found = 1;                found = 1;
             }              }
         }          }
     }      }
   
   if (e.reason < 0)    CATCH (e, RETURN_MASK_ERROR)
     C_CTX (context)->c_ops->error (C_CTX (context), e.message);      {
         C_CTX (context)->c_ops->error (C_CTX (context), e.message);
       }
     END_CATCH
   
   if (compile_debug && !found)    if (compile_debug && !found)
     fprintf_unfiltered (gdb_stdout,      fprintf_unfiltered (gdb_stdlog,
                         "gcc_symbol_address \"%s\": failed\n",                          "gcc_symbol_address \"%s\": failed\n",
                         identifier);                          identifier);
   return result;    return result;
Line 633  generate_c_for_for_one_variable (struct 
Line 646  generate_c_for_for_one_variable (struct 
                                  CORE_ADDR pc,                                   CORE_ADDR pc,
                                  struct symbol *sym)                                   struct symbol *sym)
 {  {
   volatile struct gdb_exception e;  
   
   TRY_CATCH (e, RETURN_MASK_ERROR)    TRY
     {      {
       if (is_dynamic_type (SYMBOL_TYPE (sym)))        if (is_dynamic_type (SYMBOL_TYPE (sym)))
         {          {
Line 689  generate_c_for_for_one_variable (struct 
Line 701  generate_c_for_for_one_variable (struct 
         }          }
     }      }
   
   if (e.reason >= 0)    CATCH (e, RETURN_MASK_ERROR)
     return;      {
         if (compiler->symbol_err_map == NULL)
   if (compiler->symbol_err_map == NULL)          compiler->symbol_err_map = htab_create_alloc (10,
     compiler->symbol_err_map = htab_create_alloc (10,                                                        hash_symbol_error,
                                                   hash_symbol_error,                                                        eq_symbol_error,
                                                   eq_symbol_error,                                                        del_symbol_error,
                                                   del_symbol_error,                                                        xcalloc,
                                                   xcalloc,                                                        xfree);
                                                   xfree);        insert_symbol_error (compiler->symbol_err_map, sym, e.message);
   insert_symbol_error (compiler->symbol_err_map, sym, e.message);      }
     END_CATCH
 }  }
   
 /* See compile-internal.h.  */  /* See compile-internal.h.  */

Legend:
Removed from v.1.2  
changed lines
  Added in v.1.3

CVSweb <webmaster@jp.NetBSD.org>