gcc/dwarf2out.h

   1 /* dwarf2out.h - Various declarations for functions found in dwarf2out.c
   2    Copyright (C) 1998-2021 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef GCC_DWARF2OUT_H
  21 #define GCC_DWARF2OUT_H 1
  22
  23 #include "dwarf2.h"     /* ??? Remove this once only used by dwarf2foo.c.  */
  24
  25 typedef struct die_struct *dw_die_ref;
  26 typedef const struct die_struct *const_dw_die_ref;
  27
  28 typedef struct dw_val_node *dw_val_ref;
  29 typedef struct dw_cfi_node *dw_cfi_ref;
  30 typedef struct dw_loc_descr_node *dw_loc_descr_ref;
  31 typedef struct dw_loc_list_struct *dw_loc_list_ref;
  32 typedef struct dw_discr_list_node *dw_discr_list_ref;
  33 typedef wide_int *wide_int_ptr;
  34
  35
  36 /* Call frames are described using a sequence of Call Frame
  37    Information instructions.  The register number, offset
  38    and address fields are provided as possible operands;
  39    their use is selected by the opcode field.  */
  40
  41 enum dw_cfi_oprnd_type {
  42   dw_cfi_oprnd_unused,
  43   dw_cfi_oprnd_reg_num,
  44   dw_cfi_oprnd_offset,
  45   dw_cfi_oprnd_addr,
  46   dw_cfi_oprnd_loc,
  47   dw_cfi_oprnd_cfa_loc
  48 };
  49
  50 typedef union GTY(()) {
  51   unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
  52   HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
  53   const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
  54   struct dw_loc_descr_node * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
  55   struct dw_cfa_location * GTY ((tag ("dw_cfi_oprnd_cfa_loc")))
  56     dw_cfi_cfa_loc;
  57 } dw_cfi_oprnd;
  58
  59 struct GTY(()) dw_cfi_node {
  60   enum dwarf_call_frame_info dw_cfi_opc;
  61   dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
  62     dw_cfi_oprnd1;
  63   dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
  64     dw_cfi_oprnd2;
  65 };
  66
  67
  68 typedef vec<dw_cfi_ref, va_gc> *cfi_vec;
  69
  70 typedef struct dw_fde_node *dw_fde_ref;
  71
  72 /* All call frame descriptions (FDE's) in the GCC generated DWARF
  73    refer to a single Common Information Entry (CIE), defined at
  74    the beginning of the .debug_frame section.  This use of a single
  75    CIE obviates the need to keep track of multiple CIE's
  76    in the DWARF generation routines below.  */
  77
  78 struct GTY(()) dw_fde_node {
  79   tree decl;
  80   const char *dw_fde_begin;
  81   const char *dw_fde_current_label;
  82   const char *dw_fde_end;
  83   const char *dw_fde_vms_end_prologue;
  84   const char *dw_fde_vms_begin_epilogue;
  85   const char *dw_fde_second_begin;
  86   const char *dw_fde_second_end;
  87   cfi_vec dw_fde_cfi;
  88   int dw_fde_switch_cfi_index; /* Last CFI before switching sections.  */
  89   HOST_WIDE_INT stack_realignment;
  90
  91   unsigned funcdef_number;
  92   unsigned fde_index;
  93
  94   /* Dynamic realign argument pointer register.  */
  95   unsigned int drap_reg;
  96   /* Virtual dynamic realign argument pointer register.  */
  97   unsigned int vdrap_reg;
  98   /* These 3 flags are copied from rtl_data in function.h.  */
  99   unsigned all_throwers_are_sibcalls : 1;
 100   unsigned uses_eh_lsda : 1;
 101   unsigned nothrow : 1;
 102   /* Whether we did stack realign in this call frame.  */
 103   unsigned stack_realign : 1;
 104   /* Whether dynamic realign argument pointer register has been saved.  */
 105   unsigned drap_reg_saved: 1;
 106   /* True iff dw_fde_begin label is in text_section or cold_text_section.  */
 107   unsigned in_std_section : 1;
 108   /* True iff dw_fde_second_begin label is in text_section or
 109      cold_text_section.  */
 110   unsigned second_in_std_section : 1;
 111   /* True if Rule 18 described in dwarf2cfi.c is in action, i.e. for dynamic
 112      stack realignment in between pushing of hard frame pointer to stack
 113      and setting hard frame pointer to stack pointer.  The register save for
 114      hard frame pointer register should be emitted only on the latter
 115      instruction.  */
 116   unsigned rule18 : 1;
 117   /* True if this function is to be ignored by debugger.  */
 118   unsigned ignored_debug : 1;
 119 };
 120
 121
 122 /* This is how we define the location of the CFA. We use to handle it
 123    as REG + OFFSET all the time,  but now it can be more complex.
 124    It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
 125    Instead of passing around REG and OFFSET, we pass a copy
 126    of this structure.  */
 127 struct GTY(()) dw_cfa_location {
 128   poly_int64_pod offset;
 129   poly_int64_pod base_offset;
 130   /* REG is in DWARF_FRAME_REGNUM space, *not* normal REGNO space.  */
 131   unsigned int reg;
 132   BOOL_BITFIELD indirect : 1;  /* 1 if CFA is accessed via a dereference.  */
 133   BOOL_BITFIELD in_use : 1;    /* 1 if a saved cfa is stored here.  */
 134 };
 135
 136
 137 /* Each DIE may have a series of attribute/value pairs.  Values
 138    can take on several forms.  The forms that are used in this
 139    implementation are listed below.  */
 140
 141 enum dw_val_class
 142 {
 143   dw_val_class_none,
 144   dw_val_class_addr,
 145   dw_val_class_offset,
 146   dw_val_class_loc,
 147   dw_val_class_loc_list,
 148   dw_val_class_range_list,
 149   dw_val_class_const,
 150   dw_val_class_unsigned_const,
 151   dw_val_class_const_double,
 152   dw_val_class_wide_int,
 153   dw_val_class_vec,
 154   dw_val_class_flag,
 155   dw_val_class_die_ref,
 156   dw_val_class_fde_ref,
 157   dw_val_class_lbl_id,
 158   dw_val_class_lineptr,
 159   dw_val_class_str,
 160   dw_val_class_macptr,
 161   dw_val_class_loclistsptr,
 162   dw_val_class_file,
 163   dw_val_class_data8,
 164   dw_val_class_decl_ref,
 165   dw_val_class_vms_delta,
 166   dw_val_class_high_pc,
 167   dw_val_class_discr_value,
 168   dw_val_class_discr_list,
 169   dw_val_class_const_implicit,
 170   dw_val_class_unsigned_const_implicit,
 171   dw_val_class_file_implicit,
 172   dw_val_class_view_list,
 173   dw_val_class_symview
 174 };
 175
 176 /* Describe a floating point constant value, or a vector constant value.  */
 177
 178 struct GTY(()) dw_vec_const {
 179   void * GTY((atomic)) array;
 180   unsigned length;
 181   unsigned elt_size;
 182 };
 183
 184 /* Describe a single value that a discriminant can match.
 185
 186    Discriminants (in the "record variant part" meaning) are scalars.
 187    dw_discr_list_ref and dw_discr_value are a mean to describe a set of
 188    discriminant values that are matched by a particular variant.
 189
 190    Discriminants can be signed or unsigned scalars, and can be discriminants
 191    values.  Both have to be consistent, though.  */
 192
 193 struct GTY(()) dw_discr_value {
 194   int pos; /* Whether the discriminant value is positive (unsigned).  */
 195   union
 196     {
 197       HOST_WIDE_INT GTY ((tag ("0"))) sval;
 198       unsigned HOST_WIDE_INT GTY ((tag ("1"))) uval;
 199     }
 200   GTY ((desc ("%1.pos"))) v;
 201 };
 202
 203 struct addr_table_entry;
 204
 205 /* The dw_val_node describes an attribute's value, as it is
 206    represented internally.  */
 207
 208 struct GTY(()) dw_val_node {
 209   enum dw_val_class val_class;
 210   struct addr_table_entry * GTY(()) val_entry;
 211   union dw_val_struct_union
 212     {
 213       rtx GTY ((tag ("dw_val_class_addr"))) val_addr;
 214       unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset;
 215       dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
 216       dw_die_ref GTY ((tag ("dw_val_class_view_list"))) val_view_list;
 217       dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
 218       HOST_WIDE_INT GTY ((default)) val_int;
 219       unsigned HOST_WIDE_INT
 220         GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
 221       double_int GTY ((tag ("dw_val_class_const_double"))) val_double;
 222       wide_int_ptr GTY ((tag ("dw_val_class_wide_int"))) val_wide;
 223       dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec;
 224       struct dw_val_die_union
 225         {
 226           dw_die_ref die;
 227           int external;
 228         } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref;
 229       unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index;
 230       struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str;
 231       char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id;
 232       unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag;
 233       struct dwarf_file_data * GTY ((tag ("dw_val_class_file"))) val_file;
 234       struct dwarf_file_data *
 235         GTY ((tag ("dw_val_class_file_implicit"))) val_file_implicit;
 236       unsigned char GTY ((tag ("dw_val_class_data8"))) val_data8[8];
 237       tree GTY ((tag ("dw_val_class_decl_ref"))) val_decl_ref;
 238       struct dw_val_vms_delta_union
 239         {
 240           char * lbl1;
 241           char * lbl2;
 242         } GTY ((tag ("dw_val_class_vms_delta"))) val_vms_delta;
 243       dw_discr_value GTY ((tag ("dw_val_class_discr_value"))) val_discr_value;
 244       dw_discr_list_ref GTY ((tag ("dw_val_class_discr_list"))) val_discr_list;
 245       char * GTY ((tag ("dw_val_class_symview"))) val_symbolic_view;
 246     }
 247   GTY ((desc ("%1.val_class"))) v;
 248 };
 249
 250 /* Locations in memory are described using a sequence of stack machine
 251    operations.  */
 252
 253 struct GTY((chain_next ("%h.dw_loc_next"))) dw_loc_descr_node {
 254   dw_loc_descr_ref dw_loc_next;
 255   ENUM_BITFIELD (dwarf_location_atom) dw_loc_opc : 8;
 256   /* Used to distinguish DW_OP_addr with a direct symbol relocation
 257      from DW_OP_addr with a dtp-relative symbol relocation.  */
 258   unsigned int dtprel : 1;
 259   /* For DW_OP_pick, DW_OP_dup and DW_OP_over operations: true iff.
 260      it targets a DWARF prodecure argument.  In this case, it needs to be
 261      relocated according to the current frame offset.  */
 262   unsigned int frame_offset_rel : 1;
 263   int dw_loc_addr;
 264   dw_val_node dw_loc_oprnd1;
 265   dw_val_node dw_loc_oprnd2;
 266 };
 267
 268 /* A variant (inside a record variant part) is selected when the corresponding
 269    discriminant matches its set of values (see the comment for dw_discr_value).
 270    The following datastructure holds such matching information.  */
 271
 272 struct GTY(()) dw_discr_list_node {
 273   dw_discr_list_ref dw_discr_next;
 274
 275   dw_discr_value dw_discr_lower_bound;
 276   dw_discr_value dw_discr_upper_bound;
 277   /* This node represents only the value in dw_discr_lower_bound when it's
 278      zero.  It represents the range between the two fields (bounds included)
 279      otherwise.  */
 280   int dw_discr_range;
 281 };
 282
 283 /* Interface from dwarf2out.c to dwarf2cfi.c.  */
 284 extern struct dw_loc_descr_node *build_cfa_loc
 285   (dw_cfa_location *, poly_int64);
 286 extern struct dw_loc_descr_node *build_cfa_aligned_loc
 287   (dw_cfa_location *, poly_int64, HOST_WIDE_INT);
 288 extern struct dw_loc_descr_node *mem_loc_descriptor
 289   (rtx, machine_mode mode, machine_mode mem_mode,
 290    enum var_init_status);
 291 extern bool loc_descr_equal_p (dw_loc_descr_ref, dw_loc_descr_ref);
 292 extern dw_fde_ref dwarf2out_alloc_current_fde (void);
 293
 294 extern unsigned long size_of_locs (dw_loc_descr_ref);
 295 extern void output_loc_sequence (dw_loc_descr_ref, int);
 296 extern void output_loc_sequence_raw (dw_loc_descr_ref);
 297
 298 /* Interface from dwarf2cfi.c to dwarf2out.c.  */
 299 extern void lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc,
 300                           dw_cfa_location *remember);
 301 extern bool cfa_equal_p (const dw_cfa_location *, const dw_cfa_location *);
 302
 303 extern void output_cfi (dw_cfi_ref, dw_fde_ref, int);
 304
 305 extern GTY(()) cfi_vec cie_cfi_vec;
 306
 307 /* Interface from dwarf2*.c to the rest of the compiler.  */
 308 extern enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
 309   (enum dwarf_call_frame_info cfi);
 310 extern enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
 311   (enum dwarf_call_frame_info cfi);
 312
 313 extern void output_cfi_directive (FILE *f, struct dw_cfi_node *cfi);
 314
 315 extern void dwarf2out_emit_cfi (dw_cfi_ref cfi);
 316
 317 extern void debug_dwarf (void);
 318 struct die_struct;
 319 extern void debug_dwarf_die (struct die_struct *);
 320 extern void debug_dwarf_loc_descr (dw_loc_descr_ref);
 321 extern void debug (die_struct &ref);
 322 extern void debug (die_struct *ptr);
 323 extern void dwarf2out_set_demangle_name_func (const char *(*) (const char *));
 324 #ifdef VMS_DEBUGGING_INFO
 325 extern void dwarf2out_vms_debug_main_pointer (void);
 326 #endif
 327
 328 enum array_descr_ordering
 329 {
 330   array_descr_ordering_default,
 331   array_descr_ordering_row_major,
 332   array_descr_ordering_column_major
 333 };
 334
 335 #define DWARF2OUT_ARRAY_DESCR_INFO_MAX_DIMEN 16
 336
 337 struct array_descr_info
 338 {
 339   int ndimensions;
 340   enum array_descr_ordering ordering;
 341   tree element_type;
 342   tree base_decl;
 343   tree data_location;
 344   tree allocated;
 345   tree associated;
 346   tree stride;
 347   tree rank;
 348   bool stride_in_bits;
 349   struct array_descr_dimen
 350     {
 351       /* GCC uses sizetype for array indices, so lower_bound and upper_bound
 352          will likely be "sizetype" values. However, bounds may have another
 353          type in the original source code.  */
 354       tree bounds_type;
 355       tree lower_bound;
 356       tree upper_bound;
 357
 358       /* Only Fortran uses more than one dimension for array types.  For other
 359          languages, the stride can be rather specified for the whole array.  */
 360       tree stride;
 361     } dimen[DWARF2OUT_ARRAY_DESCR_INFO_MAX_DIMEN];
 362 };
 363
 364 enum fixed_point_scale_factor
 365 {
 366   fixed_point_scale_factor_binary,
 367   fixed_point_scale_factor_decimal,
 368   fixed_point_scale_factor_arbitrary
 369 };
 370
 371 struct fixed_point_type_info
 372 {
 373   /* The scale factor is the value one has to multiply the actual data with
 374      to get the fixed point value.  We support three ways to encode it.  */
 375   enum fixed_point_scale_factor scale_factor_kind;
 376   union
 377     {
 378       /* For a binary scale factor, the scale factor is 2 ** binary.  */
 379       int binary;
 380       /* For a decimal scale factor, the scale factor is 10 ** decimal.  */
 381       int decimal;
 382       /* For an arbitrary scale factor, the scale factor is the ratio
 383          numerator / denominator.  */
 384       struct { tree numerator; tree denominator; } arbitrary;
 385     } scale_factor;
 386 };
 387
 388 void dwarf2out_c_finalize (void);
 389
 390 /* Some DWARF internals are exposed for the needs of DWARF-based debug
 391    formats.  */
 392
 393 /* Each DIE attribute has a field specifying the attribute kind,
 394    a link to the next attribute in the chain, and an attribute value.
 395    Attributes are typically linked below the DIE they modify.  */
 396
 397 typedef struct GTY(()) dw_attr_struct {
 398   enum dwarf_attribute dw_attr;
 399   dw_val_node dw_attr_val;
 400 }
 401 dw_attr_node;
 402
 403 extern dw_attr_node *get_AT (dw_die_ref, enum dwarf_attribute);
 404 extern HOST_WIDE_INT AT_int (dw_attr_node *);
 405 extern unsigned HOST_WIDE_INT AT_unsigned (dw_attr_node *a);
 406 extern dw_loc_descr_ref AT_loc (dw_attr_node *);
 407 extern dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
 408 extern const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
 409 extern enum dw_val_class AT_class (dw_attr_node *);
 410 extern unsigned HOST_WIDE_INT AT_unsigned (dw_attr_node *);
 411 extern unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
 412 extern int get_AT_flag (dw_die_ref, enum dwarf_attribute);
 413
 414 extern void add_name_attribute (dw_die_ref, const char *);
 415
 416 extern dw_die_ref new_die_raw (enum dwarf_tag);
 417 extern dw_die_ref base_type_die (tree, bool);
 418
 419 extern dw_die_ref lookup_decl_die (tree);
 420
 421 extern dw_die_ref dw_get_die_child (dw_die_ref);
 422 extern dw_die_ref dw_get_die_sib (dw_die_ref);
 423 extern enum dwarf_tag dw_get_die_tag (dw_die_ref);
 424
 425 /* Data about a single source file.  */
 426 struct GTY((for_user)) dwarf_file_data {
 427   const char * key;
 428   const char * filename;
 429   int emitted_number;
 430 };
 431
 432 extern struct dwarf_file_data *get_AT_file (dw_die_ref,
 433                                             enum dwarf_attribute);
 434
 435 #endif /* GCC_DWARF2OUT_H */