reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

   20 class Address;

   19 class Address;

   54 class Address;

   20 class Address;

   25 class Address;

   21 class Address;

   28 class Address;

   20 class Address;

   78 class Address;

   20 class Address;

   34 class Address;

References

   30   T t;
   39 template <typename T> union SizerImpl<T> { char arr[sizeof(T)]; };
   50       llvm::detail::SizerImpl<T, Ts...>)];

  437   static const bool isRef = std::is_reference<T>::value;
  439   using wrap = std::reference_wrapper<typename std::remove_reference<T>::type>;
  444   using storage_type = typename std::conditional<isRef, wrap, T>::type;
  445   using value_type = T;
  448   using reference = typename std::remove_reference<T>::type &;
  449   using const_reference = const typename std::remove_reference<T>::type &;
  450   using pointer = typename std::remove_reference<T>::type *;
  451   using const_pointer = const typename std::remove_reference<T>::type *;
  474   Expected(OtherT &&Val,
  475            typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
  475            typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
  483     new (getStorage()) storage_type(std::forward<OtherT>(Val));
  492   Expected(Expected<OtherT> &&Other,
  493            typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
  493            typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
  594   template <class OtherT> void moveConstruct(Expected<OtherT> &&Other) {

  106   lldb_private::Address *operator->();
  108   const lldb_private::Address *operator->() const;
  112   lldb_private::Address *get();
  114   lldb_private::Address &ref();
  116   const lldb_private::Address &ref() const;
  118   SBAddress(const lldb_private::Address *lldb_object_ptr);
  120   void SetAddress(const lldb_private::Address *lldb_object_ptr);
  123   std::unique_ptr<lldb_private::Address> m_opaque_up;

  242   lldb::BreakpointLocationSP AddLocation(const Address &addr,
  253   lldb::BreakpointLocationSP FindLocationByAddress(const Address &addr);
  262   lldb::break_id_t FindLocationIDByAddress(const Address &addr);

   50   Address &GetAddress();
  321                      const Address &addr, lldb::tid_t tid, bool hardware,
  329   Address m_address;   ///< The address defining this location.

   49   const lldb::BreakpointLocationSP FindByAddress(const Address &addr) const;
   70   lldb::break_id_t FindIDByAddress(const Address &addr);
  177   lldb::BreakpointLocationSP Create(const Address &addr,
  184   lldb::BreakpointLocationSP AddLocation(const Address &addr,
  200   typedef std::map<lldb_private::Address, lldb::BreakpointLocationSP,
  201                    Address::ModulePointerAndOffsetLessThanFunctionObject>

  211   lldb::BreakpointLocationSP AddLocation(Address loc_addr,

   24   BreakpointResolverAddress(Breakpoint *bkpt, const Address &addr);
   26   BreakpointResolverAddress(Breakpoint *bkpt, const Address &addr,
   45                                           Address *addr) override;
   62   Address

   39                                           Address *addr) override;

   41                                           Address *addr) override;

   62                                           Address *addr) override;

   42                                           Address *addr) override;

  117   Address(const Address &rhs)
  162   const Address &operator=(const Address &rhs);
  162   const Address &operator=(const Address &rhs);
  185   static int CompareFileAddress(const Address &lhs, const Address &rhs);
  185   static int CompareFileAddress(const Address &lhs, const Address &rhs);
  187   static int CompareLoadAddress(const Address &lhs, const Address &rhs,
  187   static int CompareLoadAddress(const Address &lhs, const Address &rhs,
  190   static int CompareModulePointerAndOffset(const Address &lhs,
  191                                            const Address &rhs);
  198     bool operator()(const Address &a, const Address &b) const {
  198     bool operator()(const Address &a, const Address &b) const {
  199       return Address::CompareModulePointerAndOffset(a, b) < 0;
  501 bool operator<(const Address &lhs, const Address &rhs);
  501 bool operator<(const Address &lhs, const Address &rhs);
  502 bool operator>(const Address &lhs, const Address &rhs);
  502 bool operator>(const Address &lhs, const Address &rhs);
  503 bool operator==(const Address &lhs, const Address &rhs);
  503 bool operator==(const Address &lhs, const Address &rhs);
  504 bool operator!=(const Address &lhs, const Address &rhs);
  504 bool operator!=(const Address &lhs, const Address &rhs);

   76   AddressRange(const Address &so_addr, lldb::addr_t byte_size);
  121   bool ContainsFileAddress(const Address &so_addr) const;
  145   bool ContainsLoadAddress(const Address &so_addr, Target *target) const;
  194   Dump(Stream *s, Target *target, Address::DumpStyle style,
  195        Address::DumpStyle fallback_style = Address::DumpStyleInvalid) const;
  195        Address::DumpStyle fallback_style = Address::DumpStyleInvalid) const;
  213   Address &GetBaseAddress() { return m_base_addr; }
  219   const Address &GetBaseAddress() const { return m_base_addr; }
  245   Address m_base_addr;      ///< The section offset base address of this range.

   38                                           Address *addr) override;

   43                                           Address *addr) override;

   48   virtual size_t GetBytesToSkip(Symbol &func, const Address &curr_addr) const {
   61                                        Address &addr) const {}

  109                                         const Address *addr, Stream &s);

   59   Instruction(const Address &address,
   64   const Address &GetAddress() const { return m_address; }
   86   void SetAddress(const Address &addr) {
  212   Address m_address; // The section offset address of this instruction
  303   uint32_t GetIndexOfInstructionAtAddress(const Address &addr);
  388                    const char *flavor, const Address &start, const void *bytes,
  402                           const ExecutionContext &exe_ctx, const Address &start,
  449                            const Address &range, uint32_t num_instructions,
  452   virtual size_t DecodeInstructions(const Address &base_addr,

  378                               const Address &inst_addr, Target *target);

   41                                           Address *addr) override;

  180                      const ExecutionContext *exe_ctx, const Address *addr,
  187                               const Address *addr, ValueObject *valobj,
  193                             const Address *addr, ValueObject *valobj,

  354                             std::vector<Address> &output_local,
  355                             std::vector<Address> &output_extern);
  653   bool ResolveFileAddress(lldb::addr_t vm_addr, Address &so_addr);
  693       const Address &so_addr, lldb::SymbolContextItem resolve_scope,
 1026                                           Address &so_addr, SymbolContext &sc);

  405                             std::vector<Address> &output_local,
  406                             std::vector<Address> &output_extern);
  430   bool ResolveFileAddress(lldb::addr_t vm_addr, Address &so_addr) const;
  434   uint32_t ResolveSymbolContextForAddress(const Address &so_addr,

   56                                         Address *addr) = 0;
  119   virtual bool AddressPasses(Address &addr);
  322   bool AddressPasses(Address &address) override;
  375   bool AddressPasses(Address &address) override;
  426   bool AddressPasses(Address &address) override;

  136   bool ResolveContainedAddress(lldb::addr_t offset, Address &so_addr,

  119   Address m_address; ///< The variable that this value object is based upon

   35                                     const Address &address,
   40                                     const Address &address,
   62   Address m_address; ///< The variable that this value object is based upon
   68                     const Address &address, lldb::TypeSP &type_sp);
   71                     const Address &address, const CompilerType &ast_type);

   84                  const Address &function_address,
  315   Address m_function_addr;  ///< If we don't have the FunctionSP, we at least

  298   Address m_address;       ///< The address the process is stopped in.

  106                                   Address *addr) override = 0;
  130                                             Address *addr) override;
  153                                             Address *addr) override;
  174                                             Address *addr) override;

   37   bool GetUnwindPlan(Target &target, const Address &addr,
   51   const uint8_t *GetExceptionHandlingTableEntry(const Address &addr);

  365   bool GetRangeContainingAddress(const Address &addr, AddressRange &range);
  370   uint32_t GetRangeIndexContainingAddress(const Address &addr);
  376   bool GetStartAddress(Address &addr);

   20   virtual bool GetAddressRange(Address addr, AddressRange &range) = 0;
   22   virtual bool GetUnwindPlan(const Address &addr, UnwindPlan &unwind_plan) = 0;

 1031                                     const Address &function_address,

   42   bool GetUnwindPlan(Target &target, Address addr, UnwindPlan &unwind_plan);
   82     Address lsda_address; // the address of the LSDA data for this function
   83     Address personality_ptr_address; // the address where the personality
  109   bool GetCompactUnwindInfoForFunction(Target &target, Address address,
  130                                Address pc_or_function_start);
  134                              Address pc_or_function_start);
  138                               Address pc_or_function_start);
  142                               Address pc_or_function_start);

   44   bool GetAddressRange(Address addr, AddressRange &range);
   49   bool GetUnwindPlan(const Address &addr, UnwindPlan &unwind_plan);
  129   bool FDEToUnwindPlan(uint32_t offset, Address startaddr,

   52   Address &GetFirstNonPrologueInsn(Target &target);
   54   const Address &GetFunctionStartAddress() const;
   56   bool ContainsAddress(const Address &addr) const {
   65   Address GetLSDAAddress(Target &target);
   71   Address GetPersonalityRoutinePtrAddress(Target &target);
  150   Address m_first_non_prologue_insn;

   66   bool Dump(Stream *s, Target *target, bool show_file, Address::DumpStyle style,
   67             Address::DumpStyle fallback_style, bool show_range) const;

   90   void Dump(Stream *s, Target *target, Address::DumpStyle style,
   91             Address::DumpStyle fallback_style, bool show_line_ranges);
  112   bool FindLineEntryByAddress(const Address &so_addr, LineEntry &line_entry,

  336   virtual Symbol *ResolveSymbolForAddress(const Address &so_addr,
  457   virtual lldb_private::Address GetImageInfoAddress(Target *target) {
  467   virtual lldb_private::Address GetEntryPointAddress() { return Address(); }
  477   virtual lldb_private::Address GetBaseAddress() {

   55   Address &GetAddressRef() { return m_addr_range.GetBaseAddress(); }
   57   const Address &GetAddressRef() const { return m_addr_range.GetBaseAddress(); }
   71   Address GetAddress() const {

  155                        const Address &so_addr, bool show_fullpaths,
  329   bool GetParentOfInlinedScope(const Address &curr_frame_pc,
  331                                Address &inlined_frame_addr) const;

  167   virtual uint32_t ResolveSymbolContext(const Address &so_addr,
  241   GetUnwindPlan(const Address &address, const RegisterInfoResolver &resolver) {

  463                                             const Address &function_address,

  445   bool PlanValidAtAddress(Address addr);
  507   Address GetLSDAAddress() const { return m_lsda_address; }
  509   void SetLSDAAddress(Address lsda_addr) { m_lsda_address = lsda_addr; }
  511   Address GetPersonalityFunctionPtr() const { return m_personality_func_addr; }
  513   void SetPersonalityFunctionPtr(Address presonality_func_ptr) {
  533   Address m_lsda_address; // Where the language specific data area exists in the
  536   Address m_personality_func_addr; // The address of a pointer to the

   40   lldb::FuncUnwindersSP GetFuncUnwindersContainingAddress(const Address &addr,
   54   GetUncachedFuncUnwindersContainingAddress(const Address &addr,
   63   llvm::Optional<AddressRange> GetAddressRange(const Address &addr,

   77   bool DumpLocationForAddress(Stream *s, const Address &address);
   87   bool LocationIsValidForAddress(const Address &address);

   81                                         Address &address,

 1745   virtual lldb::addr_t ResolveIndirectFunction(const Address *address,
 2358   Address AdvanceAddressToNextBranchInstruction(Address default_stop_addr,
 2358   Address AdvanceAddressToNextBranchInstruction(Address default_stop_addr,
 2472   bool CallVoidArgVoidPtrReturn(const Address *address,

   35             lldb::addr_t item_ref, lldb_private::Address address);
   62   lldb_private::Address &GetAddress();
   69   void SetAddress(lldb_private::Address addr);
  144   lldb_private::Address m_address;

  151   bool SetPC(Address addr);

   48                           Address &so_addr);

   43   bool ResolveLoadAddress(lldb::addr_t load_addr, Address &so_addr,

  122              const Address &pc, bool behaves_like_zeroth_frame,
  137   const Address &GetFrameCodeAddress();
  512   Address m_frame_code_addr; // The frame code address (might not be the same as

  617   lldb::BreakpointSP CreateBreakpoint(const Address &addr, bool internal,
  971   size_t ReadMemoryFromFileCache(const Address &addr, void *dst, size_t dst_len,
  984   size_t ReadMemory(const Address &addr, bool prefer_file_cache, void *dst,
  988   size_t ReadCStringFromMemory(const Address &addr, std::string &out_str,
  991   size_t ReadCStringFromMemory(const Address &addr, char *dst,
  994   size_t ReadScalarIntegerFromMemory(const Address &addr,
  999   uint64_t ReadUnsignedIntegerFromMemory(const Address &addr,
 1004   bool ReadPointerFromMemory(const Address &addr, bool prefer_file_cache,
 1005                              Status &error, Address &pointer_addr);
 1057                                                const Address &function_address,
 1078   bool ResolveFileAddress(lldb::addr_t load_addr, Address &so_addr);
 1080   bool ResolveLoadAddress(lldb::addr_t load_addr, Address &so_addr,
 1134   llvm::Expected<lldb_private::Address> GetEntryPointAddress();

  893   QueueThreadPlanForRunToAddress(bool abort_other_plans, Address &target_addr,

   25   ThreadPlanCallFunction(Thread &thread, const Address &function,
   30   ThreadPlanCallFunction(Thread &thread, const Address &function,
  124   Address m_function_addr;
  125   Address m_start_addr;

   32                                  const Address &function_address,

   24   ThreadPlanCallUserExpression(Thread &thread, Address &function,

   21   ThreadPlanRunToAddress(Thread &thread, Address &address, bool stop_others);

   40                        Address &first_non_prologue_insn) = 0;

   24 SBAddress::SBAddress() : m_opaque_up(new Address()) {
   28 SBAddress::SBAddress(const Address *lldb_object_ptr)
   29     : m_opaque_up(new Address()) {
   31     m_opaque_up = std::make_unique<Address>(*lldb_object_ptr);
   34 SBAddress::SBAddress(const SBAddress &rhs) : m_opaque_up(new Address()) {
   41     : m_opaque_up(new Address(section.GetSP(), offset)) {
   48     : m_opaque_up(new Address()) {
   92   m_opaque_up.reset(new Address());
   99   Address &addr = ref();
  104 void SBAddress::SetAddress(const Address *lldb_object_ptr) {
  108     m_opaque_up.reset(new Address());
  184 Address *SBAddress::operator->() { return m_opaque_up.get(); }
  186 const Address *SBAddress::operator->() const { return m_opaque_up.get(); }
  188 Address &SBAddress::ref() {
  190     m_opaque_up.reset(new Address());
  194 const Address &SBAddress::ref() const {
  201 Address *SBAddress::get() { return m_opaque_up.get(); }
  211     m_opaque_up->Dump(&strm, nullptr, Address::DumpStyleResolvedDescription,
  212                       Address::DumpStyleModuleWithFileAddress, 4);

  133       Address address;
  154     Address address;
  571                         Address::DumpStyleModuleWithFileAddress);

  244     const Address &addr = inst_sp->GetAddress();
  279     const Address &addr = inst_sp->GetAddress();

  170         const Address &addr = inst->GetAddress();

  218     Address addr;

  138       const Address &symbol_addr = m_opaque_ptr->GetAddressRef();

  610   Address &addr = sb_addr.ref();
  629   Address &addr = sb_addr.ref();
  647   Address &addr = sb_addr.ref();
 2034     Address *addr_ptr = base_addr.get();
 2078     Address addr;

  829   Address target_addr(addr);

  224     Address *start_address = sb_start_address.get();
  268     Address *start_address = sb_start_address.get();
  348     Address *address = sb_address.get();

 1339           Address addr;
 1355   Address addr;

   17 template <typename T> std::unique_ptr<T> clone(const std::unique_ptr<T> &src) {
   17 template <typename T> std::unique_ptr<T> clone(const std::unique_ptr<T> &src) {
   19     return std::make_unique<T>(*src);

  254 BreakpointLocationSP Breakpoint::AddLocation(const Address &addr,
  260 BreakpointLocationSP Breakpoint::FindLocationByAddress(const Address &addr) {
  264 break_id_t Breakpoint::FindLocationIDByAddress(const Address &addr) {
  533         Address section_addr(break_loc_sp->GetAddress());

   32                                        const Address &addr, lldb::tid_t tid,
   65 Address &BreakpointLocation::GetAddress() { return m_address; }
  574     m_address.Dump(s, exe_scope, Address::DumpStyleLoadAddress,
  575                    Address::DumpStyleFileAddress);
  577     m_address.Dump(s, exe_scope, Address::DumpStyleLoadAddress,
  578                    Address::DumpStyleModuleWithFileAddress);
  581     Address resolved_address;

   29 BreakpointLocationList::Create(const Address &addr,
   56 lldb::break_id_t BreakpointLocationList::FindIDByAddress(const Address &addr) {
   97 BreakpointLocationList::FindByAddress(const Address &addr) const {
  101     Address so_addr;
  203     const Address &addr, bool resolve_indirect_symbols, bool *new_location) {

  296   Address line_start = sc.line_entry.range.GetBaseAddress();
  315     Address prologue_addr(sc.function->GetAddressRange().GetBaseAddress());
  338 BreakpointLocationSP BreakpointResolver::AddLocation(Address loc_addr,

   25     Breakpoint *bkpt, const Address &addr, const FileSpec &module_spec)
   31                                                      const Address &addr)
   52   Address address(addr_offset);
  124     SearchFilter &filter, SymbolContext &context, Address *addr) {
  137           Address tmp_address;
  173               Address::DumpStyleModuleWithFileAddress,
  174               Address::DumpStyleLoadAddress);

  202     SearchFilter &filter, SymbolContext &context, Address *addr) {

   98     SearchFilter &filter, SymbolContext &context, Address *addr) {

  253                                        SymbolContext &context, Address *addr) {
  259   Address break_addr;

  110     SearchFilter &filter, SymbolContext &context, Address *addr) {

  107   Address watch_address(GetLoadAddress());

  359                                                         Address *addr) {
  445     SearchFilter &filter, SymbolContext &context, Address *addr) {
  491     SearchFilter &filter, SymbolContext &context, Address *addr) {

  373               Address symbol_containing_address;
  407                 Address file_address;

  677       Address address(addr, nullptr);
  823         Address address(item_addr);
 1721           lldb_private::Address addr;

   95               Address so_reg_addr;
  101                                  Address::DumpStyleResolvedDescription);

  315     Address so_addr;
  361                          Address::DumpStyleModuleWithFileAddress);
  370                        Address::DumpStyleModuleWithFileAddress);
  411           const Address &base_address = sc.symbol->GetAddressRef();
  437         const Address &base_address = range.GetBaseAddress();
  958             const Address &base_address = sc.symbol->GetAddressRef();
 1012       Address so_addr;
 1057                            Address::DumpStyleModuleWithFileAddress);

 1459                         const Address &so_addr, bool verbose, Stream &strm) {
 1462   so_addr.Dump(&strm, exe_scope, Address::DumpStyleModuleWithFileAddress);
 1464   so_addr.Dump(&strm, exe_scope, Address::DumpStyleSectionNameOffset);
 1469   so_addr.Dump(&strm, exe_scope, Address::DumpStyleResolvedDescription);
 1474     so_addr.Dump(&strm, exe_scope, Address::DumpStyleDetailedSymbolContext);
 1485     Address so_addr;
 2791                 Address file_entry = objfile->GetEntryPointAddress();
 2975           Address module_address;
 3139             Address base_addr(objfile->GetBaseAddress());
 3146                                    Address::DumpStyleModuleWithFileAddress,
 3147                                    Address::DumpStyleFileAddress);
 3164               base_addr.Dump(&strm, target, Address::DumpStyleFileAddress);
 3354       Address addr;

  666           Address pc_address = frame->GetFrameCodeAddress();
 1183         Address fun_start_addr = fun_addr_range.GetBaseAddress();
 1187         Address fun_end_addr(fun_start_addr.GetSection(),
 1775       Address dest = Address(m_options.m_load_addr);

   61                         const Address &address, void *dst, size_t dst_len) {
   76                                        const Address &address,
  101                               const Address &address, uint32_t byte_size,
  125                         const Address &address, uint32_t pointer_size,
  126                         Address &deref_so_addr) {
  161 static bool DumpUInt(ExecutionContextScope *exe_scope, const Address &address,
  190                                     const Address &address, Stream *strm) {
  201   Address curr_address(address);
  239 const Address &Address::operator=(const Address &rhs) {
  239 const Address &Address::operator=(const Address &rhs) {
  411   Address so_addr;
  549                 Address cstr_addr(*this);
  575           Address cfstring_data_addr(*this);
  752           Address dereferenced_addr;
  896 int Address::CompareFileAddress(const Address &a, const Address &b) {
  896 int Address::CompareFileAddress(const Address &a, const Address &b) {
  906 int Address::CompareLoadAddress(const Address &a, const Address &b,
  906 int Address::CompareLoadAddress(const Address &a, const Address &b,
  918 int Address::CompareModulePointerAndOffset(const Address &a, const Address &b) {
  918 int Address::CompareModulePointerAndOffset(const Address &a, const Address &b) {
  941   return sizeof(Address);
  956 bool lldb_private::operator<(const Address &lhs, const Address &rhs) {
  956 bool lldb_private::operator<(const Address &lhs, const Address &rhs) {
  971 bool lldb_private::operator>(const Address &lhs, const Address &rhs) {
  971 bool lldb_private::operator>(const Address &lhs, const Address &rhs) {
  987 bool lldb_private::operator==(const Address &a, const Address &rhs) {
  987 bool lldb_private::operator==(const Address &a, const Address &rhs) {
  993 bool lldb_private::operator!=(const Address &a, const Address &rhs) {
  993 bool lldb_private::operator!=(const Address &a, const Address &rhs) {

   40 AddressRange::AddressRange(const Address &so_addr, addr_t byte_size)
   62 bool AddressRange::ContainsFileAddress(const Address &addr) const {
   93 bool AddressRange::ContainsLoadAddress(const Address &addr,
  148 bool AddressRange::Dump(Stream *s, Target *target, Address::DumpStyle style,
  149                         Address::DumpStyle fallback_style) const {
  159   case Address::DumpStyleSectionNameOffset:
  160   case Address::DumpStyleSectionPointerOffset:
  169   case Address::DumpStyleModuleWithFileAddress:
  172   case Address::DumpStyleFileAddress:
  176   case Address::DumpStyleLoadAddress:
  190   } else if (fallback_style != Address::DumpStyleInvalid) {
  191     return Dump(s, target, fallback_style, Address::DumpStyleInvalid);

   41                                         SymbolContext &context, Address *addr) {
   54       Address line_start = sc.line_entry.range.GetBaseAddress();

   70                                     SymbolContext &context, Address *addr) {
   77   Address func_addr;

 1109                                          const Address *addr, Stream &s) {

  107 static void ResolveAddress(const ExecutionContext &exe_ctx, const Address &addr,
  108                            Address &resolved_addr) {
  218                                const char *flavor, const Address &start,
  273                                const Address &start_address,
  286   Address addr;
  401   const Address *pc_addr_ptr = nullptr;
  441       const Address &addr = inst->GetAddress();
  492       const Address &addr = inst->GetAddress();
  683 Instruction::Instruction(const Address &address, AddressClass addr_class)
 1158 InstructionList::GetIndexOfInstructionAtAddress(const Address &address) {
 1173   Address address;
 1218                                        const Address &start,

  160         lldb_private::Address so_addr;
  636         lldb_private::Address so_addr;
  641             so_addr.Dump(s, exe_scope, Address::DumpStyleResolvedDescription,
  642                          Address::DumpStyleModuleWithFileAddress);
  646                          Address::DumpStyleResolvedPointerDescription);

  522                                         const Address &inst_addr,

   36                                  Address *addr) {

  418                         const ExecutionContext *exe_ctx, const Address &addr,
  438       addr.Dump(&s, exe_scope, Address::DumpStyleLoadAddress,
  439                 Address::DumpStyleModuleWithFileAddress, 0);
  450                                           const Address &format_addr,
  454     Address func_addr;
 1055                                    const Address *addr, ValueObject *valobj,
 1072                                  const Address *addr, ValueObject *valobj,
 1088                           const ExecutionContext *exe_ctx, const Address *addr,
 1417         const Address &pc_addr = frame->GetFrameCodeAddress();
 1827       Address addr = sc->line_entry.range.GetBaseAddress();
 1843           Address pc;

 4103         Address pc_address;
 4314           Address addr = inst->GetAddress();
 4351           Address addr = inst->GetAddress();

  426 bool Module::ResolveFileAddress(lldb::addr_t vm_addr, Address &so_addr) {
  439     const Address &so_addr, lldb::SymbolContextItem resolve_scope,
  535       Address previous_addr = so_addr;
  907                                   std::vector<Address> &output_local,
  908                                   std::vector<Address> &output_extern) {
  914     Address addr = resolver.GetAddressRangeAtIndex(n).GetBaseAddress();

  536                                       std::vector<Address> &output_local,
  537                                       std::vector<Address> &output_extern) {
  597                                     Address &so_addr) const {
  609 ModuleList::ResolveSymbolContextForAddress(const Address &so_addr,

  140 bool SearchFilter::AddressPasses(Address &address) { return true; }
  150   Address addr = function.GetAddressRange().GetBaseAddress();
  415 bool SearchFilterByModule::AddressPasses(Address &address) {
  550 bool SearchFilterByModuleList::AddressPasses(Address &address) {
  742 bool SearchFilterByModuleListAndCU::AddressPasses(Address &address) {

  246 bool Section::ResolveContainedAddress(addr_t offset, Address &so_addr,

  323   Address file_so_addr;
  417             Address so_addr(address, objfile->GetSectionList());
  678   Address so_addr;

  815         Address so_addr;
 1022     Address cstr_so_addr(cstr_address);
 2947     Address ptr_addr(ptr_value);
 2961     Address ptr_addr(ptr_value);

  145   Address dynamic_address;

   33                                         const Address &address,
   40                                         const Address &address,
   47                                      const Address &address,
   74                                      const Address &address,

   38       Address so_addr;
   44                        Address::DumpStyleResolvedDescription,
   45                        Address::DumpStyleSectionNameOffset);

   82               Address address(valobj->GetPointerValue());

 1149         Address so_addr;

   35                                const Address &functionAddress,
  249   Address wrapper_address(m_jit_start_addr);

 1496       lldb_private::Address funcAddr(I.ULongLong(LLDB_INVALID_ADDRESS));

  641       Address absolute_address(process_address);

  131       Address wrapper_address(m_jit_start_addr);

 1063     const Address sym_address = m_symbol.GetAddress();

   87       return (0 == Address::CompareLoadAddress(m_address,

   73   Address impl_code_address;

 1395   Address so_addr;

 1399   Address so_addr;

   81   Address resolved_addr;
  102     Address sym_addr;
  139     const ExecutionContext &exe_ctx, const Address &resolved_addr,
  167   Address addr = resolved_addr;

   39                                        const Address &resolved_addr,

   53                                          const Address &curr_addr) const {
   61                                                 Address &addr) const {

   29   size_t GetBytesToSkip(Symbol &func, const Address &curr_addr) const override;
   32                                Address &addr) const override;

   84                    const lldb_private::Address &address,
 1251 size_t DisassemblerLLVMC::DecodeInstructions(const Address &base_addr,
 1266   Address inst_addr(base_addr);
 1365       Address value_so_addr;
 1366       Address pc_so_addr;
 1404           value_so_addr.Dump(&ss, target, Address::DumpStyleNoFunctionName,
 1405                              Address::DumpStyleSectionNameOffset);
 1409               Address::DumpStyleResolvedDescriptionNoFunctionArguments,
 1410               Address::DumpStyleSectionNameOffset);

   39   size_t DecodeInstructions(const lldb_private::Address &base_addr,

 1161     const Address &kext_summary_addr, uint32_t count) {
 1362     const Address &kext_summary_addr, uint32_t image_infos_count,
 1411       Address summary_addr(m_kext_summary_header_addr);

  256   bool ParseKextSummaries(const lldb_private::Address &kext_summary_addr,
  264   uint32_t ReadKextSummaries(const lldb_private::Address &kext_summary_addr,
  291   lldb_private::Address m_kext_summary_header_ptr_addr;
  292   lldb_private::Address m_kext_summary_header_addr;

   65       Address addr = sym->GetAddress();
  533     lldb_private::Address entry = object.GetEntryPointAddress();

  298   Address address = list[0].symbol->GetAddress();

  156     Address header;
  838     std::vector<Address> addresses;
  884                   const Address actual_symbol_addr =
  934         Address target_addr(actual_symbol->GetAddress());
  952       for (Address address : addresses) {
  956           Address symbol_address = symbol->GetAddress();
 1019 Address DynamicLoaderDarwin::GetPthreadSetSpecificAddress() {
 1048   lldb_private::Address tls_addr;
 1083           Address pthread_getspecific_addr = GetPthreadSetSpecificAddress();

  200   lldb_private::Address GetPthreadSetSpecificAddress();
  231   lldb_private::Address m_pthread_getspecific_addr;

  998       Address so_addr;

   51       Address addr = obj_file->GetImageInfoAddress(target);
  566   Address address = list[0].symbol->GetAddress();

  125       Address addr = obj->GetImageInfoAddress(&target);
  613   Address file_entry = exe->GetEntryPointAddress();

   86   Address resolved_addr;

  549     const Address sym_address = sym_ctx.symbol->GetAddress();
 1595     Address so_addr(var_location.GetScalar().ULongLong(),
 1750   const Address symbol_address = symbol.GetAddress();
 1899   Address fun_address;
 2071                      Address::DumpStyleResolvedDescription);

   48                                          const Address &functionAddress,

  116                       const Address &function_address,

13805                                            const Address &inst_addr,

  131   bool SetInstruction(const Opcode &insn_opcode, const Address &inst_addr,

  999                                             const Address &inst_addr,
 1017       Address next_addr(next_inst_addr);

   76                       const lldb_private::Address &inst_addr,

  121     Address addr = frame->GetFrameCodeAddress();

  543   lldb_private::Address so_addr;
  558   lldb_private::Address so_addr;
  597     lldb_private::Address so_addr;

  157     const Address FCA =

  468   const Address jit_descriptor_addr = sym_ctx.symbol->GetAddress();

  147   Address vtable_addr_resolved;
  184   Address function_address_resolved;
  243     Address address = range.GetBaseAddress();
  245     Address addr;
  294   Address pc_addr_resolved;

   30     Address callable_address;

   60     Address vtable_addr;
  188     TypeAndOrName &class_type_or_name, Address &dynamic_address,
  562   Address addr = context.symbol->GetAddress();
  597     const lldb_private::Address &vtable_addr) {
  607     const lldb_private::Address &vtable_addr, const TypeAndOrName &type_info) {

   53                                 Address &address,
   94   typedef std::map<lldb_private::Address, TypeAndOrName> DynamicTypeCache;
  109   TypeAndOrName GetDynamicTypeInfo(const lldb_private::Address &vtable_addr);
  111   void SetDynamicTypeInfo(const lldb_private::Address &vtable_addr,

  101   const Address *function_address = GetPrintForDebuggerAddr();
  219 Address *AppleObjCRuntime::GetPrintForDebuggerAddr() {
  237     m_PrintForDebugger_addr.reset(new Address(context.symbol->GetAddress()));
  252     TypeAndOrName &class_type_or_name, Address &address,

   53                                 Address &address,
  116   Address *GetPrintForDebuggerAddr();
  118   std::unique_ptr<Address> m_PrintForDebugger_addr;

   50     TypeAndOrName &class_type_or_name, Address &address,

   97                                 Address &address,

  438     TypeAndOrName &class_type_or_name, Address &address,
 1309   Address function_address;
 1571   Address function_address;

   53                                 Address &address,

  486           const Address changed_symbol_addr = changed_symbol->GetAddress();
 1053       Address impl_code_address;

  140     Address target_so_addr;

  466 bool SkipPrologue(lldb::ModuleSP &module, Address &addr) {
  793                                      SymbolContext &context, Address *) {
  812     Address bp_addr = kernel_sym->GetAddress();
  823                                            Address *) {
  864         auto address = symbol->GetAddress();
  883     SearchFilter &filter, SymbolContext &context, Address *addr) {
  929       auto address = sym->GetAddress();
 1016     TypeAndOrName &class_type_or_name, Address &address,
 3872   Address resolved;

   71                                           Address *addr) override;
  121                                           Address *addr) override;
  266                                           Address *addr) override;
  338                                 Address &address,

  801 Address ObjectFileELF::GetImageInfoAddress(Target *target) {
  843         Address addr;
  855           Address addr;
  868 lldb_private::Address ObjectFileELF::GetEntryPointAddress() {
  885 Address ObjectFileELF::GetBaseAddress() {
 2783       auto entry_point_addr = GetEntryPointAddress();

  131   lldb_private::Address
  134   lldb_private::Address GetEntryPointAddress() override;
  136   lldb_private::Address GetBaseAddress() override;
  220   lldb_private::Address m_entry_point_address;

  183 lldb_private::Address ObjectFileJIT::GetEntryPointAddress() {
  187 lldb_private::Address ObjectFileJIT::GetBaseAddress() { return Address(); }

   90   lldb_private::Address GetEntryPointAddress() override;
   92   lldb_private::Address GetBaseAddress() override;

 4524           Address symbol_addr;
 4619                 Address so_addr(symbol_stub_addr, section_list);
 5123 lldb_private::Address ObjectFileMachO::GetEntryPointAddress() {
 5295 lldb_private::Address ObjectFileMachO::GetBaseAddress() {
 5296   lldb_private::Address header_addr;

  107   lldb_private::Address GetEntryPointAddress() override;
  109   lldb_private::Address GetBaseAddress() override;
  226   lldb_private::Address m_entry_point_address;

  522 uint32_t ObjectFilePECOFF::GetRVA(const Address &addr) const {
  526 Address ObjectFilePECOFF::GetAddress(uint32_t rva) {
  566     Address addr = GetAddress(rva);
  688               Address symbol_addr(sect_list->GetSectionAtIndex(symbol.sect - 1),
  752           Address symbol_addr(m_coff_header_opt.image_base + function_rva,
 1010 lldb_private::Address ObjectFilePECOFF::GetEntryPointAddress() {
 1028 Address ObjectFilePECOFF::GetBaseAddress() {

  123   lldb_private::Address GetEntryPointAddress() override;
  125   lldb_private::Address GetBaseAddress() override;
  138   uint32_t GetRVA(const lldb_private::Address &addr) const;
  139   lldb_private::Address GetAddress(uint32_t rva);
  300   lldb_private::Address m_entry_point_address;

  444 bool PECallFrameInfo::GetAddressRange(Address addr, AddressRange &range) {
  460 bool PECallFrameInfo::GetUnwindPlan(const Address &addr,

   31   bool GetAddressRange(lldb_private::Address addr,
   34   bool GetUnwindPlan(const lldb_private::Address &addr,

   99   Address pc_minus_one(m_current_pc);
  483     Address temporary_pc;
 1890       Address addr;

  224   lldb_private::Address m_start_pc;
  225   lldb_private::Address m_current_pc;

  404   Address addr = obj_file->GetImageInfoAddress(&GetTarget());

   81   Address GetBaseAddress() override {

  251 SymbolFileBreakpad::ResolveSymbolContext(const Address &so_addr,
  483 SymbolFileBreakpad::GetUnwindPlan(const Address &address,

   89   uint32_t ResolveSymbolContext(const Address &so_addr,
  135   GetUnwindPlan(const Address &address,

  813 bool SymbolFileDWARF::FixupAddress(Address &addr) {
 1714 uint32_t SymbolFileDWARF::ResolveSymbolContext(const Address &so_addr,
 1822                 Address exe_so_addr(so_addr);
 2197     Address addr;

  150   uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr,
  416   bool FixupAddress(lldb_private::Address &addr);

  753 SymbolFileDWARFDebugMap::ResolveSymbolContext(const Address &exe_so_addr,
  782             Address oso_so_addr;
 1371 bool SymbolFileDWARFDebugMap::LinkOSOAddress(Address &addr) {

   87   uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr,
  327   bool LinkOSOAddress(lldb_private::Address &addr);

  958     const Address &addr, SymbolContextItem resolve_scope, SymbolContext &sc) {

  109   uint32_t ResolveSymbolContext(const Address &so_addr,

  727 SymbolFilePDB::ResolveSymbolContext(const lldb_private::Address &so_addr,
  779       Address addr(so_addr);
 1892     const lldb_private::Address &so_addr) {

   92   uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr,
  200   GetCompileUnitContainsAddress(const lldb_private::Address &so_addr);

  245 uint32_t SymbolFileSymtab::ResolveSymbolContext(const Address &so_addr,

   70   uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr,

  147   Address impl_code_address;

  143   Address impl_code_address;

  829       Address addr;

  291     Address &first_non_prologue_insn) {

   45                        lldb_private::Address &first_non_prologue_insn) override;

  209     Address &first_non_prologue_insn) {

   39                        lldb_private::Address &first_non_prologue_insn) override;

 1339   Address addr_start = func_range.GetBaseAddress();

   99 bool ArmUnwindInfo::GetUnwindPlan(Target &target, const Address &addr,
  354 ArmUnwindInfo::GetExceptionHandlingTableEntry(const Address &addr) {

  239 bool Block::GetRangeContainingAddress(const Address &addr,
  269   Address load_address;
  275 uint32_t Block::GetRangeIndexContainingAddress(const Address &addr) {
  306 bool Block::GetStartAddress(Address &addr) {

10314     const CompilerType &return_type, const Address &function_address,

  172 bool CompactUnwindInfo::GetUnwindPlan(Target &target, Address addr,
  190             Address::DumpStyle::DumpStyleResolvedDescriptionNoFunctionArguments,
  191             Address::DumpStyle::DumpStyleFileAddress,
  492     Target &target, Address address, FunctionInfo &unwind_info) {
  737                                                 Address pc_or_function_start) {
  822           Address subl_payload_addr(function_info.valid_range_offset_start, sl);
 1009                                               Address pc_or_function_start) {
 1087           Address subl_payload_addr(function_info.valid_range_offset_start, sl);
 1306                                                Address pc_or_function_start) {
 1440                                                Address pc_or_function_start) {

  150 bool DWARFCallFrameInfo::GetUnwindPlan(const Address &addr,
  158   Address addr = range.GetBaseAddress();
  172 bool DWARFCallFrameInfo::GetAddressRange(Address addr, AddressRange &range) {
  527                                          Address startaddr,
  608   Address lsda_data;
  609   Address personality_function_ptr;

   88     Address current_pc(m_range.GetBaseAddress());
  166     Address current_pc(m_range.GetBaseAddress());
  459   Address current_pc;
  484   Address current_pc;
  501 Address &FuncUnwinders::GetFirstNonPrologueInsn(Target &target) {
  514 const Address &FuncUnwinders::GetFunctionStartAddress() const {
  528 Address FuncUnwinders::GetLSDAAddress(Target &target) {
  529   Address lsda_addr;
  544 Address FuncUnwinders::GetPersonalityRoutinePtrAddress(Target &target) {
  545   Address personality_addr;

  159     Address callee_addr = sc_list[0].symbol->GetAddress();
  183   const Address &base = caller.GetAddressRange().GetBaseAddress();
  234   Address scratch_addr(GetAddressRange().GetBaseAddress());
  332   Address::DumpStyle fallback_style;
  334     fallback_style = Address::DumpStyleModuleWithFileAddress;
  336     fallback_style = Address::DumpStyleFileAddress;
  337   GetAddressRange().Dump(s, target, Address::DumpStyleLoadAddress,

   72                      Address::DumpStyle style,
   73                      Address::DumpStyle fallback_style, bool show_range) const {
  113       range.GetBaseAddress().Dump(s, target, Address::DumpStyleLoadAddress,
  114                                   Address::DumpStyleFileAddress);
  116       range.Dump(s, target, Address::DumpStyleLoadAddress,
  117                  Address::DumpStyleFileAddress);
  148     return Dump(s, target, true, Address::DumpStyleLoadAddress,
  149                 Address::DumpStyleModuleWithFileAddress, true);
  159   int result = Address::CompareFileAddress(a.range.GetBaseAddress(),
  205     Address range_end(complete_line_range.GetBaseAddress());

  170 bool LineTable::FindLineEntryByAddress(const Address &so_addr,
  405 void LineTable::Dump(Stream *s, Target *target, Address::DumpStyle style,
  406                      Address::DumpStyle fallback_style, bool show_line_ranges) {

  187         m_addr_range.Dump(s, target, Address::DumpStyleLoadAddress,
  188                           Address::DumpStyleFileAddress);
  192                                            Address::DumpStyleLoadAddress,
  193                                            Address::DumpStyleFileAddress);
  224                                             Address::DumpStyleFileAddress))
  230                                             Address::DumpStyleLoadAddress))
  264       const Address &base_address = m_addr_range.GetBaseAddress();
  282             Address addr(base_address);
  509   Address func_so_addr;

   85                                     const Address &addr, bool show_fullpaths,
  101     Address inline_parent_addr;
  191     addr.Dump(s, exe_scope, Address::DumpStyleModuleWithFileAddress);
  340     function->GetAddressRange().Dump(s, target, Address::DumpStyleLoadAddress,
  341                                      Address::DumpStyleModuleWithFileAddress);
  361   line_entry.Dump(s, target, true, Address::DumpStyleLoadAddress,
  362                   Address::DumpStyleModuleWithFileAddress, true);
  450 bool SymbolContext::GetParentOfInlinedScope(const Address &curr_frame_pc,
  452                                             Address &next_frame_pc) const {
  690   Address start_addr;
  798         const Address sym_address = symbol->GetAddress();
 1121     Address match_address(addr, nullptr);
 1189                              Address::DumpStyleLoadAddress,
 1190                              Address::DumpStyleFileAddress);

  433 bool UnwindPlan::PlanValidAtAddress(Address addr) {
  439       if (addr.Dump(&s, nullptr, Address::DumpStyleSectionNameOffset)) {
  462       if (addr.Dump(&s, nullptr, Address::DumpStyleSectionNameOffset)) {
  537                                     Address::DumpStyleSectionNameOffset);

   86 llvm::Optional<AddressRange> UnwindTable::GetAddressRange(const Address &addr,
  113 UnwindTable::GetFuncUnwindersContainingAddress(const Address &addr,
  151 UnwindTable::GetUncachedFuncUnwindersContainingAddress(const Address &addr,

  254 bool Variable::LocationIsValidForAddress(const Address &address) {
  450 bool Variable::DumpLocationForAddress(Stream *s, const Address &address) {

  115                                           Address *addr) override {

 1649       Address symbol_address = symbol->GetAddress();
 1660       Address resolved_address(load_addr);
 5589 addr_t Process::ResolveIndirectFunction(const Address *address, Status &error) {
 5769 Address
 5770 Process::AdvanceAddressToNextBranchInstruction(Address default_stop_addr,
 5776   Address retval = default_stop_addr;
 5811     Address next_branch_insn_address =
 5980 bool Process::CallVoidArgVoidPtrReturn(const Address *address,

   18                      lldb::addr_t item_ref, lldb_private::Address address)
   39 Address &QueueItem::GetAddress() { return m_address; }
   41 void QueueItem::SetAddress(Address addr) { m_address = addr; }

  153 bool RegisterContext::SetPC(Address addr) {

  208 bool SectionLoadList::ResolveLoadAddress(addr_t load_addr, Address &so_addr,

  106                        const Address &pc_addr, bool behaves_like_zeroth_frame,
  188 const Address &StackFrame::GetFrameCodeAddress() {
  297     Address lookup_addr(GetFrameCodeAddress());
 1363       lldb_private::Address addr;
 1491                                    VariableList &variables, const Address &pc) {
 1593         Address load_address;
 1616         Address return_value_address(return_value.GetAsUInt64());

  110   Address pc_as_address;
  504       Address curr_frame_address(unwind_frame_sp->GetFrameCodeAddress());
  526       Address next_frame_address;

  102     Address start_addr = symbol->GetAddress();
  103     Address current_addr = frame->GetFrameCodeAddress();

  374   Address so_addr;
  392 BreakpointSP Target::CreateBreakpoint(const Address &addr, bool internal,
 1678 size_t Target::ReadMemoryFromFileCache(const Address &addr, void *dst,
 1710 size_t Target::ReadMemory(const Address &addr, bool prefer_file_cache,
 1724   Address resolved_addr;
 1802 size_t Target::ReadCStringFromMemory(const Address &addr, std::string &out_str,
 1807   Address address(addr);
 1824 size_t Target::ReadCStringFromMemory(const Address &addr, char *dst,
 1833     Address address(addr);
 1877 size_t Target::ReadScalarIntegerFromMemory(const Address &addr,
 1906 uint64_t Target::ReadUnsignedIntegerFromMemory(const Address &addr,
 1918 bool Target::ReadPointerFromMemory(const Address &addr, bool prefer_file_cache,
 1919                                    Status &error, Address &pointer_addr) {
 2212     const Address &function_address, const ValueList &arg_value_list,
 2422 llvm::Expected<lldb_private::Address> Target::GetEntryPointAddress() {
 2431     Address entry_addr = exe_module->GetObjectFile()->GetEntryPointAddress();
 2448     Address entry_addr = module_sp->GetObjectFile()->GetEntryPointAddress();
 2745 bool Target::ResolveLoadAddress(addr_t load_addr, Address &so_addr,
 2751                                 Address &resolved_addr) {

 1465                                                     Address &target_addr,
 1718 static void DumpAddressList(Stream &s, const std::vector<Address> &list,
 1722     list[n].Dump(&s, exe_scope, Address::DumpStyleResolvedDescription,
 1723                  Address::DumpStyleSectionNameOffset);
 1738   std::vector<Address> candidates, within_function, outside_function;
 1769   Address dest = candidates[0];

   67   llvm::Expected<Address> start_address = GetTarget().GetEntryPointAddress();
   97     Thread &thread, const Address &function, const CompilerType &return_type,
  127     Thread &thread, const Address &function,

   24     Thread &thread, const Address &function, llvm::Type &prototype,

   35     Thread &thread, Address &function, llvm::ArrayRef<lldb::addr_t> args,

   22 ThreadPlanRunToAddress::ThreadPlanRunToAddress(Thread &thread, Address &address,

  116       Address symbol_end = sc.symbol->GetAddress();

  261         Address func_start_address;
  284             Address curr_sec_addr;

  102     Address return_address(return_frame_sp->GetFrameCodeAddress());
  106       Address return_address_decr_pc = return_address;
  194       Address tmp_address;
  196         tmp_address.Dump(s, &GetThread(), Address::DumpStyleResolvedDescription,
  197                          Address::DumpStyleLoadAddress);
  208         tmp_address.Dump(s, &GetThread(), Address::DumpStyleResolvedDescription,
  209                          Address::DumpStyleLoadAddress);

  225               Address cur_address = frame_sp->GetFrameCodeAddress();
  245                     Address prev_address =
  270                     Address next_line_address =

   92                              Address::DumpStyleLoadAddress);
   97                                Address::DumpStyleLoadAddress);
  136                                            true, Address::DumpStyleLoadAddress,
  137                                            Address::DumpStyleLoadAddress, true);
  155                                            true, Address::DumpStyleLoadAddress,
  156                                            Address::DumpStyleLoadAddress, true);
  178                                            true, Address::DumpStyleLoadAddress,
  179                                            Address::DumpStyleLoadAddress, true);
  324     Address run_to_address;

  136   Address pc_addr;
  142   pc_addr.Dump(stream, &m_thread, Address::DumpStyleResolvedDescription,
  143                Address::DumpStyleModuleWithFileAddress);

  424       auto addr =
  478     auto addr = le.GetSameLineContiguousAddressRange(include_inlined_functions)

   57   Address start_addr(0x100);

   65   Address start_addr(0x100);

  233   auto entry_point_addr = module_sp->GetObjectFile()->GetEntryPointAddress();
  298   auto entry_point_addr = module_sp->GetObjectFile()->GetEntryPointAddress();

  387       using allocator_type = allocator<_Tp>;
  389       using value_type = _Tp;
  392       using pointer = _Tp*;
  395       using const_pointer = const _Tp*;
  474 	construct(allocator_type& __a, _Up* __p, _Args&&... __args)
  474 	construct(allocator_type& __a, _Up* __p, _Args&&... __args)
  475 	{ __a.construct(__p, std::forward<_Args>(__args)...); }
  486 	destroy(allocator_type& __a, _Up* __p)

  108     class allocator: public __allocator_base<_Tp>
  113       typedef _Tp*       pointer;
  114       typedef const _Tp* const_pointer;
  115       typedef _Tp&       reference;
  116       typedef const _Tp& const_reference;
  117       typedef _Tp        value_type;
  137 	allocator(const allocator<_Tp1>&) throw() { }
  158     operator!=(const allocator<_T1>&, const allocator<_T2>&)
  158     operator!=(const allocator<_T1>&, const allocator<_T2>&)
  164     operator!=(const allocator<_Tp>&, const allocator<_Tp>&)
  164     operator!=(const allocator<_Tp>&, const allocator<_Tp>&)

   46     inline _GLIBCXX_CONSTEXPR _Tp*
   47     __addressof(_Tp& __r) _GLIBCXX_NOEXCEPT
   72     constexpr _Tp&&
   73     forward(typename std::remove_reference<_Tp>::type& __t) noexcept
   83     constexpr _Tp&&
   84     forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
   98     move(_Tp&& __t) noexcept
  104     : public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
  105                     is_copy_constructible<_Tp>>::type { };

  343 		   _Args&&... __args)
  688     allocate_shared(const _Alloc& __a, _Args&&... __args)
  703     make_shared(_Args&&... __args)

 1317 		     _Args&&... __args)

   74     _Construct(_T1* __p, _Args&&... __args)
   74     _Construct(_T1* __p, _Args&&... __args)
   75     { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
   97     _Destroy(_Tp* __pointer)
  204 	     allocator<_Tp>&)

  121       typedef _Arg1 	first_argument_type; 
  124       typedef _Arg2 	second_argument_type;
  381     struct less : public binary_function<_Tp, _Tp, bool>
  381     struct less : public binary_function<_Tp, _Tp, bool>
  385       operator()(const _Tp& __x, const _Tp& __y) const
  385       operator()(const _Tp& __x, const _Tp& __y) const

 1224     __make_move_if_noexcept_iterator(_Tp* __i)

  181       typedef _Tp                         value_type;
  183       typedef _Tp*                        pointer;
  184       typedef _Tp&                        reference;
  192       typedef _Tp                         value_type;
  194       typedef const _Tp*                  pointer;
  195       typedef const _Tp&                  reference;

  102       typedef _Key					key_type;
  104       typedef std::pair<const _Key, _Tp>		value_type;

  563       typedef _Key 				key_type;
  758       static const _Key&
  782       static const _Key&
  894 		     const _Key& __k);
  898 		     const _Key& __k) const;
  902 		     const _Key& __k);
  906 		     const _Key& __k) const;

  288 			   _ForwardIterator __result, allocator<_Tp>&)

   77 	rebind<_Tp>::other _Tp_alloc_type;
  216     class vector : protected _Vector_base<_Tp, _Alloc>
  227       typedef _Vector_base<_Tp, _Alloc>			_Base;
  232       typedef _Tp					value_type;
  919       _Tp*
  923       const _Tp*
  962 	emplace_back(_Args&&... __args);
 1483 	_M_realloc_insert(iterator __position, _Args&&... __args);

   68         default_delete(const default_delete<_Up>&) noexcept { }
   72       operator()(_Tp* __ptr) const
   74 	static_assert(!is_void<_Tp>::value,
   76 	static_assert(sizeof(_Tp)>0,
  122 	  using type = _Up*;
  137       using pointer = typename _Ptr<_Tp, _Dp>::type;
  161 	typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
  163       __uniq_ptr_impl<_Tp, _Dp> _M_t;
  166       using pointer	  = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
  167       using element_type  = _Tp;
  252 	unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
  297           __safe_conversion_up<_Up, _Ep>,
  301 	operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
  689     operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
  706     operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
  811     { typedef unique_ptr<_Tp> __single_object; };
  823     inline typename _MakeUniq<_Tp>::__single_object
  824     make_unique(_Args&&... __args)
  825     { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }

  101 				     std::forward<_Args>(__args)...);
  105 	  _M_realloc_insert(end(), std::forward<_Args>(__args)...);
  418 				   std::forward<_Args>(__args)...);

  117       { typedef typename _Base_type::template rebind_alloc<_Tp> other; };

   63       typedef _Tp*       pointer;
   64       typedef const _Tp* const_pointer;
   65       typedef _Tp&       reference;
   66       typedef const _Tp& const_reference;
   67       typedef _Tp        value_type;
  111 	return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
  130       { return size_t(-1) / sizeof(_Tp); }
  135 	construct(_Up* __p, _Args&&... __args)
  135 	construct(_Up* __p, _Args&&... __args)
  136 	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
  136 	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
  140 	destroy(_Up* __p) { __p->~_Up(); }
  160     operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
  160     operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&)

   50       typedef _E 		value_type;
   51       typedef const _E& 	reference;
   52       typedef const _E& 	const_reference;
   54       typedef const _E* 	iterator;
   55       typedef const _E* 	const_iterator;

  125       constexpr _Head_base(const _Head& __h)
  132         constexpr _Head_base(_UHead&& __h)
  159       static constexpr _Head&
  162       static constexpr const _Head&
  350       static constexpr _Head&
  353       static constexpr const _Head&
  360       constexpr _Tuple_impl(const _Head& __head)
  365         constexpr _Tuple_impl(_UHead&& __head)
  390 		    const _Head& __head)
  473       return __and_<is_constructible<_Elements, const _UElements&>...>::value;
  479       return __and_<is_convertible<const _UElements&, _Elements>...>::value;
  485       return __and_<is_constructible<_Elements, _UElements&&>...>::value;
  491       return __and_<is_convertible<_UElements&&, _Elements>...>::value;
  608         constexpr tuple(const _Elements&... __elements)
  619       explicit constexpr tuple(const _Elements&... __elements)
  646         constexpr tuple(_UElements&&... __elements)
  730 	      const _Elements&... __elements)
  741                        const _Elements&... __elements)
 1302     constexpr _Head&
 1307     constexpr const _Head&
 1313     constexpr __tuple_element_t<__i, tuple<_Elements...>>&
 1319     constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
 1325     constexpr __tuple_element_t<__i, tuple<_Elements...>>&&

  215     : public __is_void_helper<typename remove_cv<_Tp>::type>::type
  326     : public __is_integral_helper<typename remove_cv<_Tp>::type>::type
  354     : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
  381     : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
  567     : public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
  581     : public __or_<is_lvalue_reference<_Tp>,
  582                    is_rvalue_reference<_Tp>>::type
  588     : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
  588     : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  602                           is_void<_Tp>>>::type
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  612                    is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
  612                    is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
  631     : public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  762     typename add_rvalue_reference<_Tp>::type declval() noexcept;
  777     : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
  777     : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
  798       typedef decltype(__test<_Tp>(0)) type;
  811                remove_all_extents<_Tp>::type>::type
  825     : public __is_destructible_safe<_Tp>::type
  984       typedef decltype(__test<_Tp, _Arg>(0)) type;
  989     : public __and_<is_destructible<_Tp>,
  990                     __is_direct_constructible_impl<_Tp, _Arg>>
 1072 			 __is_direct_constructible_ref_cast<_Tp, _Arg>,
 1073 			 __is_direct_constructible_new_safe<_Tp, _Arg>
 1079     : public __is_direct_constructible_new<_Tp, _Arg>::type
 1119     : public __is_direct_constructible<_Tp, _Arg>
 1130     : public __is_constructible_impl<_Tp, _Args...>::type
 1142     : public is_constructible<_Tp, const _Tp&>
 1142     : public is_constructible<_Tp, const _Tp&>
 1148     : public __is_copy_constructible_impl<_Tp>
 1215     : public __and_<is_constructible<_Tp, _Args...>,
 1216 		    __is_nt_constructible_impl<_Tp, _Args...>>
 1246     : public is_nothrow_constructible<_Tp, _Tp&&>
 1246     : public is_nothrow_constructible<_Tp, _Tp&&>
 1252     : public __is_nothrow_move_constructible_impl<_Tp>
 1526 	static void __test_aux(_To1);
 1538       typedef decltype(__test<_From, _To>(0)) type;
 1538       typedef decltype(__test<_From, _To>(0)) type;
 1545     : public __is_convertible_helper<_From, _To>::type
 1545     : public __is_convertible_helper<_From, _To>::type
 1554     { typedef _Tp     type; };
 1558     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1629     { typedef _Tp   type; };
 1633     { typedef _Tp   type; };
 1645     { typedef _Tp&   type; };
 1650     : public __add_lvalue_reference_helper<_Tp>
 1659     { typedef _Tp&&   type; };
 1664     : public __add_rvalue_reference_helper<_Tp>
 1955     { typedef _Tp     type; };
 2171     { typedef _Iffalse type; };