gcc/dwarf2out.h

   1 /* dwarf2out.h - Various declarations for functions found in dwarf2out.c
   2    Copyright (C) 1998-2018 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 };
 112
 113
 114 /* This is how we define the location of the CFA. We use to handle it
 115    as REG + OFFSET all the time,  but now it can be more complex.
 116    It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
 117    Instead of passing around REG and OFFSET, we pass a copy
 118    of this structure.  */
 119 struct GTY(()) dw_cfa_location {
 120   poly_int64_pod offset;
 121   poly_int64_pod base_offset;
 122   /* REG is in DWARF_FRAME_REGNUM space, *not* normal REGNO space.  */
 123   unsigned int reg;
 124   BOOL_BITFIELD indirect : 1;  /* 1 if CFA is accessed via a dereference.  */
 125   BOOL_BITFIELD in_use : 1;    /* 1 if a saved cfa is stored here.  */
 126 };
 127
 128
 129 /* Each DIE may have a series of attribute/value pairs.  Values
 130    can take on several forms.  The forms that are used in this
 131    implementation are listed below.  */
 132
 133 enum dw_val_class
 134 {
 135   dw_val_class_none,
 136   dw_val_class_addr,
 137   dw_val_class_offset,
 138   dw_val_class_loc,
 139   dw_val_class_loc_list,
 140   dw_val_class_range_list,
 141   dw_val_class_const,
 142   dw_val_class_unsigned_const,
 143   dw_val_class_const_double,
 144   dw_val_class_wide_int,
 145   dw_val_class_vec,
 146   dw_val_class_flag,
 147   dw_val_class_die_ref,
 148   dw_val_class_fde_ref,
 149   dw_val_class_lbl_id,
 150   dw_val_class_lineptr,
 151   dw_val_class_str,
 152   dw_val_class_macptr,
 153   dw_val_class_loclistsptr,
 154   dw_val_class_file,
 155   dw_val_class_data8,
 156   dw_val_class_decl_ref,
 157   dw_val_class_vms_delta,
 158   dw_val_class_high_pc,
 159   dw_val_class_discr_value,
 160   dw_val_class_discr_list,
 161   dw_val_class_const_implicit,
 162   dw_val_class_unsigned_const_implicit,
 163   dw_val_class_file_implicit,
 164   dw_val_class_view_list
 165 };
 166
 167 /* Describe a floating point constant value, or a vector constant value.  */
 168
 169 struct GTY(()) dw_vec_const {
 170   void * GTY((atomic)) array;
 171   unsigned length;
 172   unsigned elt_size;
 173 };
 174
 175 /* Describe a single value that a discriminant can match.
 176
 177    Discriminants (in the "record variant part" meaning) are scalars.
 178    dw_discr_list_ref and dw_discr_value are a mean to describe a set of
 179    discriminant values that are matched by a particular variant.
 180
 181    Discriminants can be signed or unsigned scalars, and can be discriminants
 182    values.  Both have to be consistent, though.  */
 183
 184 struct GTY(()) dw_discr_value {
 185   int pos; /* Whether the discriminant value is positive (unsigned).  */
 186   union
 187     {
 188       HOST_WIDE_INT GTY ((tag ("0"))) sval;
 189       unsigned HOST_WIDE_INT GTY ((tag ("1"))) uval;
 190     }
 191   GTY ((desc ("%1.pos"))) v;
 192 };
 193
 194 struct addr_table_entry;
 195
 196 /* The dw_val_node describes an attribute's value, as it is
 197    represented internally.  */
 198
 199 struct GTY(()) dw_val_node {
 200   enum dw_val_class val_class;
 201   struct addr_table_entry * GTY(()) val_entry;
 202   union dw_val_struct_union
 203     {
 204       rtx GTY ((tag ("dw_val_class_addr"))) val_addr;
 205       unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset;
 206       dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
 207       dw_die_ref GTY ((tag ("dw_val_class_view_list"))) val_view_list;
 208       dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
 209       HOST_WIDE_INT GTY ((default)) val_int;
 210       unsigned HOST_WIDE_INT
 211         GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
 212       double_int GTY ((tag ("dw_val_class_const_double"))) val_double;
 213       wide_int_ptr GTY ((tag ("dw_val_class_wide_int"))) val_wide;
 214       dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec;
 215       struct dw_val_die_union
 216         {
 217           dw_die_ref die;
 218           int external;
 219         } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref;
 220       unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index;
 221       struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str;
 222       char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id;
 223       unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag;
 224       struct dwarf_file_data * GTY ((tag ("dw_val_class_file"))) val_file;
 225       struct dwarf_file_data *
 226         GTY ((tag ("dw_val_class_file_implicit"))) val_file_implicit;
 227       unsigned char GTY ((tag ("dw_val_class_data8"))) val_data8[8];
 228       tree GTY ((tag ("dw_val_class_decl_ref"))) val_decl_ref;
 229       struct dw_val_vms_delta_union
 230         {
 231           char * lbl1;
 232           char * lbl2;
 233         } GTY ((tag ("dw_val_class_vms_delta"))) val_vms_delta;
 234       dw_discr_value GTY ((tag ("dw_val_class_discr_value"))) val_discr_value;
 235       dw_discr_list_ref GTY ((tag ("dw_val_class_discr_list"))) val_discr_list;
 236     }
 237   GTY ((desc ("%1.val_class"))) v;
 238 };
 239
 240 /* Locations in memory are described using a sequence of stack machine
 241    operations.  */
 242
 243 struct GTY((chain_next ("%h.dw_loc_next"))) dw_loc_descr_node {
 244   dw_loc_descr_ref dw_loc_next;
 245   ENUM_BITFIELD (dwarf_location_atom) dw_loc_opc : 8;
 246   /* Used to distinguish DW_OP_addr with a direct symbol relocation
 247      from DW_OP_addr with a dtp-relative symbol relocation.  */
 248   unsigned int dtprel : 1;
 249   /* For DW_OP_pick, DW_OP_dup and DW_OP_over operations: true iff.
 250      it targets a DWARF prodecure argument.  In this case, it needs to be
 251      relocated according to the current frame offset.  */
 252   unsigned int frame_offset_rel : 1;
 253   int dw_loc_addr;
 254   dw_val_node dw_loc_oprnd1;
 255   dw_val_node dw_loc_oprnd2;
 256 };
 257
 258 /* A variant (inside a record variant part) is selected when the corresponding
 259    discriminant matches its set of values (see the comment for dw_discr_value).
 260    The following datastructure holds such matching information.  */
 261
 262 struct GTY(()) dw_discr_list_node {
 263   dw_discr_list_ref dw_discr_next;
 264
 265   dw_discr_value dw_discr_lower_bound;
 266   dw_discr_value dw_discr_upper_bound;
 267   /* This node represents only the value in dw_discr_lower_bound when it's
 268      zero.  It represents the range between the two fields (bounds included)
 269      otherwise.  */
 270   int dw_discr_range;
 271 };
 272
 273 /* Interface from dwarf2out.c to dwarf2cfi.c.  */
 274 extern struct dw_loc_descr_node *build_cfa_loc
 275   (dw_cfa_location *, poly_int64);
 276 extern struct dw_loc_descr_node *build_cfa_aligned_loc
 277   (dw_cfa_location *, poly_int64, HOST_WIDE_INT);
 278 extern struct dw_loc_descr_node *mem_loc_descriptor
 279   (rtx, machine_mode mode, machine_mode mem_mode,
 280    enum var_init_status);
 281 extern bool loc_descr_equal_p (dw_loc_descr_ref, dw_loc_descr_ref);
 282 extern dw_fde_ref dwarf2out_alloc_current_fde (void);
 283
 284 extern unsigned long size_of_locs (dw_loc_descr_ref);
 285 extern void output_loc_sequence (dw_loc_descr_ref, int);
 286 extern void output_loc_sequence_raw (dw_loc_descr_ref);
 287
 288 /* Interface from dwarf2cfi.c to dwarf2out.c.  */
 289 extern void lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc,
 290                           dw_cfa_location *remember);
 291 extern bool cfa_equal_p (const dw_cfa_location *, const dw_cfa_location *);
 292
 293 extern void output_cfi (dw_cfi_ref, dw_fde_ref, int);
 294
 295 extern GTY(()) cfi_vec cie_cfi_vec;
 296
 297 /* Interface from dwarf2*.c to the rest of the compiler.  */
 298 extern enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
 299   (enum dwarf_call_frame_info cfi);
 300 extern enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
 301   (enum dwarf_call_frame_info cfi);
 302
 303 extern void output_cfi_directive (FILE *f, struct dw_cfi_node *cfi);
 304
 305 extern void dwarf2out_emit_cfi (dw_cfi_ref cfi);
 306
 307 extern void debug_dwarf (void);
 308 struct die_struct;
 309 extern void debug_dwarf_die (struct die_struct *);
 310 extern void debug_dwarf_loc_descr (dw_loc_descr_ref);
 311 extern void debug (die_struct &ref);
 312 extern void debug (die_struct *ptr);
 313 extern void dwarf2out_set_demangle_name_func (const char *(*) (const char *));
 314 #ifdef VMS_DEBUGGING_INFO
 315 extern void dwarf2out_vms_debug_main_pointer (void);
 316 #endif
 317
 318 enum array_descr_ordering
 319 {
 320   array_descr_ordering_default,
 321   array_descr_ordering_row_major,
 322   array_descr_ordering_column_major
 323 };
 324
 325 #define DWARF2OUT_ARRAY_DESCR_INFO_MAX_DIMEN 16
 326
 327 struct array_descr_info
 328 {
 329   int ndimensions;
 330   enum array_descr_ordering ordering;
 331   tree element_type;
 332   tree base_decl;
 333   tree data_location;
 334   tree allocated;
 335   tree associated;
 336   tree stride;
 337   tree rank;
 338   bool stride_in_bits;
 339   struct array_descr_dimen
 340     {
 341       /* GCC uses sizetype for array indices, so lower_bound and upper_bound
 342          will likely be "sizetype" values. However, bounds may have another
 343          type in the original source code.  */
 344       tree bounds_type;
 345       tree lower_bound;
 346       tree upper_bound;
 347
 348       /* Only Fortran uses more than one dimension for array types.  For other
 349          languages, the stride can be rather specified for the whole array.  */
 350       tree stride;
 351     } dimen[DWARF2OUT_ARRAY_DESCR_INFO_MAX_DIMEN];
 352 };
 353
 354 enum fixed_point_scale_factor
 355 {
 356   fixed_point_scale_factor_binary,
 357   fixed_point_scale_factor_decimal,
 358   fixed_point_scale_factor_arbitrary
 359 };
 360
 361 struct fixed_point_type_info
 362 {
 363   /* A scale factor is the value one has to multiply with physical data in
 364      order to get the fixed point logical data.  The DWARF standard enables one
 365      to encode it in three ways.  */
 366   enum fixed_point_scale_factor scale_factor_kind;
 367   union
 368     {
 369       /* For binary scale factor, the scale factor is: 2 ** binary.  */
 370       int binary;
 371       /* For decimal scale factor, the scale factor is: 10 ** binary.  */
 372       int decimal;
 373       /* For arbitrary scale factor, the scale factor is:
 374          numerator / denominator.  */
 375       struct
 376         {
 377           unsigned HOST_WIDE_INT numerator;
 378           HOST_WIDE_INT denominator;
 379         } arbitrary;
 380     } scale_factor;
 381 };
 382
 383 void dwarf2out_c_finalize (void);
 384
 385 #endif /* GCC_DWARF2OUT_H */