Lines Matching full:address

61   // Address of the executable segment of the binary.
62   uint64_t Address;
63   // Index to the sorted code address array of the binary.
65   InstructionPointer(const ProfiledBinary *Binary, uint64_t Address,
106   // Whether the start address is the real entry of the function.
112 // PrologEpilog address tracker, used to filter out broken stack samples
114 // based on the start address and return address. In the future,
130       PrologEpilogSet.insert(IP.Address);
134   // Take the last two addresses before the return address as epilog
141       PrologEpilogSet.insert(IP.Address);
199   // The runtime base address that the first executable segment is loaded at.
201   // The runtime base address that the first loadabe segment is loaded at.
203   // The preferred load address of each executable segment.
217   // if a given RVA is a valid code address.
230   // GUID to Elf symbol start address map
237   // Start address to Elf symbol GUID map
240   // An ordered map of mapping function's start address to function range
245   // Address to context location map. Used to expand the context.
248   // Address to instruction size map. Also used for quick Address lookup.
298   // Indicate if the base loading address is parsed from the mmap event or uses
299   // the preferred address
332   // Create elf symbol to its start address mapping.
335   // A function may be spilt into multiple non-continuous address ranges. We use
343   /// Dissassemble the text section and build various address maps.
371   void setBaseAddress(uint64_t Address) { BaseAddress = Address; }
375   // Canonicalize to use preferred load address as base address.
376   uint64_t canonicalizeVirtualAddress(uint64_t Address) {
377     return Address - BaseAddress + getPreferredBaseAddress();
379   // Return the preferred load address for the first executable segment.
383   // Return the preferred load address for the first loadable segment.
394   uint64_t getInstSize(uint64_t Address) const {
395     auto I = AddressToInstSizeMap.find(Address);
401   bool addressIsCode(uint64_t Address) const {
402     return AddressToInstSizeMap.find(Address) != AddressToInstSizeMap.end();
405   bool addressIsCall(uint64_t Address) const {
406     return CallAddressSet.count(Address);
408   bool addressIsReturn(uint64_t Address) const {
409     return RetAddressSet.count(Address);
411   bool addressInPrologEpilog(uint64_t Address) const {
412     return ProEpilogTracker.PrologEpilogSet.count(Address);
415   bool addressIsTransfer(uint64_t Address) {
416     return BranchAddressSet.count(Address) || RetAddressSet.count(Address) ||
417            CallAddressSet.count(Address);
443   // Get the index in CodeAddressVec for the address
444   // As we might get an address which is not the code
445   // here it would round to the next valid code address by
447   uint32_t getIndexForAddr(uint64_t Address) const {
448     auto Low = llvm::lower_bound(CodeAddressVec, Address);
462   FuncRange *findFuncRangeForStartAddr(uint64_t Address) {
463     auto I = StartAddrToFuncRangeMap.find(Address);
469   // Binary search the function range which includes the input address.
470   FuncRange *findFuncRange(uint64_t Address) {
471     auto I = StartAddrToFuncRangeMap.upper_bound(Address);
476     if (Address >= I->second.EndAddress)
483   RangesTy getRanges(uint64_t Address) {
484     auto *FRange = findFuncRange(Address);
529   getFrameLocationStack(uint64_t Address, bool UseProbeDiscriminator = false) {
530     InstructionPointer IP(this, Address);
535   getCachedFrameLocationStack(uint64_t Address,
537     auto I = AddressToLocStackMap.emplace(Address, SampleContextFrameVector());
539       I.first->second = getFrameLocationStack(Address, UseProbeDiscriminator);
544   std::optional<SampleContextFrame> getInlineLeafFrameLoc(uint64_t Address) {
545     const auto &Stack = getCachedFrameLocationStack(Address);
573   const MCDecodedPseudoProbe *getCallProbeForAddr(uint64_t Address) const {
574     return ProbeDecoder.getCallProbeForAddr(Address);