gcc/dwarf2out.h

   1 /* dwarf2out.h - Various declarations for functions found in dwarf2out.cc
   2    Copyright (C) 1998-2024 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 struct dw_wide_int *dw_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 enum dw_cfi_oprnd_type: int {
  41   dw_cfi_oprnd_unused,
  42   dw_cfi_oprnd_reg_num,
  43   dw_cfi_oprnd_offset,
  44   dw_cfi_oprnd_addr,
  45   dw_cfi_oprnd_loc,
  46   dw_cfi_oprnd_cfa_loc
  47 };
  48
  49 typedef union GTY(()) {
  50   unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
  51   HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
  52   const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
  53   struct dw_loc_descr_node * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
  54   struct dw_cfa_location * GTY ((tag ("dw_cfi_oprnd_cfa_loc")))
  55     dw_cfi_cfa_loc;
  56 } dw_cfi_oprnd;
  57
  58 struct GTY(()) dw_cfi_node {
  59   enum dwarf_call_frame_info dw_cfi_opc;
  60   dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
  61     dw_cfi_oprnd1;
  62   dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
  63     dw_cfi_oprnd2;
  64 };
  65
  66
  67 typedef vec<dw_cfi_ref, va_gc> *cfi_vec;
  68
  69 typedef struct dw_fde_node *dw_fde_ref;
  70
  71 /* All call frame descriptions (FDE's) in the GCC generated DWARF
  72    refer to a single Common Information Entry (CIE), defined at
  73    the beginning of the .debug_frame section.  This use of a single
  74    CIE obviates the need to keep track of multiple CIE's
  75    in the DWARF generation routines below.  */
  76
  77 struct GTY(()) dw_fde_node {
  78   tree decl;
  79   const char *dw_fde_begin;
  80   const char *dw_fde_current_label;
  81   const char *dw_fde_end;
  82   const char *dw_fde_vms_end_prologue;
  83   const char *dw_fde_vms_begin_epilogue;
  84   const char *dw_fde_second_begin;
  85   const char *dw_fde_second_end;
  86   cfi_vec dw_fde_cfi;
  87   int dw_fde_switch_cfi_index; /* Last CFI before switching sections.  */
  88   HOST_WIDE_INT stack_realignment;
  89
  90   unsigned funcdef_number;
  91   unsigned fde_index;
  92
  93   /* Dynamic realign argument pointer register.  */
  94   unsigned int drap_reg;
  95   /* Virtual dynamic realign argument pointer register.  */
  96   unsigned int vdrap_reg;
  97   /* These 3 flags are copied from rtl_data in function.h.  */
  98   unsigned all_throwers_are_sibcalls : 1;
  99   unsigned uses_eh_lsda : 1;
 100   unsigned nothrow : 1;
 101   /* Whether we did stack realign in this call frame.  */
 102   unsigned stack_realign : 1;
 103   /* Whether dynamic realign argument pointer register has been saved.  */
 104   unsigned drap_reg_saved: 1;
 105   /* True iff dw_fde_begin label is in text_section or cold_text_section.  */
 106   unsigned in_std_section : 1;
 107   /* True iff dw_fde_second_begin label is in text_section or
 108      cold_text_section.  */
 109   unsigned second_in_std_section : 1;
 110   /* True if Rule 18 described in dwarf2cfi.cc is in action, i.e. for dynamic
 111      stack realignment in between pushing of hard frame pointer to stack
 112      and setting hard frame pointer to stack pointer.  The register save for
 113      hard frame pointer register should be emitted only on the latter
 114      instruction.  */
 115   unsigned rule18 : 1;
 116   /* True if this function is to be ignored by debugger.  */
 117   unsigned ignored_debug : 1;
 118 };
 119
 120
 121 /* This represents a register, in DWARF_FRAME_REGNUM space, for use in CFA
 122    definitions and expressions.
 123    Most architectures only need a single register number, but some (amdgcn)
 124    have pointers that span multiple registers.  DWARF permits arbitrary
 125    register sets but existing use-cases only require contiguous register
 126    sets, as represented here.  */
 127 struct GTY(()) cfa_reg {
 128   unsigned int reg;
 129   unsigned short span;
 130   unsigned short span_width;  /* A.K.A. register mode size.  */
 131
 132   cfa_reg& set_by_dwreg (unsigned int r)
 133     {
 134       reg = r;
 135       span = 1;
 136       span_width = 0;  /* Unknown size (permitted when span == 1).  */
 137       return *this;
 138     }
 139
 140   bool operator== (const cfa_reg &other) const
 141     {
 142       return (reg == other.reg && span == other.span
 143               && (span_width == other.span_width
 144                   || (span == 1
 145                       && (span_width == 0 || other.span_width == 0))));
 146     }
 147
 148   bool operator!= (const cfa_reg &other) const
 149     {
 150       return !(*this == other);
 151     }
 152 };
 153
 154 /* This is how we define the location of the CFA. We use to handle it
 155    as REG + OFFSET all the time,  but now it can be more complex.
 156    It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
 157    Instead of passing around REG and OFFSET, we pass a copy
 158    of this structure.  */
 159 struct GTY(()) dw_cfa_location {
 160   poly_int64 offset;
 161   poly_int64 base_offset;
 162   /* REG is in DWARF_FRAME_REGNUM space, *not* normal REGNO space.  */
 163   struct cfa_reg reg;
 164   BOOL_BITFIELD indirect : 1;  /* 1 if CFA is accessed via a dereference.  */
 165   BOOL_BITFIELD in_use : 1;    /* 1 if a saved cfa is stored here.  */
 166 };
 167
 168
 169 /* Each DIE may have a series of attribute/value pairs.  Values
 170    can take on several forms.  The forms that are used in this
 171    implementation are listed below.  */
 172
 173 enum dw_val_class
 174 {
 175   dw_val_class_none,
 176   dw_val_class_addr,
 177   dw_val_class_offset,
 178   dw_val_class_loc,
 179   dw_val_class_loc_list,
 180   dw_val_class_range_list,
 181   dw_val_class_const,
 182   dw_val_class_unsigned_const,
 183   dw_val_class_const_double,
 184   dw_val_class_wide_int,
 185   dw_val_class_vec,
 186   dw_val_class_flag,
 187   dw_val_class_die_ref,
 188   dw_val_class_fde_ref,
 189   dw_val_class_lbl_id,
 190   dw_val_class_lineptr,
 191   dw_val_class_str,
 192   dw_val_class_macptr,
 193   dw_val_class_loclistsptr,
 194   dw_val_class_file,
 195   dw_val_class_data8,
 196   dw_val_class_decl_ref,
 197   dw_val_class_vms_delta,
 198   dw_val_class_high_pc,
 199   dw_val_class_discr_value,
 200   dw_val_class_discr_list,
 201   dw_val_class_const_implicit,
 202   dw_val_class_unsigned_const_implicit,
 203   dw_val_class_file_implicit,
 204   dw_val_class_view_list,
 205   dw_val_class_symview
 206 };
 207
 208 /* Describe a floating point constant value, or a vector constant value.  */
 209
 210 struct GTY(()) dw_vec_const {
 211   void * GTY((atomic)) array;
 212   unsigned length;
 213   unsigned elt_size;
 214 };
 215
 216 /* Describe a single value that a discriminant can match.
 217
 218    Discriminants (in the "record variant part" meaning) are scalars.
 219    dw_discr_list_ref and dw_discr_value are a mean to describe a set of
 220    discriminant values that are matched by a particular variant.
 221
 222    Discriminants can be signed or unsigned scalars, and can be discriminants
 223    values.  Both have to be consistent, though.  */
 224
 225 struct GTY(()) dw_discr_value {
 226   int pos; /* Whether the discriminant value is positive (unsigned).  */
 227   union
 228     {
 229       HOST_WIDE_INT GTY ((tag ("0"))) sval;
 230       unsigned HOST_WIDE_INT GTY ((tag ("1"))) uval;
 231     }
 232   GTY ((desc ("%1.pos"))) v;
 233 };
 234
 235 struct addr_table_entry;
 236
 237 typedef unsigned int var_loc_view;
 238
 239 /* Location lists are ranges + location descriptions for that range,
 240    so you can track variables that are in different places over
 241    their entire life.  */
 242 typedef struct GTY(()) dw_loc_list_struct {
 243   dw_loc_list_ref dw_loc_next;
 244   const char *begin; /* Label and addr_entry for start of range */
 245   addr_table_entry *begin_entry;
 246   const char *end;  /* Label for end of range */
 247   addr_table_entry *end_entry;
 248   char *ll_symbol; /* Label for beginning of location list.
 249                       Only on head of list.  */
 250   char *vl_symbol; /* Label for beginning of view list.  Ditto.  */
 251   const char *section; /* Section this loclist is relative to */
 252   dw_loc_descr_ref expr;
 253   var_loc_view vbegin, vend;
 254   hashval_t hash;
 255   /* True if all addresses in this and subsequent lists are known to be
 256      resolved.  */
 257   bool resolved_addr;
 258   /* True if this list has been replaced by dw_loc_next.  */
 259   bool replaced;
 260   /* True if it has been emitted into .debug_loc* / .debug_loclists*
 261      section.  */
 262   unsigned char emitted : 1;
 263   /* True if hash field is index rather than hash value.  */
 264   unsigned char num_assigned : 1;
 265   /* True if .debug_loclists.dwo offset has been emitted for it already.  */
 266   unsigned char offset_emitted : 1;
 267   /* True if note_variable_value_in_expr has been called on it.  */
 268   unsigned char noted_variable_value : 1;
 269   /* True if the range should be emitted even if begin and end
 270      are the same.  */
 271   bool force;
 272 } dw_loc_list_node;
 273
 274 /* The dw_val_node describes an attribute's value, as it is
 275    represented internally.  */
 276
 277 struct GTY(()) dw_val_node {
 278   enum dw_val_class val_class;
 279   struct addr_table_entry * GTY(()) val_entry;
 280   union dw_val_struct_union
 281     {
 282       rtx GTY ((tag ("dw_val_class_addr"))) val_addr;
 283       unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset;
 284       dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
 285       dw_die_ref GTY ((tag ("dw_val_class_view_list"))) val_view_list;
 286       dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
 287       HOST_WIDE_INT GTY ((default)) val_int;
 288       unsigned HOST_WIDE_INT
 289         GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
 290       double_int GTY ((tag ("dw_val_class_const_double"))) val_double;
 291       dw_wide_int_ptr GTY ((tag ("dw_val_class_wide_int"))) val_wide;
 292       dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec;
 293       struct dw_val_die_union
 294         {
 295           dw_die_ref die;
 296           int external;
 297         } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref;
 298       unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index;
 299       struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str;
 300       char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id;
 301       unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag;
 302       struct dwarf_file_data * GTY ((tag ("dw_val_class_file"))) val_file;
 303       struct dwarf_file_data *
 304         GTY ((tag ("dw_val_class_file_implicit"))) val_file_implicit;
 305       unsigned char GTY ((tag ("dw_val_class_data8"))) val_data8[8];
 306       tree GTY ((tag ("dw_val_class_decl_ref"))) val_decl_ref;
 307       struct dw_val_vms_delta_union
 308         {
 309           char * lbl1;
 310           char * lbl2;
 311         } GTY ((tag ("dw_val_class_vms_delta"))) val_vms_delta;
 312       dw_discr_value GTY ((tag ("dw_val_class_discr_value"))) val_discr_value;
 313       dw_discr_list_ref GTY ((tag ("dw_val_class_discr_list"))) val_discr_list;
 314       char * GTY ((tag ("dw_val_class_symview"))) val_symbolic_view;
 315     }
 316   GTY ((desc ("%1.val_class"))) v;
 317 };
 318
 319 /* Locations in memory are described using a sequence of stack machine
 320    operations.  */
 321
 322 struct GTY((chain_next ("%h.dw_loc_next"))) dw_loc_descr_node {
 323   dw_loc_descr_ref dw_loc_next;
 324   ENUM_BITFIELD (dwarf_location_atom) dw_loc_opc : 8;
 325   /* Used to distinguish DW_OP_addr with a direct symbol relocation
 326      from DW_OP_addr with a dtp-relative symbol relocation.  */
 327   unsigned int dtprel : 1;
 328   /* For DW_OP_pick, DW_OP_dup and DW_OP_over operations: true iff.
 329      it targets a DWARF prodecure argument.  In this case, it needs to be
 330      relocated according to the current frame offset.  */
 331   unsigned int frame_offset_rel : 1;
 332   int dw_loc_addr;
 333   dw_val_node dw_loc_oprnd1;
 334   dw_val_node dw_loc_oprnd2;
 335 };
 336
 337 /* A variant (inside a record variant part) is selected when the corresponding
 338    discriminant matches its set of values (see the comment for dw_discr_value).
 339    The following datastructure holds such matching information.  */
 340
 341 struct GTY(()) dw_discr_list_node {
 342   dw_discr_list_ref dw_discr_next;
 343
 344   dw_discr_value dw_discr_lower_bound;
 345   dw_discr_value dw_discr_upper_bound;
 346   /* This node represents only the value in dw_discr_lower_bound when it's
 347      zero.  It represents the range between the two fields (bounds included)
 348      otherwise.  */
 349   int dw_discr_range;
 350 };
 351
 352 struct GTY((variable_size)) dw_wide_int {
 353   unsigned int precision;
 354   unsigned int len;
 355   HOST_WIDE_INT val[1];
 356
 357   unsigned int get_precision () const { return precision; }
 358   unsigned int get_len () const { return len; }
 359   const HOST_WIDE_INT *get_val () const { return val; }
 360   inline HOST_WIDE_INT elt (unsigned int) const;
 361   inline bool operator == (const dw_wide_int &) const;
 362 };
 363
 364 inline HOST_WIDE_INT
 365 dw_wide_int::elt (unsigned int i) const
 366 {
 367   if (i < len)
 368     return val[i];
 369   wide_int_ref ref = wi::storage_ref (val, len, precision);
 370   return wi::sign_mask (ref);
 371 }
 372
 373 inline bool
 374 dw_wide_int::operator == (const dw_wide_int &o) const
 375 {
 376   wide_int_ref ref1 = wi::storage_ref (val, len, precision);
 377   wide_int_ref ref2 = wi::storage_ref (o.val, o.len, o.precision);
 378   return ref1 == ref2;
 379 }
 380
 381 /* Interface from dwarf2out.cc to dwarf2cfi.cc.  */
 382 extern struct dw_loc_descr_node *build_cfa_loc
 383   (dw_cfa_location *, poly_int64);
 384 extern struct dw_loc_descr_node *build_cfa_aligned_loc
 385   (dw_cfa_location *, poly_int64, HOST_WIDE_INT);
 386 extern struct dw_loc_descr_node *build_span_loc (struct cfa_reg);
 387 extern struct dw_loc_descr_node *mem_loc_descriptor
 388   (rtx, machine_mode mode, machine_mode mem_mode,
 389    enum var_init_status);
 390 extern bool loc_descr_equal_p (dw_loc_descr_ref, dw_loc_descr_ref);
 391 extern dw_fde_ref dwarf2out_alloc_current_fde (void);
 392
 393 extern unsigned long size_of_locs (dw_loc_descr_ref);
 394 extern void output_loc_sequence (dw_loc_descr_ref, int);
 395 extern void output_loc_sequence_raw (dw_loc_descr_ref);
 396
 397 /* Interface from dwarf2cfi.cc to dwarf2out.cc.  */
 398 extern void lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc,
 399                           dw_cfa_location *remember);
 400 extern bool cfa_equal_p (const dw_cfa_location *, const dw_cfa_location *);
 401
 402 extern void output_cfi (dw_cfi_ref, dw_fde_ref, int);
 403
 404 extern GTY(()) cfi_vec cie_cfi_vec;
 405
 406 /* Interface from dwarf2*.c to the rest of the compiler.  */
 407 extern enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc (dwarf_call_frame_info cfi);
 408 extern enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc (dwarf_call_frame_info cfi);
 409
 410 extern void output_cfi_directive (FILE *f, dw_cfi_ref cfi);
 411
 412 extern void dwarf2out_emit_cfi (dw_cfi_ref cfi);
 413
 414 extern void debug_dwarf (void);
 415 struct die_struct;
 416 extern void debug_dwarf_die (struct die_struct *);
 417 extern void debug_dwarf_loc_descr (dw_loc_descr_ref);
 418 extern void debug (die_struct &ref);
 419 extern void debug (die_struct *ptr);
 420 extern void dwarf2out_set_demangle_name_func (const char *(*) (const char *));
 421 #ifdef VMS_DEBUGGING_INFO
 422 extern void dwarf2out_vms_debug_main_pointer (void);
 423 #endif
 424
 425 enum array_descr_ordering
 426 {
 427   array_descr_ordering_default,
 428   array_descr_ordering_row_major,
 429   array_descr_ordering_column_major
 430 };
 431
 432 #define DWARF2OUT_ARRAY_DESCR_INFO_MAX_DIMEN 16
 433
 434 struct array_descr_info
 435 {
 436   int ndimensions;
 437   enum array_descr_ordering ordering;
 438   tree element_type;
 439   tree base_decl;
 440   tree data_location;
 441   tree allocated;
 442   tree associated;
 443   tree stride;
 444   tree rank;
 445   bool stride_in_bits;
 446   struct array_descr_dimen
 447     {
 448       /* GCC uses sizetype for array indices, so lower_bound and upper_bound
 449          will likely be "sizetype" values. However, bounds may have another
 450          type in the original source code.  */
 451       tree bounds_type;
 452       tree lower_bound;
 453       tree upper_bound;
 454
 455       /* Only Fortran uses more than one dimension for array types.  For other
 456          languages, the stride can be rather specified for the whole array.  */
 457       tree stride;
 458     } dimen[DWARF2OUT_ARRAY_DESCR_INFO_MAX_DIMEN];
 459 };
 460
 461 enum fixed_point_scale_factor
 462 {
 463   fixed_point_scale_factor_binary,
 464   fixed_point_scale_factor_decimal,
 465   fixed_point_scale_factor_arbitrary
 466 };
 467
 468 struct fixed_point_type_info
 469 {
 470   /* The scale factor is the value one has to multiply the actual data with
 471      to get the fixed point value.  We support three ways to encode it.  */
 472   enum fixed_point_scale_factor scale_factor_kind;
 473   union
 474     {
 475       /* For a binary scale factor, the scale factor is 2 ** binary.  */
 476       int binary;
 477       /* For a decimal scale factor, the scale factor is 10 ** decimal.  */
 478       int decimal;
 479       /* For an arbitrary scale factor, the scale factor is the ratio
 480          numerator / denominator.  */
 481       struct { tree numerator; tree denominator; } arbitrary;
 482     } scale_factor;
 483 };
 484
 485 void dwarf2cfi_cc_finalize (void);
 486 void dwarf2out_cc_finalize (void);
 487
 488 /* Some DWARF internals are exposed for the needs of DWARF-based debug
 489    formats.  */
 490
 491 /* Each DIE attribute has a field specifying the attribute kind,
 492    a link to the next attribute in the chain, and an attribute value.
 493    Attributes are typically linked below the DIE they modify.  */
 494
 495 typedef struct GTY(()) dw_attr_struct {
 496   enum dwarf_attribute dw_attr;
 497   dw_val_node dw_attr_val;
 498 }
 499 dw_attr_node;
 500
 501 extern dw_attr_node *get_AT (dw_die_ref, enum dwarf_attribute);
 502 extern HOST_WIDE_INT AT_int (dw_attr_node *);
 503 extern unsigned HOST_WIDE_INT AT_unsigned (dw_attr_node *a);
 504 extern dw_loc_descr_ref AT_loc (dw_attr_node *);
 505 extern dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
 506 extern const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
 507 extern enum dw_val_class AT_class (dw_attr_node *);
 508 extern unsigned HOST_WIDE_INT AT_unsigned (dw_attr_node *);
 509 extern unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
 510 extern int get_AT_flag (dw_die_ref, enum dwarf_attribute);
 511
 512 extern void add_name_attribute (dw_die_ref, const char *);
 513
 514 extern dw_die_ref new_die_raw (enum dwarf_tag);
 515 extern dw_die_ref base_type_die (tree, bool);
 516
 517 extern dw_die_ref lookup_decl_die (tree);
 518 extern dw_die_ref lookup_type_die (tree);
 519
 520 extern dw_die_ref dw_get_die_child (dw_die_ref);
 521 extern dw_die_ref dw_get_die_sib (dw_die_ref);
 522 extern dw_die_ref dw_get_die_parent (dw_die_ref);
 523 extern enum dwarf_tag dw_get_die_tag (dw_die_ref);
 524
 525 /* Data about a single source file.  */
 526 struct GTY((for_user)) dwarf_file_data {
 527   const char * key;
 528   const char * filename;
 529   int emitted_number;
 530 };
 531
 532 extern struct dwarf_file_data *get_AT_file (dw_die_ref,
 533                                             enum dwarf_attribute);
 534
 535 #endif /* GCC_DWARF2OUT_H */