reader.comp_unit_die,
pretend_language);
- this_cu->lang = reader.cu->language;
-
/* Age out any secondary CUs. */
per_objfile->age_comp_units ();
}
case DW_TAG_subprogram:
case DW_TAG_inlined_subroutine:
add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu);
- if (cu->language == language_cplus)
+ if (cu->per_cu->lang == language_cplus)
scan_partial_symbols (pdi->die_child, lowpc, highpc,
set_addrmap, cu);
break;
{
add_partial_symbol (pdi, cu);
}
- if ((cu->language == language_rust
- || cu->language == language_cplus) && pdi->has_children)
+ if ((cu->per_cu->lang == language_rust
+ || cu->per_cu->lang == language_cplus)
+ && pdi->has_children)
scan_partial_symbols (pdi->die_child, lowpc, highpc,
set_addrmap, cu);
break;
/* Go read the partial unit, if needed. */
if (per_cu->v.psymtab == NULL)
process_psymtab_comp_unit (per_cu, cu->per_objfile, true,
- cu->language);
+ cu->per_cu->lang);
cu->per_cu->imported_symtabs_push (per_cu);
}
/* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
DW_TAG_namespace DIEs with a name of "::" for the global namespace.
Work around this problem here. */
- if (cu->language == language_cplus
+ if (cu->per_cu->lang == language_cplus
&& parent->tag == DW_TAG_namespace
&& strcmp (parent->name (cu), "::") == 0
&& grandparent_scope == NULL)
|| parent->tag == DW_TAG_interface_type
|| parent->tag == DW_TAG_union_type
|| parent->tag == DW_TAG_enumeration_type
- || (cu->language == language_fortran
+ || (cu->per_cu->lang == language_fortran
&& parent->tag == DW_TAG_subprogram
&& pdi->tag == DW_TAG_subprogram))
{
partial_symbol psymbol;
memset (&psymbol, 0, sizeof (psymbol));
- psymbol.ginfo.set_language (cu->language, &objfile->objfile_obstack);
+ psymbol.ginfo.set_language (cu->per_cu->lang,
+ &objfile->objfile_obstack);
psymbol.ginfo.set_section_index (-1);
/* The code below indicates that the psymbol should be installed by
addr = (gdbarch_adjust_dwarf2_addr (gdbarch, pdi->lowpc + baseaddr)
- baseaddr);
if (pdi->is_external
- || cu->language == language_ada
- || (cu->language == language_fortran
+ || cu->per_cu->lang == language_ada
+ || (cu->per_cu->lang == language_fortran
&& pdi->die_parent != NULL
&& pdi->die_parent->tag == DW_TAG_subprogram))
{
psymbol.ginfo.value.address = addr;
if (pdi->main_subprogram && actual_name != NULL)
- set_objfile_main_name (objfile, actual_name, cu->language);
+ set_objfile_main_name (objfile, actual_name, cu->per_cu->lang);
break;
case DW_TAG_constant:
psymbol.domain = VAR_DOMAIN;
static vs. global. */
psymbol.domain = STRUCT_DOMAIN;
psymbol.aclass = LOC_TYPEDEF;
- where = (cu->language == language_cplus
+ where = (cu->per_cu->lang == language_cplus
? psymbol_placement::GLOBAL
: psymbol_placement::STATIC);
break;
case DW_TAG_enumerator:
psymbol.domain = VAR_DOMAIN;
psymbol.aclass = LOC_CONST;
- where = (cu->language == language_cplus
+ where = (cu->per_cu->lang == language_cplus
? psymbol_placement::GLOBAL
: psymbol_placement::STATIC);
break;
{
if (built_actual_name != nullptr)
actual_name = objfile->intern (actual_name);
- if (pdi->linkage_name == nullptr || cu->language == language_ada)
+ if (pdi->linkage_name == nullptr
+ || cu->per_cu->lang == language_ada)
psymbol.ginfo.set_linkage_name (actual_name);
else
{
if (! pdi->has_children)
return;
- if (cu->language == language_ada || cu->language == language_fortran)
+ if (cu->per_cu->lang == language_ada
+ || cu->per_cu->lang == language_fortran)
{
pdi = pdi->die_child;
while (pdi != NULL)
/* Only C++ delays computing physnames. */
if (cu->method_list.empty ())
return;
- gdb_assert (cu->language == language_cplus);
+ gdb_assert (cu->per_cu->lang == language_cplus);
for (const delayed_method_info &mi : cu->method_list)
{
static void
rust_union_quirks (struct dwarf2_cu *cu)
{
- gdb_assert (cu->language == language_rust);
+ gdb_assert (cu->per_cu->lang == language_rust);
for (type *type_ : cu->rust_unions)
quirk_rust_enum (type_, cu->per_objfile->objfile);
/* We don't need this any more. */
/* Clear the list here in case something was left over. */
cu->method_list.clear ();
- cu->language = pretend_language;
- cu->language_defn = language_def (cu->language);
-
dwarf2_find_base_address (cu->dies, cu);
/* Before we start reading the top-level DIE, ensure it has a valid tag
process_die (cu->dies, cu);
/* For now fudge the Go package. */
- if (cu->language == language_go)
+ if (cu->per_cu->lang == language_go)
fixup_go_packaging (cu);
/* Now that we have processed all the DIEs in the CU, all the types
physnames. */
compute_delayed_physnames (cu);
- if (cu->language == language_rust)
+ if (cu->per_cu->lang == language_rust)
rust_union_quirks (cu);
/* Some compilers don't define a DW_AT_high_pc attribute for the
/* Set symtab language to language from DW_AT_language. If the
compilation is from a C file generated by language preprocessors, do
not set the language if it was already deduced by start_subfile. */
- if (!(cu->language == language_c
+ if (!(cu->per_cu->lang == language_c
&& COMPUNIT_FILETABS (cust)->language != language_unknown))
- COMPUNIT_FILETABS (cust)->language = cu->language;
+ COMPUNIT_FILETABS (cust)->language = cu->per_cu->lang;
/* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
produce DW_AT_location with location lists but it can be possibly
/* Clear the list here in case something was left over. */
cu->method_list.clear ();
- cu->language = pretend_language;
- cu->language_defn = language_def (cu->language);
-
/* The symbol tables are set up in read_type_unit_scope. */
process_die (cu->dies, cu);
/* For now fudge the Go package. */
- if (cu->language == language_go)
+ if (cu->per_cu->lang == language_go)
fixup_go_packaging (cu);
/* Now that we have processed all the DIEs in the CU, all the types
physnames. */
compute_delayed_physnames (cu);
- if (cu->language == language_rust)
+ if (cu->per_cu->lang == language_rust)
rust_union_quirks (cu);
/* TUs share symbol tables.
compilation is from a C file generated by language preprocessors,
do not set the language if it was already deduced by
start_subfile. */
- if (!(cu->language == language_c
+ if (!(cu->per_cu->lang == language_c
&& COMPUNIT_FILETABS (cust)->language != language_c))
- COMPUNIT_FILETABS (cust)->language = cu->language;
+ COMPUNIT_FILETABS (cust)->language = cu->per_cu->lang;
}
}
else
return;
/* If necessary, add it to the queue and load its DIEs. */
- if (maybe_queue_comp_unit (cu, per_cu, per_objfile, cu->language))
+ if (maybe_queue_comp_unit (cu, per_cu, per_objfile,
+ cu->per_cu->lang))
load_full_comp_unit (per_cu, per_objfile, per_objfile->get_cu (per_cu),
- false, cu->language);
+ false, cu->per_cu->lang);
cu->per_cu->imported_symtabs_push (per_cu);
}
break;
case DW_TAG_subprogram:
/* Nested subprograms in Fortran get a prefix. */
- if (cu->language == language_fortran
+ if (cu->per_cu->lang == language_fortran
&& die->parent != NULL
&& die->parent->tag == DW_TAG_subprogram)
cu->processing_has_namespace_info = true;
/* We only need to handle this case for Ada -- in other
languages, it's normal for the compiler to emit a typedef
instead. */
- if (cu->language != language_ada)
+ if (cu->per_cu->lang != language_ada)
break;
/* FALLTHROUGH */
case DW_TAG_base_type:
case DW_TAG_imported_module:
cu->processing_has_namespace_info = true;
if (die->child != NULL && (die->tag == DW_TAG_imported_declaration
- || cu->language != language_fortran))
+ || cu->per_cu->lang != language_fortran))
complaint (_("Tag '%s' has unexpected children"),
dwarf_tag_name (die->tag));
read_import_statement (die, cu);
/* rustc emits invalid values for DW_AT_linkage_name. Ignore these.
See https://github.com/rust-lang/rust/issues/32925. */
- if (cu->language == language_rust && linkage_name != NULL
+ if (cu->per_cu->lang == language_rust && linkage_name != NULL
&& strchr (linkage_name, '{') != NULL)
linkage_name = NULL;
if (name == NULL)
name = dwarf2_name (die, cu);
+ enum language lang = cu->per_cu->lang;
+
/* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
but otherwise compute it by typename_concat inside GDB.
FIXME: Actually this is not really true, or at least not always true.
Fortran names because there is no mangling standard. So new_symbol
will set the demangled name to the result of dwarf2_full_name, and it is
the demangled name that GDB uses if it exists. */
- if (cu->language == language_ada
- || (cu->language == language_fortran && physname))
+ if (lang == language_ada
+ || (lang == language_fortran && physname))
{
/* For Ada unit, we prefer the linkage name over the name, as
the former contains the exported name, which the user expects
/* These are the only languages we know how to qualify names in. */
if (name != NULL
- && (cu->language == language_cplus
- || cu->language == language_fortran || cu->language == language_d
- || cu->language == language_rust))
+ && (lang == language_cplus
+ || lang == language_fortran || lang == language_d
+ || lang == language_rust))
{
if (die_needs_namespace (die, cu))
{
templates; two instantiated function templates are allowed to
differ only by their return types, which we do not add here. */
- if (cu->language == language_cplus && strchr (name, '<') == NULL)
+ if (lang == language_cplus && strchr (name, '<') == NULL)
{
struct attribute *attr;
struct die_info *child;
int first = 1;
- const language_defn *cplus_lang = language_def (cu->language);
die->building_fullname = 1;
if (child->tag == DW_TAG_template_type_param)
{
- cplus_lang->print_type (type, "", &buf, -1, 0,
- &type_print_raw_options);
+ cu->language_defn->print_type (type, "", &buf, -1, 0,
+ &type_print_raw_options);
continue;
}
if (type->has_no_signedness ())
/* GDB prints characters as NUMBER 'CHAR'. If that's
changed, this can use value_print instead. */
- cplus_lang->printchar (value, type, &buf);
+ cu->language_defn->printchar (value, type, &buf);
else
{
struct value_print_options opts;
information, if PHYSNAME. */
if (physname && die->tag == DW_TAG_subprogram
- && cu->language == language_cplus)
+ && lang == language_cplus)
{
struct type *type = read_type_die (die, cu);
- c_type_print_args (type, &buf, 1, cu->language,
+ c_type_print_args (type, &buf, 1, lang,
&type_print_raw_options);
- if (cu->language == language_cplus)
+ if (lang == language_cplus)
{
/* Assume that an artificial first parameter is
"this", but do not crash if it is not. RealView
const std::string &intermediate_name = buf.string ();
- if (cu->language == language_cplus)
+ if (lang == language_cplus)
canonical_name
= dwarf2_canonicalize_name (intermediate_name.c_str (), cu,
objfile);
if (!die_needs_namespace (die, cu))
return dwarf2_compute_name (name, die, cu, 1);
- if (cu->language != language_rust)
+ if (cu->per_cu->lang != language_rust)
mangled = dw2_linkage_name (die, cu);
/* DW_AT_linkage_name is missing in some cases - depend on what GDB
gdb::unique_xmalloc_ptr<char> demangled;
if (mangled != NULL)
{
-
- if (language_def (cu->language)->store_sym_names_in_linkage_form_p ())
+ if (cu->language_defn->store_sym_names_in_linkage_form_p ())
{
/* Do nothing (do not demangle the symbol name). */
}
static struct using_direct **
using_directives (struct dwarf2_cu *cu)
{
- if (cu->language == language_ada
+ if (cu->per_cu->lang == language_ada
&& cu->get_builder ()->outermost_context_p ())
return cu->get_builder ()->get_global_using_directives ();
else
else if (strlen (imported_name_prefix) > 0)
canonical_name = obconcat (&objfile->objfile_obstack,
imported_name_prefix,
- (cu->language == language_d ? "." : "::"),
+ (cu->per_cu->lang == language_d
+ ? "."
+ : "::"),
imported_name, (char *) NULL);
else
canonical_name = imported_name;
- if (die->tag == DW_TAG_imported_module && cu->language == language_fortran)
+ if (die->tag == DW_TAG_imported_module
+ && cu->per_cu->lang == language_fortran)
for (child_die = die->child; child_die && child_die->tag;
child_die = child_die->sibling)
{
struct die_info *child_die;
CORE_ADDR baseaddr;
- prepare_one_comp_unit (cu, die, cu->language);
+ prepare_one_comp_unit (cu, die, cu->per_cu->lang);
baseaddr = objfile->text_section_offset ();
get_scope_pc_bounds (die, &lowpc, &highpc, cu);
a real dependency of PER_CU on SIG_TYPE. That is detected later
while processing PER_CU. */
if (maybe_queue_comp_unit (NULL, sig_type, cu->per_objfile,
- cu->language))
+ cu->per_cu->lang))
load_full_type_unit (sig_type, cu->per_objfile);
cu->per_cu->imported_symtabs_push (sig_type);
}
if (dwarf2_flag_true_p (die, DW_AT_main_subprogram, cu))
set_objfile_main_name (objfile, newobj->name->linkage_name (),
- cu->language);
+ cu->per_cu->lang);
/* If there is a location expression for DW_AT_frame_base, record
it. */
/* If we have a DW_AT_specification, we might need to import using
directives from the context of the specification DIE. See the
comment in determine_prefix. */
- if (cu->language == language_cplus
+ if (cu->per_cu->lang == language_cplus
&& dwarf2_attr (die, DW_AT_specification, cu))
{
struct dwarf2_cu *spec_cu = cu;
cstk.static_link, lowpc, highpc);
/* For C++, set the block's scope. */
- if ((cu->language == language_cplus
- || cu->language == language_fortran
- || cu->language == language_d
- || cu->language == language_rust)
+ if ((cu->per_cu->lang == language_cplus
+ || cu->per_cu->lang == language_fortran
+ || cu->per_cu->lang == language_d
+ || cu->per_cu->lang == language_rust)
&& cu->processing_has_namespace_info)
block_set_scope (block, determine_prefix (die, cu),
&objfile->objfile_obstack);
{
struct rust_vtable_symbol *storage = NULL;
- if (cu->language == language_rust)
+ if (cu->per_cu->lang == language_rust)
{
struct type *containing_type = rust_containing_type (die, cu);
/* If the language does not allow nested subprograms (either inside
subprograms or lexical blocks), we're done. */
- if (cu->language != language_ada)
+ if (cu->per_cu->lang != language_ada)
return;
/* Check all the children of the given DIE. If it contains nested
type->set_fields
((struct field *) TYPE_ZALLOC (type, sizeof (struct field) * nfields));
- if (fip->non_public_fields && cu->language != language_ada)
+ if (fip->non_public_fields && cu->per_cu->lang != language_ada)
{
ALLOCATE_CPLUS_STRUCT_TYPE (type);
/* If the type has baseclasses, allocate and clear a bit vector for
TYPE_FIELD_VIRTUAL_BITS. */
- if (!fip->baseclasses.empty () && cu->language != language_ada)
+ if (!fip->baseclasses.empty () && cu->per_cu->lang != language_ada)
{
int num_bytes = B_BYTES (fip->baseclasses.size ());
unsigned char *pointer;
switch (field.accessibility)
{
case DW_ACCESS_private:
- if (cu->language != language_ada)
+ if (cu->per_cu->lang != language_ada)
SET_TYPE_FIELD_PRIVATE (type, i);
break;
case DW_ACCESS_protected:
- if (cu->language != language_ada)
+ if (cu->per_cu->lang != language_ada)
SET_TYPE_FIELD_PROTECTED (type, i);
break;
{
case DW_VIRTUALITY_virtual:
case DW_VIRTUALITY_pure_virtual:
- if (cu->language == language_ada)
+ if (cu->per_cu->lang == language_ada)
error (_("unexpected virtuality in component of Ada type"));
SET_TYPE_FIELD_VIRTUAL (type, i);
break;
const char *fieldname;
struct type *this_type;
- if (cu->language == language_ada)
+ if (cu->per_cu->lang == language_ada)
error (_("unexpected member function in Ada type"));
/* Get name of member function. */
fnp = &flp->fnfields.back ();
/* Delay processing of the physname until later. */
- if (cu->language == language_cplus)
+ if (cu->per_cu->lang == language_cplus)
add_to_method_list (type, i, flp->fnfields.size () - 1, fieldname,
die, cu);
else
dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
struct dwarf2_cu *cu)
{
- if (cu->language == language_ada)
+ if (cu->per_cu->lang == language_ada)
error (_("unexpected member functions in Ada type"));
ALLOCATE_CPLUS_STRUCT_TYPE (type);
quirk_ada_thick_pointer_struct (struct die_info *die, struct dwarf2_cu *cu,
struct type *type)
{
- gdb_assert (cu->language == language_ada);
+ gdb_assert (cu->per_cu->lang == language_ada);
/* Check for a structure with two children. */
if (type->code () != TYPE_CODE_STRUCT || type->num_fields () != 2)
name = dwarf2_name (die, cu);
if (name != NULL)
{
- if (cu->language == language_cplus
- || cu->language == language_d
- || cu->language == language_rust)
+ if (cu->per_cu->lang == language_cplus
+ || cu->per_cu->lang == language_d
+ || cu->per_cu->lang == language_rust)
{
const char *full_name = dwarf2_full_name (name, die, cu);
type->set_code (TYPE_CODE_STRUCT);
}
- if (cu->language == language_cplus && die->tag == DW_TAG_class_type)
+ if (cu->per_cu->lang == language_cplus && die->tag == DW_TAG_class_type)
type->set_is_declared_class (true);
/* Store the calling convention in the type if it's available in
/* Rust doesn't have member functions in the C++ sense.
However, it does emit ordinary functions as children
of a struct DIE. */
- if (cu->language == language_rust)
+ if (cu->per_cu->lang == language_rust)
read_func_scope (child_die, cu);
else
{
/* Copy fi.nested_types_list linked list elements content into the
allocated array TYPE_NESTED_TYPES_ARRAY (type). */
- if (!fi.nested_types_list.empty () && cu->language != language_ada)
+ if (!fi.nested_types_list.empty ()
+ && cu->per_cu->lang != language_ada)
{
int count = fi.nested_types_list.size ();
}
quirk_gcc_member_function_pointer (type, objfile);
- if (cu->language == language_rust && die->tag == DW_TAG_union_type)
+ if (cu->per_cu->lang == language_rust && die->tag == DW_TAG_union_type)
cu->rust_unions.push_back (type);
- else if (cu->language == language_ada)
+ else if (cu->per_cu->lang == language_ada)
quirk_ada_thick_pointer_struct (die, cu, type);
/* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
maybe_set_alignment (cu, die, type);
struct type *replacement_type = nullptr;
- if (cu->language == language_ada)
+ if (cu->per_cu->lang == language_ada)
{
replacement_type = quirk_ada_thick_pointer (die, cu, type);
if (replacement_type != nullptr)
FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
version checking. */
- if (cu->language == language_fortran
+ if (cu->per_cu->lang == language_fortran
&& cu->producer && strstr (cu->producer, "GNU F77"))
{
return DW_ORD_row_major;
languages that allow unprototyped functions (Eg: Objective C).
For all other languages, assume that functions are always
prototyped. */
- if (cu->language != language_c
- && cu->language != language_objc
- && cu->language != language_opencl)
+ if (cu->per_cu->lang != language_c
+ && cu->per_cu->lang != language_objc
+ && cu->per_cu->lang != language_opencl)
return 1;
/* RealView does not emit DW_AT_prototyped. We can not distinguish
/* RealView does not mark THIS as const, which the testsuite
expects. GCC marks THIS as const in method definitions,
but not in the class specifications (GCC PR 43053). */
- if (cu->language == language_cplus && !TYPE_CONST (arg_type)
+ if (cu->per_cu->lang == language_cplus
+ && !TYPE_CONST (arg_type)
&& TYPE_FIELD_ARTIFICIAL (ftype, iparams))
{
int is_this = 0;
/* Try to find a suitable floating point builtin type of size BITS.
We're going to use the name of this type as the name for the complex
target type that we are about to create. */
- switch (cu->language)
+ switch (cu->per_cu->lang)
{
case language_fortran:
switch (bits)
}
if ((encoding == DW_ATE_signed_fixed || encoding == DW_ATE_unsigned_fixed)
- && cu->language == language_ada
+ && cu->per_cu->lang == language_ada
&& has_zero_over_zero_small_attribute (die, cu))
{
/* brobecker/2018-02-24: This is a fixed point type for which
than an "else if". */
const char *gnat_encoding_suffix = nullptr;
if ((encoding == DW_ATE_signed || encoding == DW_ATE_unsigned)
- && cu->language == language_ada
+ && cu->per_cu->lang == language_ada
&& name != nullptr)
{
gnat_encoding_suffix = gnat_encoded_fixed_point_type_info (name);
type = dwarf2_init_integer_type (cu, objfile, bits, 0, name);
break;
case DW_ATE_unsigned:
- if (cu->language == language_fortran
+ if (cu->per_cu->lang == language_fortran
&& name
&& startswith (name, "character("))
type = init_character_type (objfile, bits, 1, name);
type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
break;
case DW_ATE_signed_char:
- if (cu->language == language_ada || cu->language == language_m2
- || cu->language == language_pascal
- || cu->language == language_fortran)
+ if (cu->per_cu->lang == language_ada
+ || cu->per_cu->lang == language_m2
+ || cu->per_cu->lang == language_pascal
+ || cu->per_cu->lang == language_fortran)
type = init_character_type (objfile, bits, 0, name);
else
type = dwarf2_init_integer_type (cu, objfile, bits, 0, name);
break;
case DW_ATE_unsigned_char:
- if (cu->language == language_ada || cu->language == language_m2
- || cu->language == language_pascal
- || cu->language == language_fortran
- || cu->language == language_rust)
+ if (cu->per_cu->lang == language_ada
+ || cu->per_cu->lang == language_m2
+ || cu->per_cu->lang == language_pascal
+ || cu->per_cu->lang == language_fortran
+ || cu->per_cu->lang == language_rust)
type = init_character_type (objfile, bits, 1, name);
else
type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
/* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
omitting DW_AT_lower_bound. */
- switch (cu->language)
+ switch (cu->per_cu->lang)
{
case language_c:
case language_cplus:
range_type->bounds ()->flag_upper_bound_is_count = 1;
/* Ada expects an empty array on no boundary attributes. */
- if (attr == NULL && cu->language != language_ada)
+ if (attr == NULL && cu->per_cu->lang != language_ada)
range_type->bounds ()->high.set_undefined ();
name = dwarf2_name (die, cu);
of the type is deferred to a different unit. When encountering
such a type, we treat it as a stub, and try to resolve it later on,
when needed. */
- if (cu->language == language_ada)
+ if (cu->per_cu->lang == language_ada)
type->set_is_stub (true);
return set_die_type (die, type, cu);
/* Check for template arguments. We never save these; if
they're seen, we just mark the parent, and go on our way. */
if (parent_die != NULL
- && cu->language == language_cplus
+ && cu->per_cu->lang == language_cplus
&& (abbrev->tag == DW_TAG_template_type_param
|| abbrev->tag == DW_TAG_template_value_param))
{
/* We only recurse into c++ subprograms looking for template arguments.
Skip their other children. */
if (!load_all
- && cu->language == language_cplus
+ && cu->per_cu->lang == language_cplus
&& parent_die != NULL
&& parent_die->tag == DW_TAG_subprogram
&& abbrev->tag != DW_TAG_inlined_subroutine)
later variables referencing them via DW_AT_specification (for
static members). */
if (!load_all
- && !is_type_tag_for_partial (abbrev->tag, cu->language)
+ && !is_type_tag_for_partial (abbrev->tag, cu->per_cu->lang)
&& abbrev->tag != DW_TAG_constant
&& abbrev->tag != DW_TAG_enumerator
&& abbrev->tag != DW_TAG_subprogram
|| last_die->tag == DW_TAG_namespace
|| last_die->tag == DW_TAG_module
|| last_die->tag == DW_TAG_enumeration_type
- || (cu->language == language_cplus
+ || (cu->per_cu->lang == language_cplus
&& last_die->tag == DW_TAG_subprogram
&& (last_die->raw_name == NULL
|| strchr (last_die->raw_name, '<') == NULL))
- || (cu->language != language_c
+ || (cu->per_cu->lang != language_c
&& (last_die->tag == DW_TAG_class_type
|| last_die->tag == DW_TAG_interface_type
|| last_die->tag == DW_TAG_structure_type
|| last_die->tag == DW_TAG_union_type))
- || ((cu->language == language_ada
- || cu->language == language_fortran)
+ || ((cu->per_cu->lang == language_ada
+ || cu->per_cu->lang == language_fortran)
&& (last_die->tag == DW_TAG_subprogram
|| last_die->tag == DW_TAG_lexical_block))))
{
information, we support this practice for backward
compatibility. */
if (attr.constant_value (0) == DW_CC_program
- && cu->language == language_fortran)
+ && cu->per_cu->lang == language_fortran)
main_subprogram = 1;
break;
case DW_AT_inline:
of the order in which the name and linkage name were emitted.
Really, though, this is just a workaround for the fact that gdb
doesn't store both the name and the linkage name. */
- if (cu->language == language_ada && linkage_name != nullptr)
+ if (cu->per_cu->lang == language_ada && linkage_name != nullptr)
raw_name = linkage_name;
if (high_pc_relative)
/* If there is no parent die to provide a namespace, and there are
children, see if we can determine the namespace from their linkage
name. */
- if (cu->language == language_cplus
+ if (cu->per_cu->lang == language_cplus
&& !cu->per_objfile->per_bfd->types.empty ()
&& die_parent == NULL
&& has_children
OBJSTAT (objfile, n_syms++);
/* Cache this symbol's name and the name's demangled form (if any). */
- sym->set_language (cu->language, &objfile->objfile_obstack);
+ sym->set_language (cu->per_cu->lang, &objfile->objfile_obstack);
/* Fortran does not have mangling standard and the mangling does differ
between gfortran, iFort etc. */
const char *physname
- = (cu->language == language_fortran
+ = (cu->per_cu->lang == language_fortran
? dwarf2_full_name (name, die, cu)
: dwarf2_physname (name, die, cu));
const char *linkagename = dw2_linkage_name (die, cu);
- if (linkagename == nullptr || cu->language == language_ada)
+ if (linkagename == nullptr || cu->per_cu->lang == language_ada)
sym->set_linkage_name (physname);
else
{
SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
attr2 = dwarf2_attr (die, DW_AT_external, cu);
if ((attr2 != nullptr && attr2->as_boolean ())
- || cu->language == language_ada
- || cu->language == language_fortran)
+ || cu->per_cu->lang == language_ada
+ || cu->per_cu->lang == language_fortran)
{
/* Subprograms marked external are stored as a global symbol.
Ada and Fortran subprograms, whether marked external or
/* Fortran explicitly imports any global symbols to the local
scope by DW_TAG_common_block. */
- if (cu->language == language_fortran && die->parent
+ if (cu->per_cu->lang == language_fortran && die->parent
&& die->parent->tag == DW_TAG_common_block)
attr2 = NULL;
/* Fortran explicitly imports any global symbols to the local
scope by DW_TAG_common_block. */
- if (cu->language == language_fortran && die->parent
+ if (cu->per_cu->lang == language_fortran && die->parent
&& die->parent->tag == DW_TAG_common_block)
{
/* SYMBOL_CLASS doesn't matter here because
buildsym_compunit *builder = cu->get_builder ();
list_to_add
= (cu->list_in_scope == builder->get_file_symbols ()
- && cu->language == language_cplus
+ && cu->per_cu->lang == language_cplus
? builder->get_global_symbols ()
: cu->list_in_scope);
/* The semantics of C++ state that "struct foo {
... }" also defines a typedef for "foo". */
- if (cu->language == language_cplus
- || cu->language == language_ada
- || cu->language == language_d
- || cu->language == language_rust)
+ if (cu->per_cu->lang == language_cplus
+ || cu->per_cu->lang == language_ada
+ || cu->per_cu->lang == language_d
+ || cu->per_cu->lang == language_rust)
{
/* The symbol's name is already allocated along
with this objfile, so we don't need to
list_to_add
= (cu->list_in_scope == cu->get_builder ()->get_file_symbols ()
- && cu->language == language_cplus
+ && cu->per_cu->lang == language_cplus
? cu->get_builder ()->get_global_symbols ()
: cu->list_in_scope);
}
/* For the benefit of old versions of GCC, check for anonymous
namespaces based on the demangled name. */
if (!cu->processing_has_namespace_info
- && cu->language == language_cplus)
+ && cu->per_cu->lang == language_cplus)
cp_scan_for_anonymous_namespaces (cu->get_builder (), sym, objfile);
}
return (sym);
{
/* Assume that the Ada compiler was GNAT, which always produces
the auxiliary information. */
- return (cu->language == language_ada);
+ return (cu->per_cu->lang == language_ada);
}
/* Return the auxiliary type of the die in question using its
struct type *parent_type;
const char *retval;
- if (cu->language != language_cplus
- && cu->language != language_fortran && cu->language != language_d
- && cu->language != language_rust)
+ if (cu->per_cu->lang != language_cplus
+ && cu->per_cu->lang != language_fortran
+ && cu->per_cu->lang != language_d
+ && cu->per_cu->lang != language_rust)
return "";
retval = anonymous_struct_prefix (die, cu);
/* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
DW_TAG_namespace DIEs with a name of "::" for the global namespace.
Work around this problem here. */
- if (cu->language == language_cplus
+ if (cu->per_cu->lang == language_cplus
&& strcmp (parent_type->name (), "::") == 0)
return "";
/* We give a name to even anonymous namespaces. */
case DW_TAG_compile_unit:
case DW_TAG_partial_unit:
/* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
- if (cu->language == language_cplus
+ if (cu->per_cu->lang == language_cplus
&& !per_objfile->per_bfd->types.empty ()
&& die->child != NULL
&& (die->tag == DW_TAG_class_type
case DW_TAG_subprogram:
/* Nested subroutines in Fortran get a prefix with the name
of the parent's subroutine. */
- if (cu->language == language_fortran)
+ if (cu->per_cu->lang == language_fortran)
{
if ((die->tag == DW_TAG_subprogram)
&& (dwarf2_name (parent, cu) != NULL))
if (suffix == NULL || suffix[0] == '\0'
|| prefix == NULL || prefix[0] == '\0')
sep = "";
- else if (cu->language == language_d)
+ else if (cu->per_cu->lang == language_d)
{
/* For D, the 'main' function could be defined in any module, but it
should never be prefixed. */
else
sep = ".";
}
- else if (cu->language == language_fortran && physname)
+ else if (cu->per_cu->lang == language_fortran && physname)
{
/* This is gfortran specific mangling. Normally DW_AT_linkage_name or
DW_AT_MIPS_linkage_name is preferred and used instead. */
dwarf2_canonicalize_name (const char *name, struct dwarf2_cu *cu,
struct objfile *objfile)
{
- if (name && cu->language == language_cplus)
+ if (name && cu->per_cu->lang == language_cplus)
{
gdb::unique_xmalloc_ptr<char> canon_name
= cp_canonicalize_string (name);
Even if maybe_queue_comp_unit doesn't require us to load the CU's DIEs,
it doesn't mean they are currently loaded. Since we require them
to be loaded, we must check for ourselves. */
- if (maybe_queue_comp_unit (cu, per_cu, per_objfile, cu->language)
+ if (maybe_queue_comp_unit (cu, per_cu, per_objfile, cu->per_cu->lang)
|| per_objfile->get_cu (per_cu) == nullptr)
load_full_comp_unit (per_cu, per_objfile, per_objfile->get_cu (per_cu),
- false, cu->language);
+ false, cu->per_cu->lang);
target_cu = per_objfile->get_cu (per_cu);
gdb_assert (target_cu != nullptr);
attribute is not standardised yet. As a workaround for the
language detection we fall back to the DW_AT_producer
string. */
- cu->language = language_opencl;
+ cu->per_cu->lang = language_opencl;
}
else if (cu->producer != nullptr
&& strstr (cu->producer, "GNU Go ") != NULL)
{
/* Similar hack for Go. */
- cu->language = language_go;
+ cu->per_cu->lang = language_go;
}
else if (attr != nullptr)
- cu->language = dwarf_lang_to_enum_language (attr->constant_value (0));
+ cu->per_cu->lang = dwarf_lang_to_enum_language (attr->constant_value (0));
else
- cu->language = pretend_language;
- cu->language_defn = language_def (cu->language);
+ cu->per_cu->lang = pretend_language;
+ cu->language_defn = language_def (cu->per_cu->lang);
}
/* See read.h. */
projects / thirdparty / binutils-gdb.git / commitdiff
