Lines Matching defs:size
758 /// Get the size of the elf class, in bytes.
762 /// @return the size computed.
790 /// The bloom word size depends on the current elf class (32 bits for
903 // The number of words used by the bloom filter. A size of a word
910 // The size of the bloom filter in 4 bytes word. This is going to
966 // The size of one of the words used in the bloom
970 // The bitmask of the bloom filter has a size of either 32-bits on
1552 unsigned s = elems_.size();
1562 size() const
1563 {return elems_.size();}
2794 dwarf_offsets_type::size_type n = 0, s = i->second.size();
4068 else if (per_tu_class_map.size() == 1)
4109 size_t num_decl_only_classes = declaration_only_classes().size(),
4110 num_resolved = resolved_classes.size();
4304 else if (per_tu_enum_map.size() == 1)
4345 size_t num_decl_only_enums = declaration_only_enums().size(),
4346 num_resolved = resolved_enums.size();
4428 cerr << fns_with_no_symbol.size()
4524 size_t total = types_to_canonicalize().size();
6241 /// Get the size of a (type) DIE as the value for the parameter
6246 /// @param size the resulting size in bits. This is set iff the
6249 /// @return true if the size attribute was found.
6251 die_size_in_bits(const Dwarf_Die* die, uint64_t& size)
6266 size = bit_size;
6438 /// Test if a DIE has size attribute.
6442 /// @return true if the DIE has a size attribute.
7927 ABG_ASSERT(ctxt.stack.size() > 1);
7939 ABG_ASSERT(ctxt.stack.size() > 1);
7946 ABG_ASSERT(ctxt.stack.size() > 2);
7954 ABG_ASSERT(ctxt.stack.size() > 0);
7962 ABG_ASSERT(ctxt.stack.size() > 1);
7976 ABG_ASSERT(ctxt.stack.size() > 0);
8049 ABG_ASSERT(ctxt.stack.size() > 1);
9934 /// types (looking at their size etc).
9942 /// @return TRUE iff @p l equals @p r as far as naming and size is
11892 /// @param address_size the size of the addresses expressed in this
12120 // Update the bit size.
12129 // The size of the type is zero, that must mean that we are
12134 // A type of size zero that is not void? Hmmh, I am not sure
12166 /// @param enum_size the size of the enum.
12275 uint64_t size = 0;
12276 if (die_unsigned_constant_attribute(die, DW_AT_byte_size, size))
12277 size *= 8;
12307 build_enum_underlying_type(rdr, name, size,
12808 uint64_t size = 0;
12809 die_size_in_bits(die, size);
12827 result.reset(new class_decl(rdr.env(), name, size,
12840 if (size != result->get_size_in_bits())
12841 result->set_size_in_bits(size);
12847 // The size of the class doesn't match its
12855 // have non-zero size. So we must honor these too. That is why
12857 // class has non-zero size. An example of such binary is
12862 // having a non-zero size let's trust that.
12864 if (result->get_size_in_bits() == 0 && size != 0)
12865 result->set_size_in_bits(size);
12881 if (is_declaration_only && size == 0 && has_child)
12886 // size attribute and that has a DW_AT_declaration attribute.
13203 uint64_t size = 0;
13204 die_size_in_bits(die, size);
13214 result.reset(new union_decl(rdr.env(), name, size, loc,
13223 if (size)
13225 result->set_size_in_bits(size);
13626 // attribute then we assume the size of the pointer is the address
13627 // size of the current translation unit.
13628 uint64_t size = rdr.cur_transl_unit()->get_address_size();
13629 if (die_unsigned_constant_attribute(die, DW_AT_byte_size, size))
13630 // The size as expressed by DW_AT_byte_size is in byte, so let's
13632 size *= 8;
13634 // And the size of the pointer must be the same as the address size
13636 ABG_ASSERT((size_t) rdr.cur_transl_unit()->get_address_size() == size);
13638 result.reset(new pointer_type_def(utype, size, /*alignment=*/0, location()));
13702 // attribute then we assume the size of the reference is the address
13703 // size of the current translation unit.
13704 uint64_t size = rdr.cur_transl_unit()->get_address_size();
13705 if (die_unsigned_constant_attribute(die, DW_AT_byte_size, size))
13706 size *= 8;
13708 // And the size of the pointer must be the same as the address size
13710 ABG_ASSERT((size_t) rdr.cur_transl_unit()->get_address_size() == size);
13714 result.reset(new reference_type_def(utype, is_lvalue, size,
14041 // known) size.
14047 // If the upper_bound size is the max of the integer value, then
14048 // it most certainly means infinite size.
14631 // concrete variable, then it's suppressed. This is a size
14795 /*alignment=*/0, /*size=*/0,
14817 uint64_t size = 0;
14818 if (die_unsigned_constant_attribute(type_die, DW_AT_byte_size, size))
14819 size *= 8;
14821 build_enum_underlying_type(rdr, type_name, size,
14852 /*symbol size=*/ 0,