gdb/compile/compile-c-support.c

   1 /* C language support for compilation.
   2
   3    Copyright (C) 2014-2016 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "compile-internal.h"
  22 #include "compile.h"
  23 #include "gdb-dlfcn.h"
  24 #include "c-lang.h"
  25 #include "macrotab.h"
  26 #include "macroscope.h"
  27 #include "regcache.h"
  28
  29 /* See compile-internal.h.  */
  30
  31 const char *
  32 c_get_mode_for_size (int size)
  33 {
  34   const char *mode = NULL;
  35
  36   switch (size)
  37     {
  38     case 1:
  39       mode = "QI";
  40       break;
  41     case 2:
  42       mode = "HI";
  43       break;
  44     case 4:
  45       mode = "SI";
  46       break;
  47     case 8:
  48       mode = "DI";
  49       break;
  50     default:
  51       internal_error (__FILE__, __LINE__, _("Invalid GCC mode size %d."), size);
  52     }
  53
  54   return mode;
  55 }
  56
  57 /* See compile-internal.h.  */
  58
  59 char *
  60 c_get_range_decl_name (const struct dynamic_prop *prop)
  61 {
  62   return xstrprintf ("__gdb_prop_%s", host_address_to_string (prop));
  63 }
  64
  65 \f
  66
  67 #define STR(x) #x
  68 #define STRINGIFY(x) STR(x)
  69
  70 /* Helper function for c_get_compile_context.  Open the GCC front-end
  71    shared library and return the symbol specified by the current
  72    GCC_C_FE_CONTEXT.  */
  73
  74 static gcc_c_fe_context_function *
  75 load_libcc (void)
  76 {
  77   void *handle;
  78   gcc_c_fe_context_function *func;
  79
  80    /* gdb_dlopen will call error () on an error, so no need to check
  81       value.  */
  82   handle = gdb_dlopen (STRINGIFY (GCC_C_FE_LIBCC));
  83   func = (gcc_c_fe_context_function *) gdb_dlsym (handle,
  84                                                   STRINGIFY (GCC_C_FE_CONTEXT));
  85
  86   if (func == NULL)
  87     error (_("could not find symbol %s in library %s"),
  88            STRINGIFY (GCC_C_FE_CONTEXT),
  89            STRINGIFY (GCC_C_FE_LIBCC));
  90   return func;
  91 }
  92
  93 /* Return the compile instance associated with the current context.
  94    This function calls the symbol returned from the load_libcc
  95    function.  This will provide the gcc_c_context.  */
  96
  97 struct compile_instance *
  98 c_get_compile_context (void)
  99 {
 100   static gcc_c_fe_context_function *func;
 101
 102   struct gcc_c_context *context;
 103
 104   if (func == NULL)
 105     {
 106       func = load_libcc ();
 107       gdb_assert (func != NULL);
 108     }
 109
 110   context = (*func) (GCC_FE_VERSION_0, GCC_C_FE_VERSION_0);
 111   if (context == NULL)
 112     error (_("The loaded version of GCC does not support the required version "
 113              "of the API."));
 114
 115   return new_compile_instance (context);
 116 }
 117
 118 \f
 119
 120 /* Write one macro definition.  */
 121
 122 static void
 123 print_one_macro (const char *name, const struct macro_definition *macro,
 124                  struct macro_source_file *source, int line,
 125                  void *user_data)
 126 {
 127   struct ui_file *file = (struct ui_file *) user_data;
 128
 129   /* Don't print command-line defines.  They will be supplied another
 130      way.  */
 131   if (line == 0)
 132     return;
 133
 134   /* None of -Wno-builtin-macro-redefined, #undef first
 135      or plain #define of the same value would avoid a warning.  */
 136   fprintf_filtered (file, "#ifndef %s\n# define %s", name, name);
 137
 138   if (macro->kind == macro_function_like)
 139     {
 140       int i;
 141
 142       fputs_filtered ("(", file);
 143       for (i = 0; i < macro->argc; i++)
 144         {
 145           fputs_filtered (macro->argv[i], file);
 146           if (i + 1 < macro->argc)
 147             fputs_filtered (", ", file);
 148         }
 149       fputs_filtered (")", file);
 150     }
 151
 152   fprintf_filtered (file, " %s\n#endif\n", macro->replacement);
 153 }
 154
 155 /* Write macro definitions at PC to FILE.  */
 156
 157 static void
 158 write_macro_definitions (const struct block *block, CORE_ADDR pc,
 159                          struct ui_file *file)
 160 {
 161   struct macro_scope *scope;
 162
 163   if (block != NULL)
 164     scope = sal_macro_scope (find_pc_line (pc, 0));
 165   else
 166     scope = default_macro_scope ();
 167   if (scope == NULL)
 168     scope = user_macro_scope ();
 169
 170   if (scope != NULL && scope->file != NULL && scope->file->table != NULL)
 171     macro_for_each_in_scope (scope->file, scope->line, print_one_macro, file);
 172 }
 173
 174 /* Helper function to construct a header scope for a block of code.
 175    Takes a scope argument which selects the correct header to
 176    insert into BUF.  */
 177
 178 static void
 179 add_code_header (enum compile_i_scope_types type, struct ui_file *buf)
 180 {
 181   switch (type)
 182     {
 183     case COMPILE_I_SIMPLE_SCOPE:
 184       fputs_unfiltered ("void "
 185                         GCC_FE_WRAPPER_FUNCTION
 186                         " (struct "
 187                         COMPILE_I_SIMPLE_REGISTER_STRUCT_TAG
 188                         " *"
 189                         COMPILE_I_SIMPLE_REGISTER_ARG_NAME
 190                         ") {\n",
 191                         buf);
 192       break;
 193     case COMPILE_I_PRINT_ADDRESS_SCOPE:
 194     case COMPILE_I_PRINT_VALUE_SCOPE:
 195       /* <string.h> is needed for a memcpy call below.  */
 196       fputs_unfiltered ("#include <string.h>\n"
 197                         "void "
 198                         GCC_FE_WRAPPER_FUNCTION
 199                         " (struct "
 200                         COMPILE_I_SIMPLE_REGISTER_STRUCT_TAG
 201                         " *"
 202                         COMPILE_I_SIMPLE_REGISTER_ARG_NAME
 203                         ", "
 204                         COMPILE_I_PRINT_OUT_ARG_TYPE
 205                         " "
 206                         COMPILE_I_PRINT_OUT_ARG
 207                         ") {\n",
 208                         buf);
 209       break;
 210
 211     case COMPILE_I_RAW_SCOPE:
 212       break;
 213     default:
 214       gdb_assert_not_reached (_("Unknown compiler scope reached."));
 215     }
 216 }
 217
 218 /* Helper function to construct a footer scope for a block of code.
 219    Takes a scope argument which selects the correct footer to
 220    insert into BUF.  */
 221
 222 static void
 223 add_code_footer (enum compile_i_scope_types type, struct ui_file *buf)
 224 {
 225   switch (type)
 226     {
 227     case COMPILE_I_SIMPLE_SCOPE:
 228     case COMPILE_I_PRINT_ADDRESS_SCOPE:
 229     case COMPILE_I_PRINT_VALUE_SCOPE:
 230       fputs_unfiltered ("}\n", buf);
 231       break;
 232     case COMPILE_I_RAW_SCOPE:
 233       break;
 234     default:
 235       gdb_assert_not_reached (_("Unknown compiler scope reached."));
 236     }
 237 }
 238
 239 /* Generate a structure holding all the registers used by the function
 240    we're generating.  */
 241
 242 static void
 243 generate_register_struct (struct ui_file *stream, struct gdbarch *gdbarch,
 244                           const unsigned char *registers_used)
 245 {
 246   int i;
 247   int seen = 0;
 248
 249   fputs_unfiltered ("struct " COMPILE_I_SIMPLE_REGISTER_STRUCT_TAG " {\n",
 250                     stream);
 251
 252   if (registers_used != NULL)
 253     for (i = 0; i < gdbarch_num_regs (gdbarch); ++i)
 254       {
 255         if (registers_used[i])
 256           {
 257             struct type *regtype = check_typedef (register_type (gdbarch, i));
 258             char *regname = compile_register_name_mangled (gdbarch, i);
 259             struct cleanup *cleanups = make_cleanup (xfree, regname);
 260
 261             seen = 1;
 262
 263             /* You might think we could use type_print here.  However,
 264                target descriptions often use types with names like
 265                "int64_t", which may not be defined in the inferior
 266                (and in any case would not be looked up due to the
 267                #pragma business).  So, we take a much simpler
 268                approach: for pointer- or integer-typed registers, emit
 269                the field in the most direct way; and for other
 270                register types (typically flags or vectors), emit a
 271                maximally-aligned array of the correct size.  */
 272
 273             fputs_unfiltered ("  ", stream);
 274             switch (TYPE_CODE (regtype))
 275               {
 276               case TYPE_CODE_PTR:
 277                 fprintf_filtered (stream, "__gdb_uintptr %s", regname);
 278                 break;
 279
 280               case TYPE_CODE_INT:
 281                 {
 282                   const char *mode
 283                     = c_get_mode_for_size (TYPE_LENGTH (regtype));
 284
 285                   if (mode != NULL)
 286                     {
 287                       if (TYPE_UNSIGNED (regtype))
 288                         fputs_unfiltered ("unsigned ", stream);
 289                       fprintf_unfiltered (stream,
 290                                           "int %s"
 291                                           " __attribute__ ((__mode__(__%s__)))",
 292                                           regname,
 293                                           mode);
 294                       break;
 295                     }
 296                 }
 297
 298                 /* Fall through.  */
 299
 300               default:
 301                 fprintf_unfiltered (stream,
 302                                     "  unsigned char %s[%d]"
 303                                     " __attribute__((__aligned__("
 304                                     "__BIGGEST_ALIGNMENT__)))",
 305                                     regname,
 306                                     TYPE_LENGTH (regtype));
 307               }
 308             fputs_unfiltered (";\n", stream);
 309
 310             do_cleanups (cleanups);
 311           }
 312       }
 313
 314   if (!seen)
 315     fputs_unfiltered ("  char " COMPILE_I_SIMPLE_REGISTER_DUMMY ";\n",
 316                       stream);
 317
 318   fputs_unfiltered ("};\n\n", stream);
 319 }
 320
 321 /* Take the source code provided by the user with the 'compile'
 322    command, and compute the additional wrapping, macro, variable and
 323    register operations needed.  INPUT is the source code derived from
 324    the 'compile' command, GDBARCH is the architecture to use when
 325    computing above, EXPR_BLOCK denotes the block relevant contextually
 326    to the inferior when the expression was created, and EXPR_PC
 327    indicates the value of $PC.  */
 328
 329 std::string
 330 c_compute_program (struct compile_instance *inst,
 331                    const char *input,
 332                    struct gdbarch *gdbarch,
 333                    const struct block *expr_block,
 334                    CORE_ADDR expr_pc)
 335 {
 336   struct ui_file *buf, *var_stream = NULL;
 337   std::string code;
 338   struct cleanup *cleanup;
 339   struct compile_c_instance *context = (struct compile_c_instance *) inst;
 340
 341   buf = mem_fileopen ();
 342   cleanup = make_cleanup_ui_file_delete (buf);
 343
 344   write_macro_definitions (expr_block, expr_pc, buf);
 345
 346   /* Do not generate local variable information for "raw"
 347      compilations.  In this case we aren't emitting our own function
 348      and the user's code may only refer to globals.  */
 349   if (inst->scope != COMPILE_I_RAW_SCOPE)
 350     {
 351       unsigned char *registers_used;
 352       int i;
 353
 354       /* Generate the code to compute variable locations, but do it
 355          before generating the function header, so we can define the
 356          register struct before the function body.  This requires a
 357          temporary stream.  */
 358       var_stream = mem_fileopen ();
 359       make_cleanup_ui_file_delete (var_stream);
 360       registers_used = generate_c_for_variable_locations (context,
 361                                                           var_stream, gdbarch,
 362                                                           expr_block, expr_pc);
 363       make_cleanup (xfree, registers_used);
 364
 365       fputs_unfiltered ("typedef unsigned int"
 366                         " __attribute__ ((__mode__(__pointer__)))"
 367                         " __gdb_uintptr;\n",
 368                         buf);
 369       fputs_unfiltered ("typedef int"
 370                         " __attribute__ ((__mode__(__pointer__)))"
 371                         " __gdb_intptr;\n",
 372                         buf);
 373
 374       /* Iterate all log2 sizes in bytes supported by c_get_mode_for_size.  */
 375       for (i = 0; i < 4; ++i)
 376         {
 377           const char *mode = c_get_mode_for_size (1 << i);
 378
 379           gdb_assert (mode != NULL);
 380           fprintf_unfiltered (buf,
 381                               "typedef int"
 382                               " __attribute__ ((__mode__(__%s__)))"
 383                               " __gdb_int_%s;\n",
 384                               mode, mode);
 385         }
 386
 387       generate_register_struct (buf, gdbarch, registers_used);
 388     }
 389
 390   add_code_header (inst->scope, buf);
 391
 392   if (inst->scope == COMPILE_I_SIMPLE_SCOPE
 393       || inst->scope == COMPILE_I_PRINT_ADDRESS_SCOPE
 394       || inst->scope == COMPILE_I_PRINT_VALUE_SCOPE)
 395     {
 396       ui_file_put (var_stream, ui_file_write_for_put, buf);
 397       fputs_unfiltered ("#pragma GCC user_expression\n", buf);
 398     }
 399
 400   /* The user expression has to be in its own scope, so that "extern"
 401      works properly.  Otherwise gcc thinks that the "extern"
 402      declaration is in the same scope as the declaration provided by
 403      gdb.  */
 404   if (inst->scope != COMPILE_I_RAW_SCOPE)
 405     fputs_unfiltered ("{\n", buf);
 406
 407   fputs_unfiltered ("#line 1 \"gdb command line\"\n", buf);
 408
 409   switch (inst->scope)
 410     {
 411     case COMPILE_I_PRINT_ADDRESS_SCOPE:
 412     case COMPILE_I_PRINT_VALUE_SCOPE:
 413       fprintf_unfiltered (buf,
 414 "__auto_type " COMPILE_I_EXPR_VAL " = %s;\n"
 415 "typeof (%s) *" COMPILE_I_EXPR_PTR_TYPE ";\n"
 416 "memcpy (" COMPILE_I_PRINT_OUT_ARG ", %s" COMPILE_I_EXPR_VAL ",\n"
 417          "sizeof (*" COMPILE_I_EXPR_PTR_TYPE "));\n"
 418                           , input, input,
 419                           (inst->scope == COMPILE_I_PRINT_ADDRESS_SCOPE
 420                            ? "&" : ""));
 421       break;
 422     default:
 423       fputs_unfiltered (input, buf);
 424       break;
 425     }
 426
 427   fputs_unfiltered ("\n", buf);
 428
 429   /* For larger user expressions the automatic semicolons may be
 430      confusing.  */
 431   if (strchr (input, '\n') == NULL)
 432     fputs_unfiltered (";\n", buf);
 433
 434   if (inst->scope != COMPILE_I_RAW_SCOPE)
 435     fputs_unfiltered ("}\n", buf);
 436
 437   add_code_footer (inst->scope, buf);
 438   code = ui_file_as_string (buf);
 439   do_cleanups (cleanup);
 440   return code;
 441 }