1 /* DWARF attributes 2 3 Copyright (C) 1994-2023 Free Software Foundation, Inc. 4 5 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology, 6 Inc. with support from Florida State University (under contract 7 with the Ada Joint Program Office), and Silicon Graphics, Inc. 8 Initial contribution by Brent Benson, Harris Computer Systems, Inc., 9 based on Fred Fish's (Cygnus Support) implementation of DWARF 1 10 support. 11 12 This file is part of GDB. 13 14 This program is free software; you can redistribute it and/or modify 15 it under the terms of the GNU General Public License as published by 16 the Free Software Foundation; either version 3 of the License, or 17 (at your option) any later version. 18 19 This program is distributed in the hope that it will be useful, 20 but WITHOUT ANY WARRANTY; without even the implied warranty of 21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 22 GNU General Public License for more details. 23 24 You should have received a copy of the GNU General Public License 25 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 26 27 #ifndef GDB_DWARF2_ATTRIBUTE_H 28 #define GDB_DWARF2_ATTRIBUTE_H 29 30 #include "dwarf2.h" 31 #include "gdbtypes.h" 32 #include "gdbsupport/gdb_optional.h" 33 34 /* Blocks are a bunch of untyped bytes. */ 35 struct dwarf_block 36 { 37 size_t size; 38 39 /* Valid only if SIZE is not zero. */ 40 const gdb_byte *data; 41 }; 42 43 /* Attributes have a name and a value. */ 44 struct attribute 45 { 46 /* Read the given attribute value as an address, taking the 47 attribute's form into account. */ 48 CORE_ADDR as_address () const; 49 50 /* If the attribute has a string form, return the string value; 51 otherwise return NULL. */ 52 const char *as_string () const; 53 54 /* Return the block value. The attribute must have block form. */ 55 dwarf_block *as_block () const 56 { 57 gdb_assert (form_is_block ()); 58 return u.blk; 59 } 60 61 /* Return the signature. The attribute must have signature 62 form. */ 63 ULONGEST as_signature () const 64 { 65 gdb_assert (form == DW_FORM_ref_sig8); 66 return u.signature; 67 } 68 69 /* Return the signed value. The attribute must have the appropriate 70 form. */ 71 LONGEST as_signed () const 72 { 73 gdb_assert (form_is_signed ()); 74 return u.snd; 75 } 76 77 /* Return the unsigned value, but only for attributes requiring 78 reprocessing. */ 79 ULONGEST as_unsigned_reprocess () const 80 { 81 gdb_assert (form_requires_reprocessing ()); 82 gdb_assert (requires_reprocessing); 83 return u.unsnd; 84 } 85 86 /* Return the unsigned value. Requires that the form be an unsigned 87 form, and that reprocessing not be needed. */ 88 ULONGEST as_unsigned () const 89 { 90 gdb_assert (form_is_unsigned ()); 91 gdb_assert (!requires_reprocessing); 92 return u.unsnd; 93 } 94 95 /* Return true if the value is nonnegative. Requires that that 96 reprocessing not be needed. */ 97 bool is_nonnegative () const 98 { 99 if (form_is_unsigned ()) 100 return true; 101 if (form_is_signed ()) 102 return as_signed () >= 0; 103 return false; 104 } 105 106 /* Return the nonnegative value. Requires that that reprocessing not be 107 needed. */ 108 ULONGEST as_nonnegative () const 109 { 110 if (form_is_unsigned ()) 111 return as_unsigned (); 112 if (form_is_signed ()) 113 return (ULONGEST)as_signed (); 114 gdb_assert (false); 115 } 116 117 /* Return non-zero if ATTR's value is a section offset --- classes 118 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise. 119 You may use the as_unsigned method to retrieve such offsets. 120 121 Section 7.5.4, "Attribute Encodings", explains that no attribute 122 may have a value that belongs to more than one of these classes; it 123 would be ambiguous if we did, because we use the same forms for all 124 of them. */ 125 126 bool form_is_section_offset () const; 127 128 /* Return non-zero if ATTR's value falls in the 'constant' class, or 129 zero otherwise. When this function returns true, you can apply 130 the constant_value method to it. 131 132 However, note that for some attributes you must check 133 attr_form_is_section_offset before using this test. DW_FORM_data4 134 and DW_FORM_data8 are members of both the constant class, and of 135 the classes that contain offsets into other debug sections 136 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says 137 that, if an attribute's can be either a constant or one of the 138 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be 139 taken as section offsets, not constants. 140 141 DW_FORM_data16 is not considered as constant_value cannot handle 142 that. */ 143 144 bool form_is_constant () const; 145 146 /* The address is always stored already as sect_offset; despite for 147 the forms besides DW_FORM_ref_addr it is stored as cu_offset in 148 the DWARF file. */ 149 150 bool form_is_ref () const 151 { 152 return (form == DW_FORM_ref_addr 153 || form == DW_FORM_ref1 154 || form == DW_FORM_ref2 155 || form == DW_FORM_ref4 156 || form == DW_FORM_ref8 157 || form == DW_FORM_ref_udata 158 || form == DW_FORM_GNU_ref_alt); 159 } 160 161 /* Check if the attribute's form is a DW_FORM_block* 162 if so return true else false. */ 163 164 bool form_is_block () const; 165 166 /* Check if the attribute's form is a string form. */ 167 bool form_is_string () const; 168 169 /* Check if the attribute's form is an unsigned integer form. */ 170 bool form_is_unsigned () const; 171 172 /* Check if the attribute's form is a signed integer form. */ 173 bool form_is_signed () const; 174 175 /* Check if the attribute's form is a form that requires 176 "reprocessing". */ 177 bool form_requires_reprocessing () const; 178 179 /* Return DIE offset of this attribute. Return 0 with complaint if 180 the attribute is not of the required kind. */ 181 182 sect_offset get_ref_die_offset () const 183 { 184 if (form_is_ref ()) 185 return (sect_offset) u.unsnd; 186 get_ref_die_offset_complaint (); 187 return {}; 188 } 189 190 /* Return the constant value held by this attribute. Return 191 DEFAULT_VALUE if the value held by the attribute is not 192 constant. */ 193 194 LONGEST constant_value (int default_value) const; 195 196 /* Return true if this attribute holds a canonical string. In some 197 cases, like C++ names, gdb will rewrite the name of a DIE to a 198 canonical form. This makes lookups robust when a name can be 199 spelled different ways (e.g., "signed" or "signed int"). This 200 flag indicates whether the value has been canonicalized. */ 201 bool canonical_string_p () const 202 { 203 gdb_assert (form_is_string ()); 204 return string_is_canonical; 205 } 206 207 /* Initialize this attribute to hold a non-canonical string 208 value. */ 209 void set_string_noncanonical (const char *str) 210 { 211 gdb_assert (form_is_string ()); 212 u.str = str; 213 string_is_canonical = 0; 214 requires_reprocessing = 0; 215 } 216 217 /* Set the canonical string value for this attribute. */ 218 void set_string_canonical (const char *str) 219 { 220 gdb_assert (form_is_string ()); 221 u.str = str; 222 string_is_canonical = 1; 223 } 224 225 /* Set the block value for this attribute. */ 226 void set_block (dwarf_block *blk) 227 { 228 gdb_assert (form_is_block ()); 229 u.blk = blk; 230 } 231 232 /* Set the signature value for this attribute. */ 233 void set_signature (ULONGEST signature) 234 { 235 gdb_assert (form == DW_FORM_ref_sig8); 236 u.signature = signature; 237 } 238 239 /* Set this attribute to a signed integer. */ 240 void set_signed (LONGEST snd) 241 { 242 gdb_assert (form == DW_FORM_sdata || form == DW_FORM_implicit_const); 243 u.snd = snd; 244 } 245 246 /* Set this attribute to an unsigned integer. */ 247 void set_unsigned (ULONGEST unsnd) 248 { 249 gdb_assert (form_is_unsigned ()); 250 u.unsnd = unsnd; 251 requires_reprocessing = 0; 252 } 253 254 /* Temporarily set this attribute to an unsigned integer. This is 255 used only for those forms that require reprocessing. */ 256 void set_unsigned_reprocess (ULONGEST unsnd) 257 { 258 gdb_assert (form_requires_reprocessing ()); 259 u.unsnd = unsnd; 260 requires_reprocessing = 1; 261 } 262 263 /* Set this attribute to an address. */ 264 void set_address (CORE_ADDR addr) 265 { 266 gdb_assert (form == DW_FORM_addr 267 || ((form == DW_FORM_addrx 268 || form == DW_FORM_GNU_addr_index) 269 && requires_reprocessing)); 270 u.addr = addr; 271 requires_reprocessing = 0; 272 } 273 274 /* True if this attribute requires reprocessing. */ 275 bool requires_reprocessing_p () const 276 { 277 return requires_reprocessing; 278 } 279 280 /* Return the value as one of the recognized enum 281 dwarf_defaulted_attribute constants according to DWARF5 spec, 282 Table 7.24. If the value is incorrect, or if this attribute has 283 the wrong form, then a complaint is issued and DW_DEFAULTED_no is 284 returned. */ 285 dwarf_defaulted_attribute defaulted () const; 286 287 /* Return the attribute's value as a dwarf_virtuality_attribute 288 constant according to DWARF spec. An unrecognized value will 289 issue a complaint and return DW_VIRTUALITY_none. */ 290 dwarf_virtuality_attribute as_virtuality () const; 291 292 /* Return the attribute's value as a boolean. An unrecognized form 293 will issue a complaint and return false. */ 294 bool as_boolean () const; 295 296 ENUM_BITFIELD(dwarf_attribute) name : 15; 297 298 /* A boolean that is used for forms that require reprocessing. A 299 form may require data not directly available in the attribute. 300 E.g., DW_FORM_strx requires the corresponding 301 DW_AT_str_offsets_base. In this case, the processing for the 302 attribute must be done in two passes. In the first past, this 303 flag is set and the value is an unsigned. In the second pass, 304 the unsigned value is turned into the correct value for the form, 305 and this flag is cleared. This flag is unused for other 306 forms. */ 307 unsigned int requires_reprocessing : 1; 308 309 ENUM_BITFIELD(dwarf_form) form : 15; 310 311 /* Has u.str already been updated by dwarf2_canonicalize_name? This 312 field should be in u.str but it is kept here for better struct 313 attribute alignment. */ 314 unsigned int string_is_canonical : 1; 315 316 union 317 { 318 const char *str; 319 struct dwarf_block *blk; 320 ULONGEST unsnd; 321 LONGEST snd; 322 CORE_ADDR addr; 323 ULONGEST signature; 324 } 325 u; 326 327 private: 328 329 /* Used by get_ref_die_offset to issue a complaint. */ 330 331 void get_ref_die_offset_complaint () const; 332 }; 333 334 #endif /* GDB_DWARF2_ATTRIBUTE_H */ 335