Lines Matching refs:name
126 /// the value is the corresponding qualified name of the DIE.
622 /// Compare a symbol name against another name, possibly demangling
627 /// @param name the second name to take in account.
630 /// result of the demangling with @p name.
632 /// @return true iff symbol_name equals name.
635 const string& name,
641 return m == name;
643 return symbol_name == name;
658 /// @param sym_name the symbol name to look for.
669 /// @param syms_found a vector of symbols found with the name @p
935 /// @param sym_name the name of the symbol to look for.
944 /// @param syms_found the vector of symbols found with the name @p
996 // symbols which name equal sym_name.
1071 /// @param symbol_name the name of the symbol to look for.
1076 /// name @p symbol_name.
1120 /// @param sym_name the name of the symbol to look up.
1128 /// @param sym_name_found the actual name of the symbol found.
1206 /// @param symbol_name the name of the symbol to look for.
1208 /// @param demangle if true, try to demangle the symbol name found in
1211 /// @param syms_found the list of symbols found, with the name @p
1227 /// @return true iff a symbol with the name @p symbol_name was found.
2244 cerr << "fixing up functions with linkage name but "
2581 interned_string name =
2587 istring_dwarf_offsets_map_type::iterator i = map.find(name);
2592 map[name] = offsets;
2676 interned_string name =
2681 istring_dwarf_offsets_map_type::iterator i = map.find(name);
2773 interned_string name =
2778 istring_dwarf_offsets_map_type::iterator i = map.find(name);
2783 map[name] = offsets;
2994 /// Get the qualified name of a given DIE.
2996 /// If the name of the DIE was already computed before just return
2997 /// that name from a cache. Otherwise, build the name, cache it and
3004 /// @return the interned string representing the qualified name of
3028 /// Get the qualified name of a given DIE.
3030 /// If the name of the DIE was already computed before just return
3031 /// that name from a cache. Otherwise, build the name, cache it and
3038 /// @return the interned string representing the qualified name of
3047 /// Get the qualified name of a given DIE which is considered to be
3051 /// computes the name of the function *type* that corresponds to the
3054 /// If the name of the DIE was already computed before just return
3055 /// that name from a cache. Otherwise, build the name, cache it and
3062 /// @return the interned string representing the qualified name of
3069 // The name of the translation unit die is "".
3115 /// will yield the cached name.
3152 /// will yield the cached name.
3829 /// which has a linkage name but no elf symbol yet.
3880 /// the fully qualified name of the class and the value is the
3891 /// the fully qualified name of the class and the value is the
3989 // Now, for each decl-only class that have the current name
4015 // declarations which name is i->first.
4139 /// the fully qualified name of the enum and the value is the
4150 /// the fully qualified name of the enum and the value is the
4225 // Now, for each decl-only enum that have the current name
4251 // declarations which name is i->first.
4404 /// Some functions described by DWARF may have their linkage name
4410 /// If the corpus contains a symbol with the same name as the
4411 /// linkage name of the function, then set up the link between the
4445 // (mangled) name has already been set a symbol, then do not
5292 /// representation for it, we need to get its fully qualified name.
5853 /// @param attr_name the attribute name. Must come from dwarf.h and
5877 /// @param attr_name the attribute name. Must come from dwarf.h and
5901 /// @param attr_name the DW_AT_* name of the attribute. Must come
5909 /// @return true if there was an attribute of the name @p attr_name
5935 /// @param attr_name the attribute name.
5939 /// @return true iff a signed constant attribute of the name @p
5967 /// @param attr_name the attribute name to consider.
6055 /// @param attr_name the DW_AT_* name of the attribute. Must come
6089 /// Get the mangled name from a given DIE.
6091 /// @param die the DIE to read the mangled name from.
6093 /// @return the mangled name if it's present in the DIE, or just an
6133 /// @param attr_name the DW_AT_* attribute name to read.
6164 /// @param attr_name the name of the address class attribute to read
6206 /// Return a copy of the name of a DIE.
6210 /// @return a copy of the name of the DIE.
6214 string name = die_string_attribute(die, DW_AT_name);
6215 return name;
6218 /// Return the location, the name and the mangled name of a given DIE.
6226 /// @param name the name output parameter to set.
6233 string& name,
6237 name = die_name(die);
6337 string name = die_name(die);
6338 is_public = !name.empty();
6376 string name = die_name(&parent_die);
6377 if (name.empty())
6808 string name = die_name(die);
6809 if (name == "void")
6854 string name = die_name(&underlying_type_die);
6856 return name.empty();
7406 /// @param attr_name the name of the attribute which value is the
7430 /// @param attr_name the name of the attribute to compare, on the two
7554 /// @param attr_name the name of the attribute to read the value for.
8818 /// Return the base of the internal name to represent an anonymous
8826 /// the base name. This function returns that base name, depending on
8833 /// name.
8852 /// Build a full internal anonymous type name.
8854 /// @param base_name this is the base name as returned by the function
8868 string name = base_name;
8873 name = o.str();
8875 return name;
8879 /// Build a full internal anonymous type name.
8888 /// @return the internal name of the anonymous type represented by @p
8894 string name = get_internal_anonymous_die_prefix_name(die);
8895 name = build_internal_anonymous_die_name(name, anonymous_type_index);
8896 return name;
8903 /// Compute the qualified name of a DIE that represents a type.
8906 /// function computes the name of the function *type*.
8915 /// @return a copy of the qualified name of the type.
8930 string name = die_name(die);
8950 if (parse_integral_type(name, int_type))
8953 repr = name;
8963 if (name.empty())
8966 // that case, their name must be built with the function
8969 name = get_internal_anonymous_die_prefix_name(die);
8971 ABG_ASSERT(!name.empty());
8972 repr = parent_name.empty() ? name : parent_name + separator + name;
9130 // This is a method, so print the class name.
9163 /// Compute the qualified name of a decl represented by a given DIE.
9174 /// @return a copy of the computed name.
9183 string name = die_name(die);
9200 repr = scope_name.empty() ? name : scope_name + separator + name;
9220 /// Compute the qualified name of the artifact represented by a given
9223 /// If the DIE represents a type, then the function computes the name
9225 /// function computes the name of the decl. Note that a DIE of tag
9235 /// @return a copy of the computed name.
9246 /// Test if the qualified name of a given type should be empty.
9248 /// The reason why the name of a DIE with a given tag would be empty
9250 /// that tag; or if the DIE's qualified name is built from names of
9259 /// @param qualified_name the qualified name of the DIE. This is set
9262 /// @return true if the qualified name of the DIE is empty.
9286 string name =
9288 if (name.empty())
9294 string name = die_qualified_type_name(rdr, die, where);
9295 if (name.empty())
9328 /// @param return_type_name out parameter. This contains the name of
9332 /// function, this contains the name of the enclosing class.
9462 // the linkage name of the function as a key for the map which
9475 // as well, we can use the linkage name of functions in C++ too, to
9531 // We are printing a non-static method name, skip the implicit "this"
9672 // For now, we consider that the pretty printed name of the
9673 // subrange type is its name. We might need something more
9884 /// Note that this function doesn't look at the name of the DIEs.
9957 /// linkage name, and thus are considered equal if they are C or C++,
9960 /// If the DIEs don't have a linkage name, the function compares their
9961 /// name. But in that case, the caller of the function must know that
9972 /// linkage name as the function represented by @p r.
10547 /// update their canonical type. That way, two types of the same name
10549 /// non-linear structural comparison of two types of the same name
10657 // types have the same name and are defined in the same TU.
10920 // same linkage name in a given binary. But here we are
11917 // name is '<artificial>'. As we want all different translation
11918 // units to have unique path names, let's suffix this path name
12006 // This is the data member with the same name in cl.
12012 // same name in cl already. Let's add it there then
12068 string name, linkage_name;
12070 die_loc_and_name(rdr, die, loc, name, linkage_name);
12072 result.reset(new namespace_decl(rdr.env(), name, loc));
12163 /// @param enum_name the name of the enum that this type is going to
12201 /// that the function knows how to name anonymous enums.
12222 string name, linkage_name;
12224 die_loc_and_name(rdr, die, loc, name, linkage_name);
12227 // If the enum is anonymous, let's give it a name.
12228 if (name.empty())
12230 name = get_internal_anonymous_die_prefix_name(die);
12231 ABG_ASSERT(!name.empty());
12236 name = build_internal_anonymous_die_name(name, s);
12242 // representation (name) and location can be later detected as being
12307 build_enum_underlying_type(rdr, name, size,
12311 result.reset(new enum_type_decl(name, loc, t, enms, linkage_name));
12426 // This is a virtual member function which has a linkage name
12482 /// Lookup a class or a typedef with a given qualified name in the
12487 /// @param type_name the qualified name of the type to look for.
12502 /// The type being looked for has the same name as a given DIE.
12506 /// @param die the DIE which has the same name as the type we are
12537 /// Lookup a class, typedef or enum type with a given qualified name
12542 /// @param type_name the qualified name of the type to look for.
12747 string name, linkage_name;
12749 die_loc_and_name(rdr, die, loc, name, linkage_name);
12752 if (name.empty())
12755 // give it a name.
12756 name = get_internal_anonymous_die_prefix_name(die);
12757 ABG_ASSERT(!name.empty());
12762 name = build_internal_anonymous_die_name(name, s);
12775 // TODO: if there is just one class for that name defined,
12777 result = lookup_class_type(name, *corp);
12800 // re-use anonymous classes as they have no name, by construction.
12801 // What we can do, rather, is to reuse the typedef that name them,
12827 result.reset(new class_decl(rdr.env(), name, size,
12972 /// use as a name for the hidden vtable pointer.
13153 string name, linkage_name;
13155 die_loc_and_name(rdr, die, loc, name, linkage_name);
13158 if (name.empty())
13161 // name.
13162 name = get_internal_anonymous_die_prefix_name(die);
13163 ABG_ASSERT(!name.empty());
13168 name = build_internal_anonymous_die_name(name, s);
13173 // representation (name) and location can be later detected as being
13183 result = lookup_union_type(name, *corp);
13195 // unions as they have no name, by construction. What we can do,
13196 // rather, is to reuse the typedef that name them, when they do have
13214 result.reset(new union_decl(rdr.env(), name, size, loc,
13267 // name. Anonymous member are handled a bit later below
13787 // several different function types have the same name (or
13802 // (type). If it is, we can deduce the name of its enclosing class
13870 string name, linkage_name;
13872 die_loc_and_name(rdr, &child, loc, name, linkage_name);
13873 if (!tools_utils::string_is_ascii_identifier(name))
13876 name.clear();
13888 (new function_decl::parameter(parm_type, name, loc,
13902 /*name=*/"",
13956 /// e.g, its name pretty printing methods.
13975 string name = die_name(die);
14055 name,
14227 string name, linkage_name;
14229 die_loc_and_name(rdr, die, loc, name, linkage_name);
14254 result.reset(new typedef_decl(name, utype, loc, linkage_name));
14276 /// Note that if a member variable declaration with the same name as
14277 /// the name of the DIE we are looking at exists, this function returns
14373 string name, linkage_name;
14375 die_loc_and_name(rdr, die, loc, name, linkage_name);
14378 result.reset(new var_decl(name, type, loc, linkage_name));
14383 // that missing property is the mangled name.
14388 // Check if a variable symbol with this name is exported by the elf
14409 // If the linkage name is not set or is wrong, set it to
14410 // the name of the underlying symbol.
14499 /// the same linkage name as the one on the DIE, this function returns
14543 string name = die_name(fn_die);
14545 bool is_dtor = !name.empty() && name[0]== '~';
14572 // If a member function with the same linkage name as the one
14623 string name = die_string_attribute(variable_die, DW_AT_name);
14626 linkage_name = name;
14627 string qualified_name = build_qualified_name(scope, name);
14838 /// Create a function symbol with a given name.
14840 /// @param sym_name the name of the symbol to create.
14905 // the mangled name that goes missing in the first declarations.
14908 // linkage name (of the current DIE) might be different from the
14909 // linkage name of 'fn'. In that case, update the linkage name
14936 // Set the symbol of the function. If the linkage name is not set
14937 // or is wrong, set it to the name of the underlying symbol.
14971 // linkage name *and* and has its underlying symbol correctly set.
15073 // ... has a linkage name ...
15572 // and has a linkage name that is different
15573 // from from the linkage name of 'd'. That
15944 /// @param symbol_name the name of the symbol to look for.
15946 /// @param demangle if true, try to demangle the symbol name found in
15949 /// @param syms the vector of symbols found with the name @p symbol_name.
15985 /// function of a given name is found.
15991 /// @param symbol_name the name of the function to look for.
15994 /// name @p symname.
15996 /// @return true iff a function with symbol name @p symbol_name is