Lines Matching refs:result
492 die_address_attribute(Dwarf_Die* die, unsigned attr_name, Dwarf_Addr& result);
508 Dwarf_Die& result,
630 /// result of the demangling with @p name.
766 char result = 0;
775 result = 4;
778 result = 8;
784 return result;
802 /// most significant bytes of the result are going to be zero.
808 Elf64_Xword result = 0;
817 result = bloom_filter[index];
822 result = f[index];
829 return result;
1317 /// An abstraction of a value representing the result of the
1615 // Is set to true if the result of the expression that got evaluated
1635 /// Set a flag to to tell that the result of the expression that got
1638 /// @param f true iff the result of the expression that got
1644 /// Getter for the flag that tells if the result of the expression
1647 /// @return true iff the result of the expression that got evaluated
1705 ContainerType *result = 0;
1709 result = &primary_debug_info_container_;
1712 result = &alt_debug_info_container_;
1715 result = &type_unit_container_;
1721 return *result;
1820 /// A map that associates a pair of DIE offsets to the result of the
2021 reader_sptr result(new reader(elf_path, debug_info_root_paths,
2024 return result;
2410 const Dwarf *result = 0;
2415 result = dwarf_debug_info();
2418 result = alternate_dwarf_debug_info();
2424 return result;
2987 decl_base_sptr result =
2991 return result;
3719 type_base_sptr result;
3727 result = is_type(i->second);
3730 if (!result)
3737 result = i->second;
3740 if (!result)
3748 result = i->second;
3751 return result;
4830 bool result = false, address_found = false, symbol_is_exported = false;;
4847 result = symbol_is_exported;
4849 return result;
5512 bool result = false;
5514 return result;
5523 return result;
5530 result = true;
5533 return result;
5696 // Update the cached result. We know the comparison result
5720 /// @param result this is set to the pairs that depend on @p, iff
5724 /// of the @result is set to it.
5726 /// @return true iff @result could be filled with the dependant
5730 offset_pair_set_type& result,
5737 if (result.find(dependant_type) == result.end())
5739 result.insert(dependant_type);
5741 get_dependant_types(p, result, /*transitive_closure=*/true);
5813 var_decl_sptr result = var_decl_sptr());
5920 Dwarf_Word result = 0;
5922 || dwarf_formudata(&attr, &result))
5925 cst = result;
5950 Dwarf_Sword result = 0;
5952 || dwarf_formsdata(&attr, &result))
5955 cst = result;
6135 /// @param result the DIE resulting from reading the attribute value.
6148 Dwarf_Die& result,
6157 return dwarf_formref_die(&attr, &result);
6170 /// address class and could thus be translated into the @p result.
6172 die_address_attribute(Dwarf_Die* die, unsigned attr_name, Dwarf_Addr& result)
6177 return dwarf_formaddr(&attr, &result) == 0;
6290 access_specifier result = private_access;
6295 result = private_access;
6299 result = protected_access;
6303 result = public_access;
6310 access = result;
6498 bool result = false;
6529 result = true;
6533 result = false;
6537 return result;
6553 bool result = false;
6562 result = true;
6566 result = false;
6570 return result;
6573 /// Test if a given kind of DIE ought to have its comparison result
6602 /// Cache the result of comparing to type DIEs.
6610 /// @param result the comparison result to be cached.
6615 comparison_result result)
6618 || (result != COMPARISON_RESULT_EQUAL
6619 && result != COMPARISON_RESULT_DIFFERENT))
6622 rdr.die_comparison_results_[p] = result;
6628 /// Get the cached result of the comparison of a pair of DIEs.
6636 /// @param result out parameter set to the cached result of the
6639 /// @return true iff a cached result for the comparisonof @p has been
6640 /// found and set into @p result.
6644 comparison_result& result)
6649 result = i->second;
6655 /// Get the cached result of the comparison of a pair of DIEs, if the
6664 /// @param result out parameter set to the cached result of the
6667 /// @return true iff a cached result for the comparisonof @p has been
6668 /// found and set into @p result.
6673 comparison_result& result)
6677 // Types of this kind might have their comparison result cached
6679 // cached comparison result.
6680 if (get_cached_type_comparison_result(rdr, p, result))
6694 bool result = false;
6705 result = !die_is_declaration_only(die);
6711 result = true;
6717 return result;
7433 /// @param result out parameter. This is set to the result of the
7444 /// result is set to the result of the comparison.
7448 bool &result)
7486 result = true;
7495 result = slowly_compare_strings(l, r, attr_name);
7513 compare_dies_cu_decl_file(const Dwarf_Die* l, const Dwarf_Die *r, bool &result)
7523 result);
7524 if (compared && result)
7538 result);
7580 bool result = (dwarf_getlocation(&attr, expr, &len) == 0);
7584 result &= len > 0;
7586 if (result)
7589 return result;
7596 /// If the result of the operation is a constant, update the DEVM
7760 /// Upon successful completion, as the result of the operation is a
7885 /// state of the DEVM. If the result of the operation represents a
7887 /// result's value, Otherwise, the DEVM accumulator is left with its
8010 /// If the result of the operation is a constant, update the DEVM
8143 /// If the result of the operation is a constant, update the DEVM
8243 /// @param value out parameter. This is set to the result of the
8754 Dwarf_Attribute result;
8755 if (!dwarf_getlocation_attr(&attr, expr, &result))
8757 return !dwarf_formaddr(&result, &address);
9585 // strings, the result of the location expression evaluation
9826 bool result = false;
9832 result)
9834 result))
9836 if (!result)
9841 result))
9843 if (!result)
9851 result))
9852 return result;
10045 bool& result)
10066 result = (l_canonical_die_offset == r_canonical_die_offset);
10136 /// A macro to set the 'result' variable to 'false'.
10143 /// @param result the 'result' variable to set.
10148 #define SET_RESULT_TO_FALSE(result, l , r) \
10151 result = COMPARISON_RESULT_DIFFERENT; \
10155 /// A macro to set the 'result' variable to a given value.
10163 /// @param result the 'result' variable to set.
10168 #define SET_RESULT_TO(result, value, l , r) \
10171 result = (value); \
10172 if (result == COMPARISON_RESULT_DIFFERENT) \
10183 result = COMPARISON_RESULT_CYCLE_DETECTED; \
10185 ABG_RETURN(result); \
10378 /// @param return the result of comparing @p l against @p r.
10391 comparison_result result,
10397 if (result == COMPARISON_RESULT_EQUAL)
10399 // The result comparing the two types is "true", basically. So
10411 else if (result == COMPARISON_RESULT_CYCLE_DETECTED)
10414 // returned early with the comparison result
10422 // result to COMPARISON_RESULT_UNKNOWN;
10424 else if (result == COMPARISON_RESULT_UNKNOWN)
10427 // to do in this case where the result of the comparison of the
10430 // This means that we don't yet know what the result of
10450 // the result of its comparison must also be changed into
10473 result = COMPARISON_RESULT_EQUAL;
10486 else if (result == COMPARISON_RESULT_DIFFERENT)
10489 // to do in this case where the result of the comparison of the
10501 // Also, update the cached result for this pair, that was likely
10513 if (result == COMPARISON_RESULT_CYCLE_DETECTED)
10514 result = COMPARISON_RESULT_UNKNOWN;
10525 l_tag, cur_dies, result);
10527 return result;
10594 comparison_result result = COMPARISON_RESULT_EQUAL;
10597 result))
10598 return result;
10616 comparison_result result;
10617 SET_RESULT_TO(result,
10622 return result;
10634 SET_RESULT_TO_FALSE(result, l, r);
10647 SET_RESULT_TO_FALSE(result, l, r);
10663 SET_RESULT_TO_FALSE(result, l, r);
10678 result = COMPARISON_RESULT_EQUAL;
10680 SET_RESULT_TO_FALSE(result, l, r);
10682 result = compare_dies(rdr, &lu_type_die, &ru_type_die,
10690 SET_RESULT_TO_FALSE(result, l, r);
10709 SET_RESULT_TO_FALSE(result, l, r);
10725 SET_RESULT_TO_FALSE(result, l, r);
10730 SET_RESULT_TO_FALSE(result, l, r);
10743 SET_RESULT_TO_FALSE(result, l, r);
10749 result = COMPARISON_RESULT_EQUAL;
10771 SET_RESULT_TO_FALSE(result, l, r);
10786 // Note that if the result of comparing any
10794 result = local_result;
10798 SET_RESULT_TO_FALSE(result, l, r);
10804 SET_RESULT_TO_FALSE(result, l, r);
10834 result = compare_dies(rdr, &l_child, &r_child,
10837 if (!result)
10839 SET_RESULT_TO_FALSE(result, l, r);
10845 SET_RESULT_TO_FALSE(result, l, r);
10852 result = compare_dies(rdr, <ype_die, &rtype_die,
10855 if (!result)
10891 SET_RESULT_TO_FALSE(result, l, r);
10907 SET_RESULT_TO_FALSE(result, l, r);
10914 result = COMPARISON_RESULT_EQUAL;
10934 SET_RESULT_TO_FALSE(result, l, r);
10962 result = local_result;
10963 SET_RESULT_TO_FALSE(result, l, r);
10967 // Note that if the result of comparing any
10977 result = local_result;
10981 SET_RESULT_TO_FALSE(result, l, r);
10995 SET_RESULT_TO_FALSE(result, l, r);
11002 SET_RESULT_TO(result, local_result, l, r);
11018 SET_RESULT_TO_FALSE(result, l, r);
11020 if (result)
11030 SET_RESULT_TO(result, local_result, l, r);
11034 SET_RESULT_TO_FALSE(result, l, r);
11042 result = compare_dies(rdr, &l_type, &r_type,
11045 if (!result)
11077 result = compare_dies(rdr, &l_type, &r_type,
11080 if (!result)
11081 ABG_RETURN(result);
11085 result = compare_dies(rdr, &l_type, &r_type,
11088 if (!result)
11089 ABG_RETURN(result);
11151 ABG_RETURN(result);
11187 /// comparison yield the same result.
11872 imported_unit_points_type::const_iterator result =
11875 bool is_ok = result != p.end();
11878 r = result;
11901 translation_unit_sptr result;
11904 return result;
11936 result = rdr.corpus()->find_translation_unit(abs_path);
11939 if (!result)
11941 result.reset(new translation_unit(rdr.env(),
11944 result->set_compilation_dir_path(compilation_dir);
11945 rdr.corpus()->add(result);
11948 result->set_language(dwarf_language_to_tu_language(l));
11951 rdr.cur_transl_unit(result);
11952 rdr.die_tu_map()[dwarf_dieoffset(die)] = result;
11956 return result;
11958 result->set_is_constructed(false);
12026 result->set_is_constructed(true);
12028 return result;
12055 namespace_decl_sptr result;
12058 return result;
12062 return result;
12072 result.reset(new namespace_decl(rdr.env(), name, loc));
12073 add_decl_to_scope(result, scope.get());
12074 rdr.associate_die_to_decl(die, result, where_offset);
12078 return result;
12080 rdr.scope_stack().push(result.get());
12093 return result;
12108 type_decl_sptr result;
12111 return result;
12117 return result;
12132 result = is_type_decl(build_ir_node_for_void_type(rdr));
12136 return result;
12145 result = lookup_basic_type(normalized_type_name, *corp);
12148 if (!result)
12150 result = lookup_basic_type(type_name, *corp);
12151 if (!result)
12152 result.reset(new type_decl(rdr.env(), type_name, bit_size,
12154 rdr.associate_die_to_type(die, result, where_offset);
12155 return result;
12181 type_decl_sptr result(new type_decl(rdr.env(), underlying_type_name,
12183 result->set_is_anonymous(is_anonymous);
12184 result->set_is_artificial(true);
12186 decl_base_sptr d = add_decl_to_scope(result, tu->get_global_scope().get());
12187 result = dynamic_pointer_cast<type_decl>(d);
12188 ABG_ASSERT(result);
12189 canonicalize(result);
12190 return result;
12214 enum_type_decl_sptr result;
12216 return result;
12220 return result;
12251 result = pre_existing_enum;
12256 result = lookup_enum_type_per_location(loc.expand(), *corp);
12263 result = pre_existing_enum;
12266 if (result)
12268 rdr.associate_die_to_type(die, result, where_offset);
12269 return result;
12311 result.reset(new enum_type_decl(name, loc, t, enms, linkage_name));
12312 result->set_is_anonymous(is_anonymous);
12313 result->set_is_declaration_only(is_declaration_only);
12314 result->set_is_artificial(is_artificial);
12315 rdr.associate_die_to_type(die, result, where_offset);
12317 rdr.maybe_schedule_declaration_only_enum_for_resolution(result);
12319 return result;
12475 function_decl_sptr result = build_function_decl(rdr, die,
12479 return result;
12495 type_base_sptr result = lookup_class_or_typedef_type(qname, *corp);
12496 return result;
12551 type_base_sptr result = lookup_class_typedef_or_enum_type(qname, *corp);
12552 return result;
12725 class_decl_sptr result;
12727 return result;
12734 return result;
12773 result = lookup_class_type_per_location(loc.expand(), *corp);
12777 result = lookup_class_type(name, *corp);
12778 if (result
12783 && (result->get_is_declaration_only() == is_declaration_only
12784 || (!result->get_is_declaration_only()
12787 rdr.associate_die_to_type(die, result, where_offset);
12788 return result;
12794 result.reset();
12818 res = result = klass;
12821 res = result = is_class_type(klass->get_definition_of_declaration());
12823 result->set_location(loc);
12827 result.reset(new class_decl(rdr.env(), name, size,
12832 result->set_is_declaration_only(is_declaration_only);
12834 res = add_decl_to_scope(result, scope);
12835 result = dynamic_pointer_cast<class_decl>(res);
12836 ABG_ASSERT(result);
12840 if (size != result->get_size_in_bits())
12841 result->set_size_in_bits(size);
12846 if (!!result->get_size_in_bits() == result->get_is_declaration_only())
12859 result->set_is_declaration_only(is_declaration_only);
12863 if (!result->get_is_declaration_only() && has_child)
12864 if (result->get_size_in_bits() == 0 && size != 0)
12865 result->set_size_in_bits(size);
12867 result->set_is_artificial(is_artificial);
12869 rdr.associate_die_to_type(die, result, where_offset);
12871 rdr.maybe_schedule_declaration_only_class_for_resolution(result);
12876 return result;
12878 rdr.die_wip_classes_map(source)[dwarf_dieoffset(die)] = result;
12913 result->set_is_declaration_only(false);
12954 if (result->find_base_class(b->get_qualified_name()))
12956 result->add_base_specifier(base);
12981 if (!n.empty() && lookup_var_decl_in_scope(n, result))
12993 result.get(),
13006 // result. So let's check again if the variable is
13010 if (!n.empty() && lookup_var_decl_in_scope(n, result))
13017 result->set_is_declaration_only(false);
13026 if (n.empty() && result->find_data_member(dm))
13030 result->add_data_member(dm, access, is_laid_out,
13040 add_or_update_member_function(rdr, &child, result,
13072 (&child, anonymous_member_type_index, result.get()))
13073 || !result->find_member_type(die_name(&child)))
13074 build_ir_node_from_die(rdr, &child, result.get(),
13095 rdr.maybe_schedule_declaration_only_class_for_resolution(result);
13096 return result;
13132 union_decl_sptr result;
13134 return result;
13139 return result;
13181 result = lookup_union_type_per_location(loc.expand(), *corp);
13183 result = lookup_union_type(name, *corp);
13185 if (result)
13187 rdr.associate_die_to_type(die, result, where_offset);
13188 return result;
13209 result = union_type;
13210 result->set_location(loc);
13214 result.reset(new union_decl(rdr.env(), name, size, loc,
13218 result->set_is_declaration_only(true);
13219 result = is_union_type(add_decl_to_scope(result, scope));
13220 ABG_ASSERT(result);
13225 result->set_size_in_bits(size);
13226 result->set_is_declaration_only(false);
13229 result->set_is_artificial(is_artificial);
13231 rdr.associate_die_to_type(die, result, where_offset);
13233 // TODO: maybe schedule declaration-only union for result like we do
13235 // rdr.maybe_schedule_declaration_only_class_for_resolution(result);
13240 return result;
13242 rdr.die_wip_classes_map(source)[dwarf_dieoffset(die)] = result;
13245 dynamic_pointer_cast<scope_decl>(result);
13269 if (!n.empty() && lookup_var_decl_in_scope(n, result))
13284 result->set_is_declaration_only(false);
13293 if (n.empty() && result->find_data_member(dm))
13296 result->add_data_member(dm, access, /*is_laid_out=*/true,
13308 result.get(),
13317 finish_member_function_reading(&child, f, result, rdr);
13325 is_decl(build_ir_node_from_die(rdr, &child, result.get(),
13339 set_member_access_specifier(result,
13345 return result;
13371 type_base_sptr result;
13373 return result;
13380 return result;
13395 return result;
13401 result = t;
13402 rdr.associate_die_to_type(die, result, where_offset);
13403 return result;
13419 if (!result)
13420 result.reset(new qualified_type_def(utype, qual, location()));
13422 rdr.associate_die_to_type(die, result, where_offset);
13424 return result;
13495 decl_base_sptr result = t;
13499 result = strip_useless_const_qualification(t);
13500 if (result.get() != t.get())
13501 return result;
13546 result = is_decl(u);
13558 result = is_decl(u);
13562 return result;
13587 pointer_type_def_sptr result;
13590 return result;
13594 return result;
13611 return result;
13617 result = is_pointer_type(t);
13618 ABG_ASSERT(result);
13619 return result;
13638 result.reset(new pointer_type_def(utype, size, /*alignment=*/0, location()));
13639 ABG_ASSERT(result->get_pointed_to_type());
13641 rdr.associate_die_to_type(die, result, where_offset);
13642 return result;
13668 reference_type_def_sptr result;
13671 return result;
13676 return result;
13680 return result;
13687 return result;
13693 result = is_reference_type(t);
13694 ABG_ASSERT(result);
13695 return result;
13714 result.reset(new reference_type_def(utype, is_lvalue, size,
13718 if (reference_type_def_sptr t = lookup_reference_type(*result, *corp))
13719 result = t;
13720 rdr.associate_die_to_type(die, result, where_offset);
13721 return result;
13746 function_type_sptr result;
13749 return result;
13777 result = is_function_type(t);
13778 ABG_ASSERT(result);
13779 rdr.associate_die_to_type(die, result, where_offset);
13780 return result;
13840 result.reset(is_method
13846 rdr.associate_die_to_type(die, result, where_offset);
13847 rdr.die_wip_function_types_map(source)[dwarf_dieoffset(die)] = result;
13858 result->set_return_type(return_type);
13918 result->set_parameters(function_parms);
13920 tu->bind_function_type_life_time(result);
13922 result->set_is_artificial(true);
13924 rdr.associate_die_repr_to_fn_type_per_tu(die, result);
13934 maybe_canonicalize_type(result, rdr);
13935 return result;
13966 array_type_def::subrange_sptr result;
13969 return result;
13973 return result;
14053 result.reset
14059 result->is_infinite(is_infinite);
14062 result->set_underlying_type(underlying_type);
14064 ABG_ASSERT(result->is_infinite()
14065 || (result->get_length() ==
14066 (uint64_t) (result->get_upper_bound()
14067 - result->get_lower_bound() + 1)));
14070 rdr.associate_die_to_type(die, result, where_offset);
14072 return result;
14156 array_type_def_sptr result;
14159 return result;
14163 return result;
14173 return result;
14179 result = is_array_type(t);
14180 ABG_ASSERT(result);
14181 return result;
14191 result.reset(new array_type_def(type, subranges, location()));
14193 return result;
14218 typedef_decl_sptr result;
14221 return result;
14225 return result;
14233 result = lookup_typedef_type_per_location(loc.expand(), *corp);
14235 if (!result)
14251 return result;
14254 result.reset(new typedef_decl(name, utype, loc, linkage_name));
14263 decl->set_naming_typedef(result);
14267 rdr.associate_die_to_type(die, result, where_offset);
14269 return result;
14289 /// @param result if this is set to an existing var_decl, this means
14305 var_decl_sptr result,
14319 var = build_var_decl(rdr, die, where_offset, result);
14334 /// @param result if this is set to an existing var_decl, this means
14345 var_decl_sptr result)
14348 return result;
14354 return result;
14365 return result;
14371 return result;
14377 if (!result)
14378 result.reset(new var_decl(name, type, loc, linkage_name));
14385 result->set_linkage_name(linkage_name);
14391 if (!result->get_symbol())
14400 result->get_linkage_name().empty()
14401 ? result->get_name()
14402 : result->get_linkage_name());
14408 result->set_symbol(var_sym);
14411 string linkage_name = result->get_linkage_name();
14414 result->set_linkage_name(var_sym->get_name());
14415 result->set_is_in_public_symbol_table(true);
14419 return result;
14523 /// @param result if this is set to an existing function_decl, this
14537 function_decl_sptr result)
14563 if (!result && (!(is_dtor && is_virtual)))
14581 result = fn;
14591 fn = build_function_decl(rdr, fn_die, where_offset, result);
14755 type_or_decl_base_sptr result;
14758 return result;
14765 return result;
14771 return result;
14785 result = i->second.back();
14787 if (!result)
14804 result = klass;
14813 result = i->second.back();
14815 if (!result)
14831 result = enum_type;
14835 return result;
14849 elf_symbol_sptr result =
14860 return result;
14882 function_decl_sptr result = fn;
14884 return result;
14888 return result;
14901 if (result)
14912 && result->get_linkage_name() != flinkage_name)
14913 result->set_linkage_name(flinkage_name);
14915 if (!result->get_location())
14916 result->set_location(floc);
14923 return result;
14927 result.reset(is_method
14938 if (!result->get_symbol())
14946 result->get_linkage_name().empty()
14947 ? result->get_name()
14948 : result->get_linkage_name());
14954 result->set_symbol(fn_sym);
14955 string linkage_name = result->get_linkage_name();
14957 result->set_linkage_name(fn_sym->get_name());
14958 result->set_is_in_public_symbol_table(true);
14962 rdr.associate_die_to_type(die, result->get_type(), where_offset);
14969 && !result->get_linkage_name().empty())
14976 return result;
15129 type_or_decl_base_sptr result;
15132 return result;
15146 return result;
15151 if ((result = rdr.lookup_decl_from_die_offset(dwarf_dieoffset(die),
15156 if (type_base_sptr t = is_type(result))
15160 return result;
15175 result =
15191 result = add_decl_to_scope(t, scope);
15192 if (result)
15194 maybe_set_member_type_access_specifier(is_decl(result), die);
15208 result =
15210 ABG_ASSERT(result->get_translation_unit());
15225 result =
15256 result =
15258 maybe_canonicalize_type(is_type(result), rdr);
15276 result = get_opaque_version_of_type(rdr, scope, die, where_offset);
15277 maybe_canonicalize_type(is_type(result), rdr);
15284 result = add_decl_to_scope(e, scope);
15285 if (result)
15287 maybe_set_member_type_access_specifier(is_decl(result), die);
15288 maybe_canonicalize_type(is_type(result), rdr);
15309 result = get_opaque_version_of_type(rdr, scope, die, where_offset);
15310 maybe_canonicalize_type(is_type(result), rdr);
15352 result = klass;
15375 result = union_type;
15387 result = f;
15388 result->set_is_artificial(false);
15401 result =
15417 result =
15448 result = build_namespace_decl_and_add_to_ir(rdr, die, where_offset);
15498 result = m;
15505 /*result=*/var_decl_sptr(),
15508 result = add_decl_to_scope(v, scope);
15509 ABG_ASSERT(is_decl(result)->get_scope());
15510 v = dynamic_pointer_cast<var_decl>(result);
15587 result = build_or_get_fn_decl_if_not_suppressed(rdr, logical_scope,
15592 if (result && !fn)
15594 if (potential_member_fn_should_be_dropped(is_function_decl(result),
15598 result.reset();
15601 result = add_decl_to_scope(is_decl(result), logical_scope);
15604 fn = is_function_decl(result);
15685 if (result && tag != DW_TAG_subroutine_type)
15686 rdr.associate_die_to_decl(die, is_decl(result), where_offset,
15689 if (result)
15692 if (type_base_sptr t = is_type(result))
15696 return result;