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

References

  228     typedef uintptr_t omp_uintptr_t;

  156   void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID,
  159   void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID,

   40     uintptr_t Val = static_cast<uintptr_t>(-1);
   46     uintptr_t Val = static_cast<uintptr_t>(-2);

  671     uintptr_t x = reinterpret_cast<uintptr_t>(Probe) & ~0x1;

  154   uintptr_t Allocator;
  234     uintptr_t PtrVal = reinterpret_cast<uintptr_t>(X.getInternalPointer());

  375   uintptr_t Allocator;
  652   SmallVector<uintptr_t,20> stack;
  671   uintptr_t getVisitState() const {

   34   uintptr_t Value = 0;
   38   static_assert(Bits < sizeof(uintptr_t) * CHAR_BIT,
   41   enum : uintptr_t {
   44     Shift = sizeof(uintptr_t) * CHAR_BIT - Bits,
   56   explicit PointerEmbeddedInt(uintptr_t Value, RawValueTag) : Value(Value) {}

  146                     std::numeric_limits<uintptr_t>::digits,
  150   enum : uintptr_t {
  199     uintptr_t Val = static_cast<uintptr_t>(-1);
  205     uintptr_t Val = static_cast<uintptr_t>(-2);
  211     uintptr_t IV = reinterpret_cast<uintptr_t>(V.getOpaqueValue());

   88     uintptr_t Value;
  188   uintptr_t getOpaqueValue() const {
  191     return bit_cast<uintptr_t>(Storage);
  233                    uintptr_t, (V < Min<Vs...>::value ? V : Min<Vs...>::value)> {
  236   struct Min<V> : std::integral_constant<uintptr_t, V> {};
  283     uintptr_t OpaqueValue = Arg.getOpaqueValue();
  284     return DenseMapInfo<uintptr_t>::getHashValue(OpaqueValue);

   38   uintptr_t X = 1;
   42     NumBaseBits = sizeof(uintptr_t) * CHAR_BIT,
   99   void switchToSmall(uintptr_t NewSmallBits, size_t NewSize) {
  112   uintptr_t getSmallRawBits() const {
  117   void setSmallRawBits(uintptr_t NewRawBits) {
  130   uintptr_t getSmallBits() const {
  134   void setSmallBits(uintptr_t NewBits) {
  199       uintptr_t Bits = getSmallBits();
  229       uintptr_t Bits = getSmallBits();
  239       uintptr_t Bits = getSmallBits();
  253       uintptr_t Bits = getSmallBits();
  264       uintptr_t Bits = getSmallBits();
  276       uintptr_t Bits = getSmallBits();
  291       uintptr_t Bits = getSmallBits();
  293       uintptr_t Mask = (uintptr_t(1) << Prev) - 1;
  311       uintptr_t Bits = getSmallBits();
  312       Bits &= maskTrailingOnes<uintptr_t>(PriorTo + 1);
  333       uintptr_t NewBits = t ? ~uintptr_t(0) << getSmallSize() : 0;
  338       uintptr_t OldBits = getSmallBits();
  348         uintptr_t OldBits = getSmallRawBits();
  389       uintptr_t EMask = ((uintptr_t)1) << E;
  390       uintptr_t IMask = ((uintptr_t)1) << I;
  391       uintptr_t Mask = EMask - IMask;
  420       uintptr_t EMask = ((uintptr_t)1) << E;
  421       uintptr_t IMask = ((uintptr_t)1) << I;
  422       uintptr_t Mask = EMask - IMask;
  669     uintptr_t M = Mask[0];

  102     uintptr_t Val = static_cast<uintptr_t>(-1);

  913   uintptr_t thunk;
  914   uintptr_t key;
  915   uintptr_t offset;

  862   void tidyLandingPads(DenseMap<MCSymbol *, uintptr_t> *LPMap = nullptr,

   77     uintptr_t AlignedP =
   96     uintptr_t AlignedP =

   46   uintptr_t IntPtr = static_cast<uintptr_t>(Addr);

  348     using AtomicIntPtr = std::atomic<uintptr_t>;

   38   static const unsigned PointerSize = sizeof(uintptr_t);

   74     uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
   86     uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
  108     void reserveAllocationSpace(uintptr_t CodeSize, uint32_t CodeAlign,
  109                                 uintptr_t RODataSize, uint32_t RODataAlign,
  110                                 uintptr_t RWDataSize,
  231         uintptr_t LocalAddr = reinterpret_cast<uintptr_t>(Contents.get());

  427     uintptr_t *Ptr =

  128   constexpr static uintptr_t EmptyBitPattern =
  129       std::numeric_limits<uintptr_t>::max()
  132   constexpr static uintptr_t TombstoneBitPattern =
  133       (std::numeric_limits<uintptr_t>::max() - 1)
  136   constexpr static uintptr_t InvalidPtrMask =
  137       (std::numeric_limits<uintptr_t>::max() - 3)

  104     virtual uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
  111     virtual uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
  124     virtual void reserveAllocationSpace(uintptr_t CodeSize, uint32_t CodeAlign,
  125                                         uintptr_t RODataSize,
  127                                         uintptr_t RWDataSize,

  118   uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
  127   uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
  178   uint8_t *allocateSection(AllocationPurpose Purpose, uintptr_t Size,

  163   static std::error_code checkOffset(MemoryBufferRef M, uintptr_t Addr,

  806   uintptr_t getSymbolTable() const {
 1047   std::error_code getVaPtr(uint64_t VA, uintptr_t &Res) const;
 1048   std::error_code getRvaPtr(uint32_t Rva, uintptr_t &Res) const;

  330     uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin());
  768   std::vector<uintptr_t> Offsets;
  819   uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin());

   40   uintptr_t p;

   36     uintptr_t H = hash_value(Sig.State);

  203   uintptr_t getSectionHeaderTableAddress() const;
  204   uintptr_t getEndOfSymbolTableAddress() const;
  232   void checkSectionAddress(uintptr_t Addr, uintptr_t TableAddr) const;
  232   void checkSectionAddress(uintptr_t Addr, uintptr_t TableAddr) const;
  312   uint32_t getSymbolIndex(uintptr_t SymEntPtr) const;
  326   void checkSymbolEntryPointer(uintptr_t SymbolEntPtr) const;

  184 inline uintptr_t alignAddr(const void *Addr, Align Alignment) {
  185   uintptr_t ArithAddr = reinterpret_cast<uintptr_t>(Addr);

  250       uintptr_t AlignedAddr = alignAddr(NewSlab, Alignment);
  260     uintptr_t AlignedAddr = alignAddr(CurPtr, Alignment);

   70   using Key = uintptr_t;

  104   static inline void *getAsVoidPointer(uintptr_t P) {
  107   static inline uintptr_t getFromVoidPointer(void *P) {

  104   using Key = uintptr_t;

   69 typedef uintptr_t _Unwind_Word;
   71 typedef uintptr_t _Unwind_Ptr;
   72 typedef uintptr_t _Unwind_Internal_Ptr;
   76 typedef uintptr_t _uleb128_t;

  715 void MachineFunction::tidyLandingPads(DenseMap<MCSymbol *, uintptr_t> *LPMap,

  328   uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
  332   uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
  362   uintptr_t Size, unsigned Alignment, unsigned SectionID,
  369   uintptr_t Size, unsigned Alignment, unsigned SectionID,

   67     uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
   77     uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
   86     void reserveAllocationSpace(uintptr_t CodeSize, uint32_t CodeAlign,
   87                                 uintptr_t RODataSize, uint32_t RODataAlign,
   88                                 uintptr_t RWDataSize,

  805   uintptr_t Allocate;

  763   uintptr_t PtrSizedAddr = static_cast<uintptr_t>(SrcAddr);

 1620     uintptr_t StubAddress;
 1628       uintptr_t BaseAddress = uintptr_t(Section.getAddress());
 1629       uintptr_t StubAlignment = getStubAlignment();
 1674         uintptr_t StubAddress;
 1682           uintptr_t BaseAddress = uintptr_t(Section.getAddress());
 1683           uintptr_t StubAlignment = getStubAlignment();

   64   uintptr_t StubOffset;
   72   uintptr_t ObjAddress;
   76                size_t allocationSize, uintptr_t objAddress)
  106   uintptr_t getStubOffset() const { return StubOffset; }
  113   uintptr_t getObjAddress() const { return ObjAddress; }
  287   typedef std::map<RelocationValueRef, uintptr_t> StubMap;

   63     uintptr_t ObjTarget = AddendSection.getObjAddress() + Offset;

   85     uintptr_t ObjTarget = AddendSection.getObjAddress() + Offset;

  147     uintptr_t StubOffset;
  212     uintptr_t ObjTarget = Section.getObjAddress() + Offset;

  455       uintptr_t BaseAddress = uintptr_t(Section.getAddress());
  456       uintptr_t StubAlignment = getStubAlignment();
  457       uintptr_t StubAddress =

   21 uint8_t *SectionMemoryManager::allocateDataSection(uintptr_t Size,
   33 uint8_t *SectionMemoryManager::allocateCodeSection(uintptr_t Size,
   42     SectionMemoryManager::AllocationPurpose Purpose, uintptr_t Size,
   49   uintptr_t RequiredSize = Alignment * ((Size + Alignment - 1) / Alignment + 1);
   50   uintptr_t Addr = 0;
   69       uintptr_t EndOfBlock = Addr + FreeMB.Free.allocatedSize();
  118   uintptr_t EndOfBlock = Addr + MB.allocatedSize();

   90     uintptr_t Value = Sig.State;

   60   uintptr_t Addr = uintptr_t(Ptr);
  109   uintptr_t Offset = uintptr_t(Addr) - uintptr_t(base());
  109   uintptr_t Offset = uintptr_t(Addr) - uintptr_t(base());
  126   uintptr_t Offset = uintptr_t(Addr) - uintptr_t(SectionTable);
  332   uintptr_t Offset =
  449 std::error_code COFFObjectFile::getVaPtr(uint64_t Addr, uintptr_t &Res) const {
  457 std::error_code COFFObjectFile::getRvaPtr(uint32_t Addr, uintptr_t &Res) const {
  482       uintptr_t Begin =
  496   uintptr_t IntPtr = 0;
  552   uintptr_t IntPtr = 0;
  574   uintptr_t IntPtr = 0;
  595   uintptr_t IntPtr = 0;
  610   uintptr_t IntPtr = 0;
  636   uintptr_t IntPtr = 0;
  656   uintptr_t IntPtr = 0;
 1031     uintptr_t Offset = uintptr_t(Aux) - uintptr_t(base());
 1045   uintptr_t Offset =
 1108   uintptr_t ConStart = uintptr_t(base()) + Sec->PointerToRawData;
 1314                            uintptr_t Ptr, int Index) {
 1325   uintptr_t IntPtr = 0;
 1332   uintptr_t IntPtr = 0;
 1381   uintptr_t IntPtr = 0;
 1428   uintptr_t IntPtr = 0;
 1445   uintptr_t IntPtr = 0;
 1467   uintptr_t IntPtr = 0;
 1490   uintptr_t IntPtr = 0;
 1504   uintptr_t IntPtr = 0;
 1546   uintptr_t IntPtr = 0;
 1576   uintptr_t IntPtr = 0;
 1615   uintptr_t IntPtr = 0;

   96   uintptr_t CommandAddr = reinterpret_cast<uintptr_t>(L.Ptr);
  104   uintptr_t SectionAddr = CommandAddr + SegmentLoadSize + Sec * SectionSize;

   27   uintptr_t Addr = uintptr_t(Ptr);
   33 static uintptr_t getWithOffset(uintptr_t Base, ptrdiff_t Offset) {
   33 static uintptr_t getWithOffset(uintptr_t Base, ptrdiff_t Offset) {
   38 template <typename T> static const T *viewAs(uintptr_t in) {
   63 void XCOFFObjectFile::checkSectionAddress(uintptr_t Addr,
   64                                           uintptr_t TableAddress) const {
   68   uintptr_t Offset = Addr - TableAddress;
  479 uintptr_t XCOFFObjectFile::getEndOfSymbolTableAddress() const {
  487 void XCOFFObjectFile::checkSymbolEntryPointer(uintptr_t SymbolEntPtr) const {
  502 uint32_t XCOFFObjectFile::getSymbolIndex(uintptr_t SymbolEntPtr) const {
  529 uintptr_t XCOFFObjectFile::getSectionHeaderTableAddress() const {
  577   uintptr_t RelocAddr = getWithOffset(reinterpret_cast<uintptr_t>(FileHeader),
  714   uintptr_t AuxAddr = getWithOffset(

   56   static_assert(sizeof(uintptr_t) <= sizeof(unsigned long long),

  118   uintptr_t Start = NearBlock ? reinterpret_cast<uintptr_t>(NearBlock->base()) +
  187   uintptr_t Start = alignAddr((const uint8_t *)M.Address - PageSize.value() + 1, PageSize);
  188   uintptr_t End = alignAddr((const uint8_t *)M.Address + M.AllocatedSize, PageSize);

  484     uintptr_t P1 = uintptr_t(N1), P2 = uintptr_t(N2);

  378   uintptr_t A = reinterpret_cast<uintptr_t>(P);
  380     uintptr_t B = reinterpret_cast<uintptr_t>(Blocks[i]);

  126 static const uintptr_t kCurrentStackFrameMagic = 0x41B58AB3;
  127 static const uintptr_t kRetiredStackFrameMagic = 0x45E0360E;

 4749 static uintptr_t MapCaseToResult(ConstantInt *CaseVal,
 4787     const uintptr_t NumCasesForResult =

  114 extern uintptr_t __xray_function_address(int32_t FuncId);

   37   uintptr_t skip_destructor_rounds;
   38   uintptr_t size; // number of elements in the 'data' array
  263     uintptr_t i;
  283     uintptr_t index; // data[index-1] is the object address
  313 static __inline uintptr_t emutls_get_index(__emutls_control *control) {
  314   uintptr_t index = __atomic_load_n(&control->object.index, __ATOMIC_ACQUIRE);
  330                                                  uintptr_t size) {
  339 static __inline uintptr_t emutls_new_data_array_size(uintptr_t index) {
  339 static __inline uintptr_t emutls_new_data_array_size(uintptr_t index) {
  343   uintptr_t header_words = sizeof(emutls_address_array) / sizeof(void *);
  349 static __inline uintptr_t emutls_asize(uintptr_t N) {
  349 static __inline uintptr_t emutls_asize(uintptr_t N) {
  356 emutls_get_address_array(uintptr_t index) {
  359     uintptr_t new_size = emutls_new_data_array_size(index);
  367     uintptr_t orig_size = array->size;
  368     uintptr_t new_size = emutls_new_data_array_size(index);
  379   uintptr_t index = emutls_get_index(control);

   56   const uintptr_t pageSize = sysconf(_SC_PAGESIZE);
   59   const uintptr_t pageAlignMask = ~(pageSize - 1);
   60   uintptr_t p = (uintptr_t)addr;

   46 static uintptr_t readULEB128(const uint8_t **data) {
   47   uintptr_t result = 0;
   48   uintptr_t shift = 0;
   61 static uintptr_t readEncodedPointer(const uint8_t **data, uint8_t encoding) {
   63   uintptr_t result = 0;
   72     p += sizeof(uintptr_t);
  193   uintptr_t pc = (uintptr_t)_Unwind_GetIP(context) - 1;
  194   uintptr_t funcStart = (uintptr_t)_Unwind_GetRegionStart(context);
  195   uintptr_t pcOffset = pc - funcStart;
  213     uintptr_t start = readEncodedPointer(&p, callSiteEncoding);
  214     uintptr_t length = readEncodedPointer(&p, callSiteEncoding);
  215     uintptr_t landingPad = readEncodedPointer(&p, callSiteEncoding);

   27 ATTRIBUTES_INTERFACE_TLS_INITIAL_EXEC uintptr_t __sancov_lowest_stack;
   70 void TracePC::HandlePCsInit(const uintptr_t *Start, const uintptr_t *Stop) {
   70 void TracePC::HandlePCsInit(const uintptr_t *Start, const uintptr_t *Stop) {
  111 void TracePC::HandleCallerCallee(uintptr_t Caller, uintptr_t Callee) {
  111 void TracePC::HandleCallerCallee(uintptr_t Caller, uintptr_t Callee) {
  112   const uintptr_t kBits = 12;
  113   const uintptr_t kMask = (1 << kBits) - 1;
  114   uintptr_t Idx = (Caller & kMask) | ((Callee & kMask) << kBits);
  120 inline ALWAYS_INLINE uintptr_t GetPreviousInstructionPc(uintptr_t PC) {
  120 inline ALWAYS_INLINE uintptr_t GetPreviousInstructionPc(uintptr_t PC) {
  138 ALWAYS_INLINE uintptr_t TracePC::GetNextInstructionPc(uintptr_t PC) {
  138 ALWAYS_INLINE uintptr_t TracePC::GetNextInstructionPc(uintptr_t PC) {
  191 uintptr_t TracePC::PCTableEntryIdx(const PCTableEntry *TE) {
  203 const TracePC::PCTableEntry *TracePC::PCTableEntryByIdx(uintptr_t Idx) {
  350 void TracePC::HandleCmp(uintptr_t PC, T Arg1, T Arg2) {
  389 uintptr_t TracePC::GetMaxStackOffset() const {
  434 void __sanitizer_cov_pcs_init(const uintptr_t *pcs_beg,
  435                               const uintptr_t *pcs_end) {
  441 void __sanitizer_cov_trace_pc_indir(uintptr_t Callee) {
  442   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());
  450   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());
  461   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());
  469   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());
  477   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());
  485   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());
  493   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());
  501   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());
  509   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());
  528   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());
  564   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());
  572   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());
  579 void __sanitizer_cov_trace_gep(uintptr_t Idx) {
  580   uintptr_t PC = reinterpret_cast<uintptr_t>(GET_CALLER_PC());

   73   void HandlePCsInit(const uintptr_t *Start, const uintptr_t *Stop);
   73   void HandlePCsInit(const uintptr_t *Start, const uintptr_t *Stop);
   74   void HandleCallerCallee(uintptr_t Caller, uintptr_t Callee);
   74   void HandleCallerCallee(uintptr_t Caller, uintptr_t Callee);
   75   template <class T> void HandleCmp(uintptr_t PC, T Arg1, T Arg2);
  111   uintptr_t GetMaxStackOffset() const;
  123     uintptr_t PC, PCFlags;
  126   uintptr_t PCTableEntryIdx(const PCTableEntry *TE);
  127   const PCTableEntry *PCTableEntryByIdx(uintptr_t Idx);
  128   static uintptr_t GetNextInstructionPc(uintptr_t PC);
  128   static uintptr_t GetNextInstructionPc(uintptr_t PC);
  178   uintptr_t InitialStack;
  186   typedef uintptr_t LargeType;

  195 void PrintPC(const char *SymbolizedFMT, const char *FallbackFMT, uintptr_t PC) {

   40 void PrintPC(const char *SymbolizedFMT, const char *FallbackFMT, uintptr_t PC);
   92   uintptr_t X = reinterpret_cast<uintptr_t>(P);
   98   uintptr_t X = reinterpret_cast<uintptr_t>(P);

   22   static const size_t kBitsInWord = (sizeof(uintptr_t) * 8);
   32   inline bool AddValue(uintptr_t Value) {
   33     uintptr_t Idx = Value % kMapSizeInBits;
   34     uintptr_t WordIdx = Idx / kBitsInWord;
   35     uintptr_t BitIdx = Idx % kBitsInWord;
   36     uintptr_t Old = Map[WordIdx];
   37     uintptr_t New = Old | (1ULL << BitIdx);
   43   inline bool AddValueModPrime(uintptr_t Value) {
   47   inline bool Get(uintptr_t Idx) {
   49     uintptr_t WordIdx = Idx / kBitsInWord;
   50     uintptr_t BitIdx = Idx % kBitsInWord;
   60       if (uintptr_t M = Map[i])
   67   ATTRIBUTE_ALIGNED(512) uintptr_t Map[kMapSizeInWords];

   47 void defaultPrintStackTrace(uintptr_t *Trace, size_t TraceLength,
   64     uintptr_t AllocAddr, size_t AllocSize, options::Backtrace_t Backtrace) {
   77     uintptr_t UncompressedBuffer[kMaxTraceLengthToCollect];
   95     uintptr_t UncompressedBuffer[kMaxTraceLengthToCollect];
  204   uintptr_t Ptr = slotToAddr(Index);
  220   uintptr_t UPtr = reinterpret_cast<uintptr_t>(Ptr);
  221   uintptr_t SlotStart = slotToAddr(addrToSlot(UPtr));
  261 AllocationMetadata *GuardedPoolAllocator::addrToMetadata(uintptr_t Ptr) const {
  265 size_t GuardedPoolAllocator::addrToSlot(uintptr_t Ptr) const {
  271 uintptr_t GuardedPoolAllocator::slotToAddr(size_t N) const {
  275 uintptr_t GuardedPoolAllocator::getPageAddr(uintptr_t Ptr) const {
  275 uintptr_t GuardedPoolAllocator::getPageAddr(uintptr_t Ptr) const {
  280 bool GuardedPoolAllocator::isGuardPage(uintptr_t Ptr) const {
  307 uintptr_t GuardedPoolAllocator::allocationSlotOffset(size_t Size) const {
  314   uintptr_t Offset = maximumAllocationSize();
  327 void GuardedPoolAllocator::reportError(uintptr_t AccessPtr, Error E) {
  332 size_t GuardedPoolAllocator::getNearestSlot(uintptr_t Ptr) const {
  346 Error GuardedPoolAllocator::diagnoseUnknownError(uintptr_t AccessPtr,
  378 void printErrorType(Error E, uintptr_t AccessPtr, AllocationMetadata *Meta,
  444 void printAllocDeallocTraces(uintptr_t AccessPtr, AllocationMetadata *Meta,
  457     uintptr_t UncompressedTrace[AllocationMetadata::kMaxTraceLengthToCollect];
  472   uintptr_t UncompressedTrace[AllocationMetadata::kMaxTraceLengthToCollect];
  487 void GuardedPoolAllocator::reportErrorInternal(uintptr_t AccessPtr, Error E) {
  518     uintptr_t Trace[kMaximumStackFramesForCrashTrace];

   54     void RecordAllocation(uintptr_t Addr, size_t Size,
   71     uintptr_t Addr = 0;
  116     uintptr_t P = reinterpret_cast<uintptr_t>(Ptr);
  142   static void reportError(uintptr_t AccessPtr, Error E = Error::UNKNOWN);
  175   size_t addrToSlot(uintptr_t Ptr) const;
  178   uintptr_t slotToAddr(size_t N) const;
  182   AllocationMetadata *addrToMetadata(uintptr_t Ptr) const;
  185   uintptr_t getPageAddr(uintptr_t Ptr) const;
  185   uintptr_t getPageAddr(uintptr_t Ptr) const;
  188   size_t getNearestSlot(uintptr_t Ptr) const;
  192   bool isGuardPage(uintptr_t Ptr) const;
  204   uintptr_t allocationSlotOffset(size_t AllocationSize) const;
  209   Error diagnoseUnknownError(uintptr_t AccessPtr, AllocationMetadata **Meta);
  211   void reportErrorInternal(uintptr_t AccessPtr, Error E);
  226   uintptr_t GuardedPagePool = UINTPTR_MAX;
  227   uintptr_t GuardedPagePoolEnd = 0;

   20 size_t Backtrace(uintptr_t *TraceBuffer, size_t Size) {
   21   static_assert(sizeof(uintptr_t) == sizeof(void *), "uintptr_t is not void*");
   26 static void PrintBacktrace(uintptr_t *Trace, size_t TraceLength,

   32 size_t Backtrace(uintptr_t *TraceBuffer, size_t Size) {
   43   memcpy(TraceBuffer, Trace.trace, Trace.size * sizeof(uintptr_t));
   47 static void PrintBacktrace(uintptr_t *Trace, size_t TraceLength,

   51 typedef size_t (*Backtrace_t)(uintptr_t *TraceBuffer, size_t Size);
   72 typedef void (*PrintBacktrace_t)(uintptr_t *TraceBuffer, size_t TraceLength,

   17 size_t varIntEncode(uintptr_t Value, uint8_t *Out, size_t OutLen) {
   35 size_t varIntDecode(const uint8_t *In, size_t InLen, uintptr_t *Out) {
   48     if (Shift >= sizeof(uintptr_t) * 8)
   54 uintptr_t zigzagEncode(uintptr_t Value) {
   54 uintptr_t zigzagEncode(uintptr_t Value) {
   55   uintptr_t Encoded = Value << 1;
   61 uintptr_t zigzagDecode(uintptr_t Value) {
   61 uintptr_t zigzagDecode(uintptr_t Value) {
   62   uintptr_t Decoded = Value >> 1;
   69 size_t pack(const uintptr_t *Unpacked, size_t UnpackedSize, uint8_t *Packed,
   73     uintptr_t Diff = Unpacked[CurrentDepth];
   87 size_t unpack(const uint8_t *Packed, size_t PackedSize, uintptr_t *Unpacked,
   92     uintptr_t EncodedDiff;

   26 size_t pack(const uintptr_t *Unpacked, size_t UnpackedSize, uint8_t *Packed,
   32 size_t unpack(const uint8_t *Packed, size_t PackedSize, uintptr_t *Unpacked,

   24   uintptr_t caller = reinterpret_cast<uintptr_t>(caller_p);
   32       uintptr_t p;

  463 uintptr_t __xray_function_address(int32_t FuncId) XRAY_NEVER_INSTRUMENT {

   79 constexpr ptrdiff_t diff(uintptr_t A, uintptr_t B) {
   79 constexpr ptrdiff_t diff(uintptr_t A, uintptr_t B) {

   98   uintptr_t hp = (uintptr_t)HstPtrBegin;
  119   uintptr_t hp = (uintptr_t)HstPtrBegin;
  179     uintptr_t tp = HT.TgtPtrBegin + ((uintptr_t)HstPtrBegin - HT.HstPtrBegin);
  205       uintptr_t tp = (uintptr_t)RTL->data_alloc(RTLDeviceID, Size, HstPtrBegin);
  237     uintptr_t tp = HT.TgtPtrBegin + ((uintptr_t)HstPtrBegin - HT.HstPtrBegin);
  261   uintptr_t hp = (uintptr_t)HstPtrBegin;
  265     uintptr_t tp = HT.TgtPtrBegin + (hp - HT.HstPtrBegin);

   33   uintptr_t HstPtrBase; // host info.
   34   uintptr_t HstPtrBegin;
   35   uintptr_t HstPtrEnd; // non-inclusive.
   37   uintptr_t TgtPtrBegin; // target info.
   44   HostDataToTargetTy(uintptr_t BP, uintptr_t B, uintptr_t E, uintptr_t TB)
   44   HostDataToTargetTy(uintptr_t BP, uintptr_t B, uintptr_t E, uintptr_t TB)
   44   HostDataToTargetTy(uintptr_t BP, uintptr_t B, uintptr_t E, uintptr_t TB)
   44   HostDataToTargetTy(uintptr_t BP, uintptr_t B, uintptr_t E, uintptr_t TB)
   47   HostDataToTargetTy(uintptr_t BP, uintptr_t B, uintptr_t E, uintptr_t TB,
   47   HostDataToTargetTy(uintptr_t BP, uintptr_t B, uintptr_t E, uintptr_t TB,
   47   HostDataToTargetTy(uintptr_t BP, uintptr_t B, uintptr_t E, uintptr_t TB,
   47   HostDataToTargetTy(uintptr_t BP, uintptr_t B, uintptr_t E, uintptr_t TB,

  289       uintptr_t Delta = (uintptr_t)HstPtrBegin - (uintptr_t)HstPtrBase;
  430       uintptr_t lb = (uintptr_t) HstPtrBegin;
  431       uintptr_t ub = (uintptr_t) HstPtrBegin + data_size;
  513       uintptr_t lb = (uintptr_t) HstPtrBegin;
  514       uintptr_t ub = (uintptr_t) HstPtrBegin + MapSize;
  540       uintptr_t lb = (uintptr_t) HstPtrBegin;
  541       uintptr_t ub = (uintptr_t) HstPtrBegin + MapSize;

  872 typedef uintptr_t omp_uintptr_t;
 3755                                            void **user_lock, uintptr_t hint);
 3758                                                 uintptr_t hint);

 1256 static __forceinline kmp_dyna_lockseq_t __kmp_map_hint_to_lock(uintptr_t hint) {
 2204                                 uintptr_t hint) {
 2228                                      void **user_lock, uintptr_t hint) {

 1020                                          uintptr_t KMP_DEREF hint) {
 1033                                               uintptr_t KMP_DEREF hint) {

  196     static_assert(sizeof(uintptr_t) <= sizeof(uint64_t),

  107   void addLazyDecl(ASTContext &C, uintptr_t ID, AccessSpecifier AS) {

   30   uintptr_t Ptr; // we'd use llvm::PointerUnion, but it isn't trivial

  254   uintptr_t Ptr = 0;
  263     uintptr_t PAsInteger = reinterpret_cast<uintptr_t>(P);
  417   uintptr_t getAsOpaqueInteger() const { return Ptr; }
  431   static DeclarationName getFromOpaqueInteger(uintptr_t P) {

 2168   uintptr_t Data;
 4657     uintptr_t NameOrField;

  956   uintptr_t SelectorOrMethod = 0;

   40   uintptr_t RawVAPtr = 0;

  129     uintptr_t V;

  201   VTableComponent(Kind ComponentKind, uintptr_t Ptr) {
  217   uintptr_t getPointer() const {

  757   uintptr_t x =
  763   uintptr_t x =

  690   uintptr_t InfoPtr = 0;
  727   explicit Selector(uintptr_t V) : InfoPtr(V) {}

   83     uintptr_t Ptr = 0;

  187     uintptr_t Parameter;
  198     uintptr_t Base;

  958     llvm::SmallPtrSet<uintptr_t, 16> Functions;
 1020       uintptr_t Key = reinterpret_cast<uintptr_t>(F->getCanonicalDecl());

  188     uintptr_t PtrWithInvalid;

  128         uintptr_t v = reinterpret_cast<uintptr_t>(T.getAsOpaquePtr());

  257   const std::pair<SVal, uintptr_t>&
  258   getPersistentSValWithData(const SVal& V, uintptr_t Data);

   88     uintptr_t P;

  413   explicit LocAsInteger(const std::pair<SVal, uintptr_t> &data)
  424     const std::pair<SVal, uintptr_t> *D =
  430     const std::pair<SVal, uintptr_t> *D =
  437     const std::pair<SVal, uintptr_t> *D =

   35   using AddrTy = uintptr_t;

   39   using AddrTy = uintptr_t;

  148   return S.getLocation(Caller->Func, RetPC - sizeof(uintptr_t));

   69     auto Punned = endian::read<uintptr_t, endianness::native, 1>(Ptr);

  379   llvm::DenseMap<uintptr_t, unsigned> Substitutions;
  436   bool mangleSubstitution(uintptr_t Ptr);
  449   void addSubstitution(uintptr_t Ptr);
 4689   uintptr_t TypePtr = reinterpret_cast<uintptr_t>(T.getAsOpaquePtr());
 4703 bool CXXNameMangler::mangleSubstitution(uintptr_t Ptr) {
 4704   llvm::DenseMap<uintptr_t, unsigned>::iterator I = Substitutions.find(Ptr);
 4855   uintptr_t TypePtr = reinterpret_cast<uintptr_t>(T.getAsOpaquePtr());
 4867 void CXXNameMangler::addSubstitution(uintptr_t Ptr) {

  161     uintptr_t Data;

   67     enum class SpecialKind : uintptr_t {

 5555   uintptr_t PtrInt = reinterpret_cast<uintptr_t>(Ptr);

  734   uintptr_t Value = reinterpret_cast<uintptr_t>(Tok.getAnnotationValue());

  168   llvm::DenseMap<std::pair<DeclContext *, /*Name*/uintptr_t>, ShadowMapEntry>

   51 using SValData = std::pair<SVal, uintptr_t>;
  299 const std::pair<SVal, uintptr_t>&
  300 BasicValueFactory::getPersistentSValWithData(const SVal& V, uintptr_t Data) {

   93   uintptr_t V = (uintptr_t) DLoc;
  166   uintptr_t V = (uintptr_t) location.ptr_data[0];

  890       uintptr_t index = 0;
  895       uintptr_t index = _references.size();
  900       uintptr_t index = reinterpret_cast<uintptr_t>(it);
  905       uintptr_t index = reinterpret_cast<uintptr_t>(it);

  185   typedef std::pair<lldb::addr_t, uintptr_t> AddrRange;
  260     uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
  280     uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
  344     uintptr_t m_host_address;
  351     AllocationRecord(uintptr_t host_address, uint32_t permissions,

   28   uintptr_t default_uint_value;

  457     DoRegister(uintptr_t(f), std::make_unique<DefaultReplayer<Signature>>(f),
  467     DoRegister(uintptr_t(f), std::make_unique<DefaultReplayer<Signature>>(g),
  478   unsigned GetID(uintptr_t addr);
  482   void DoRegister(uintptr_t RunID, std::unique_ptr<Replayer> replayer,
  490   std::map<uintptr_t, std::pair<std::unique_ptr<Replayer>, unsigned>>
  642     unsigned id = registry.GetID(uintptr_t(f));
  668     unsigned id = registry.GetID(uintptr_t(f));

   63   const uintptr_t rhs_value =
   82     const uintptr_t rhs_value =

  588     uintptr_t Size, unsigned Alignment, unsigned SectionID,
  618     uintptr_t Size, unsigned Alignment, unsigned SectionID,

   37   typedef uintptr_t ModuleID;

  146     uintptr_t ptr = constant_int->getZExtValue();
 1090   uintptr_t ptr = constant_int->getZExtValue();

  171   uintptr_t MemoryAddr =

 2360   uintptr_t slot = (ptr >> m_objc_debug_taggedpointer_slot_shift) &
 2368     uintptr_t slot_ptr = slot * process->GetAddressByteSize() +
 2371     uintptr_t slot_data = process->ReadPointerFromMemory(slot_ptr, error);
 2448   uintptr_t slot = (ptr >> m_objc_debug_taggedpointer_ext_slot_shift) &
 2456     uintptr_t slot_ptr = slot * process->GetAddressByteSize() +
 2459     uintptr_t slot_data = process->ReadPointerFromMemory(slot_ptr, error);
 2535       uintptr_t index = (isa & m_objc_debug_indexed_isa_index_mask) >>

   66 void Registry::DoRegister(uintptr_t RunID, std::unique_ptr<Replayer> replayer,
   75 unsigned Registry::GetID(uintptr_t addr) {

   90   uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
   96   uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
  103   void reserveAllocationSpace(uintptr_t CodeSize, uint32_t CodeAlign,
  104                               uintptr_t RODataSize, uint32_t RODataAlign,
  105                               uintptr_t RWDataSize,

   39       uintptr_t Val = static_cast<uintptr_t>(-1);
   43       uintptr_t Val = static_cast<uintptr_t>(-2);

  271   explicit TrackingSectionMemoryManager(uintptr_t *CodeSize)
  274   uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
  283   uintptr_t *const CodeSize = nullptr;
  296   uintptr_t CodeSize = 0;

  237   uintptr_t IntPtr = 0;
  284   uintptr_t IntPtr = 0;
  315   uintptr_t IntPtr = 0;
  541   uintptr_t addr;

  752   uintptr_t TableStart, TableEnd;
  759   for (uintptr_t I = TableStart; I < TableEnd; I += EntrySize) {

  201   uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
  204   uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
  260   uint8_t *allocateFromSlab(uintptr_t Size, unsigned Alignment, bool isCode,
  266     uintptr_t OldSlabOffset = CurrentSlabOffset;
  280   uintptr_t SlabSize = 0;
  281   uintptr_t CurrentSlabOffset = 0;
  285 uint8_t *TrivialMemoryManager::allocateCodeSection(uintptr_t Size,
  312 uint8_t *TrivialMemoryManager::allocateDataSection(uintptr_t Size,

   75 typedef uintptr_t isl_sioimath;

   64   uintptr_t addr = reinterpret_cast<uintptr_t>(&y);

   50   PointerEmbeddedInt<uintptr_t, CHAR_BIT> U = 42, USaturated = 255;
   60   PointerEmbeddedInt<uintptr_t, std::numeric_limits<uintptr_t>::digits - 1>
   60   PointerEmbeddedInt<uintptr_t, std::numeric_limits<uintptr_t>::digits - 1>
   61       UMax = std::numeric_limits<uintptr_t>::max() >> 1,
   62       UMin = std::numeric_limits<uintptr_t>::min() >> 1;
   72   PointerEmbeddedInt<uintptr_t, std::numeric_limits<uintptr_t>::digits - 1>
   72   PointerEmbeddedInt<uintptr_t, std::numeric_limits<uintptr_t>::digits - 1>
   73       Max = std::numeric_limits<uintptr_t>::max() >> 1;

   78     uintptr_t Value;
   89     enum { NumLowBitsAvailable = std::numeric_limits<uintptr_t>::digits - 31 };

   32 static uint8_t *roundTripAllocateCodeSection(void *object, uintptr_t size,
   41 static uint8_t *roundTripAllocateDataSection(void *object, uintptr_t size,
   76   uintptr_t ReservedCodeSize;
   77   uintptr_t UsedCodeSize;
   78   uintptr_t ReservedDataSizeRO;
   79   uintptr_t UsedDataSizeRO;
   80   uintptr_t ReservedDataSizeRW;
   81   uintptr_t UsedDataSizeRW;
   90   void reserveAllocationSpace(uintptr_t CodeSize, uint32_t CodeAlign,
   91                               uintptr_t DataSizeRO, uint32_t RODataAlign,
   92                               uintptr_t DataSizeRW,
   99   void useSpace(uintptr_t* UsedSize, uintptr_t Size, unsigned Alignment) {
   99   void useSpace(uintptr_t* UsedSize, uintptr_t Size, unsigned Alignment) {
  100     uintptr_t AlignedSize = (Size + Alignment - 1) / Alignment * Alignment;
  101     uintptr_t AlignedBegin = (*UsedSize + Alignment - 1) / Alignment * Alignment;
  105   uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
  113   uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,

  124     uintptr_t CodeSize = i % 16 + 1;
  125     uintptr_t DataSize = i % 8 + 1;
  145     uintptr_t CodeAlign = Align ? (uintptr_t)code[i] % Align : 0;
  146     uintptr_t DataAlign = Align ? (uintptr_t)data[i] % Align : 0;
  153     uintptr_t CodeSize = i % 16 + 1;
  154     uintptr_t DataSize = i % 8 + 1;

   51     uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,

  272     uint8_t *allocateCodeSection(uintptr_t, unsigned, unsigned,
  276     uint8_t *allocateDataSection(uintptr_t, unsigned, unsigned, llvm::StringRef,

   37     uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,

  386       reinterpret_cast<const void *>(std::numeric_limits<uintptr_t>::max() - 1);

   85   uintptr_t a;

   23   static_assert(detail::IsPointerLike<uintptr_t>::value,

  995   typedef atomic<uintptr_t>		atomic_uintptr_t;

  176 extern void la_activity (uintptr_t *__cookie, unsigned int __flag);
  177 extern char *la_objsearch (const char *__name, uintptr_t *__cookie,
  180 				uintptr_t *__cookie);
  181 extern void la_preinit (uintptr_t *__cookie);
  182 extern uintptr_t la_symbind32 (Elf32_Sym *__sym, unsigned int __ndx,
  183 			       uintptr_t *__refcook, uintptr_t *__defcook,
  183 			       uintptr_t *__refcook, uintptr_t *__defcook,
  185 extern uintptr_t la_symbind64 (Elf64_Sym *__sym, unsigned int __ndx,
  186 			       uintptr_t *__refcook, uintptr_t *__defcook,
  186 			       uintptr_t *__refcook, uintptr_t *__defcook,
  188 extern unsigned int la_objclose (uintptr_t *__cookie);

  159 typedef uintptr_t       Py_uintptr_t;

  127 					  uintptr_t *__refcook,
  128 					  uintptr_t *__defcook,
  135 					   uintptr_t *__refcook,
  136 					   uintptr_t *__defcook,
  143 				       uintptr_t *__refcook,
  144 				       uintptr_t *__defcook,
  151 					uintptr_t *__refcook,
  152 					uintptr_t *__defcook,

  226     using CPUMask = std::bitset<sizeof(std::uintptr_t) * CHAR_BIT>;