// Populates the FileHeader reference by reading the first 32 bytes of the file. Error readBinaryFormatHeader(StringRef Data, XRayFileHeader &FileHeader) { // FIXME: Maybe deduce whether the data is little or big-endian using some // magic bytes in the beginning of the file? // First 32 bytes of the file will always be the header. We assume a certain // format here: // // (2) uint16 : version // (2) uint16 : type // (4) uint32 : bitfield // (8) uint64 : cycle frequency // (16) - : padding DataExtractor HeaderExtractor(Data, true, 8); uint32_t OffsetPtr = 0; FileHeader.Version = HeaderExtractor.getU16(&OffsetPtr); FileHeader.Type = HeaderExtractor.getU16(&OffsetPtr); uint32_t Bitfield = HeaderExtractor.getU32(&OffsetPtr); FileHeader.ConstantTSC = Bitfield & 1uL; FileHeader.NonstopTSC = Bitfield & 1uL << 1; FileHeader.CycleFrequency = HeaderExtractor.getU64(&OffsetPtr); std::memcpy(&FileHeader.FreeFormData, Data.bytes_begin() + OffsetPtr, 16); if (FileHeader.Version != 1) return make_error<StringError>( Twine("Unsupported XRay file version: ") + Twine(FileHeader.Version), std::make_error_code(std::errc::invalid_argument)); return Error::success(); }
static bool isIntrinsicSourceOfDivergence(const TargetIntrinsicInfo *TII, const IntrinsicInst *I) { switch (I->getIntrinsicID()) { default: return false; case Intrinsic::not_intrinsic: // This means we have an intrinsic that isn't defined in // IntrinsicsAMDGPU.td break; case Intrinsic::amdgcn_interp_p1: case Intrinsic::amdgcn_interp_p2: case Intrinsic::amdgcn_mbcnt_hi: case Intrinsic::amdgcn_mbcnt_lo: case Intrinsic::r600_read_tidig_x: case Intrinsic::r600_read_tidig_y: case Intrinsic::r600_read_tidig_z: return true; } StringRef Name = I->getCalledFunction()->getName(); switch (TII->lookupName((const char *)Name.bytes_begin(), Name.size())) { default: return false; case AMDGPUIntrinsic::SI_tid: case AMDGPUIntrinsic::SI_fs_interp: case AMDGPUIntrinsic::SI_fs_constant: return true; } }
static bool isIntrinsicSourceOfDivergence(const TargetIntrinsicInfo *TII, const IntrinsicInst *I) { switch (I->getIntrinsicID()) { default: return false; case Intrinsic::not_intrinsic: // This means we have an intrinsic that isn't defined in // IntrinsicsAMDGPU.td break; case Intrinsic::amdgcn_workitem_id_x: case Intrinsic::amdgcn_workitem_id_y: case Intrinsic::amdgcn_workitem_id_z: case Intrinsic::amdgcn_interp_p1: case Intrinsic::amdgcn_interp_p2: case Intrinsic::amdgcn_mbcnt_hi: case Intrinsic::amdgcn_mbcnt_lo: case Intrinsic::r600_read_tidig_x: case Intrinsic::r600_read_tidig_y: case Intrinsic::r600_read_tidig_z: case Intrinsic::amdgcn_image_atomic_swap: case Intrinsic::amdgcn_image_atomic_add: case Intrinsic::amdgcn_image_atomic_sub: case Intrinsic::amdgcn_image_atomic_smin: case Intrinsic::amdgcn_image_atomic_umin: case Intrinsic::amdgcn_image_atomic_smax: case Intrinsic::amdgcn_image_atomic_umax: case Intrinsic::amdgcn_image_atomic_and: case Intrinsic::amdgcn_image_atomic_or: case Intrinsic::amdgcn_image_atomic_xor: case Intrinsic::amdgcn_image_atomic_inc: case Intrinsic::amdgcn_image_atomic_dec: case Intrinsic::amdgcn_image_atomic_cmpswap: case Intrinsic::amdgcn_buffer_atomic_swap: case Intrinsic::amdgcn_buffer_atomic_add: case Intrinsic::amdgcn_buffer_atomic_sub: case Intrinsic::amdgcn_buffer_atomic_smin: case Intrinsic::amdgcn_buffer_atomic_umin: case Intrinsic::amdgcn_buffer_atomic_smax: case Intrinsic::amdgcn_buffer_atomic_umax: case Intrinsic::amdgcn_buffer_atomic_and: case Intrinsic::amdgcn_buffer_atomic_or: case Intrinsic::amdgcn_buffer_atomic_xor: case Intrinsic::amdgcn_buffer_atomic_cmpswap: return true; } StringRef Name = I->getCalledFunction()->getName(); switch (TII->lookupName((const char *)Name.bytes_begin(), Name.size())) { default: return false; case AMDGPUIntrinsic::SI_tid: case AMDGPUIntrinsic::SI_fs_interp: return true; } }
Error llvm::codeview::consume(ArrayRef<uint8_t> &Data, StringRef &Item) { if (Data.empty()) return make_error<CodeViewError>(cv_error_code::corrupt_record, "Null terminated string buffer is empty!"); StringRef Rest; std::tie(Item, Rest) = getBytesAsCharacters(Data).split('\0'); // We expect this to be null terminated. If it was not, it is an error. if (Data.size() == Item.size()) return make_error<CodeViewError>(cv_error_code::corrupt_record, "Expected null terminator!"); Data = ArrayRef<uint8_t>(Rest.bytes_begin(), Rest.bytes_end()); return Error::success(); }
static Error loadObj(StringRef Filename, object::OwningBinary<object::ObjectFile> &ObjFile, InstrumentationMap::SledContainer &Sleds, InstrumentationMap::FunctionAddressMap &FunctionAddresses, InstrumentationMap::FunctionAddressReverseMap &FunctionIds) { InstrumentationMap Map; // Find the section named "xray_instr_map". if ((!ObjFile.getBinary()->isELF() && !ObjFile.getBinary()->isMachO()) || !(ObjFile.getBinary()->getArch() == Triple::x86_64 || ObjFile.getBinary()->getArch() == Triple::ppc64le)) return make_error<StringError>( "File format not supported (only does ELF and Mach-O little endian 64-bit).", std::make_error_code(std::errc::not_supported)); StringRef Contents = ""; const auto &Sections = ObjFile.getBinary()->sections(); auto I = llvm::find_if(Sections, [&](object::SectionRef Section) { StringRef Name = ""; if (Section.getName(Name)) return false; return Name == "xray_instr_map"; }); if (I == Sections.end()) return make_error<StringError>( "Failed to find XRay instrumentation map.", std::make_error_code(std::errc::executable_format_error)); if (I->getContents(Contents)) return errorCodeToError( std::make_error_code(std::errc::executable_format_error)); RelocMap Relocs; if (ObjFile.getBinary()->isELF()) { uint32_t RelativeRelocation = [](object::ObjectFile *ObjFile) { if (const auto *ELFObj = dyn_cast<object::ELF32LEObjectFile>(ObjFile)) return ELFObj->getELFFile()->getRelativeRelocationType(); else if (const auto *ELFObj = dyn_cast<object::ELF32BEObjectFile>(ObjFile)) return ELFObj->getELFFile()->getRelativeRelocationType(); else if (const auto *ELFObj = dyn_cast<object::ELF64LEObjectFile>(ObjFile)) return ELFObj->getELFFile()->getRelativeRelocationType(); else if (const auto *ELFObj = dyn_cast<object::ELF64BEObjectFile>(ObjFile)) return ELFObj->getELFFile()->getRelativeRelocationType(); else return static_cast<uint32_t>(0); }(ObjFile.getBinary()); for (const object::SectionRef &Section : Sections) { for (const object::RelocationRef &Reloc : Section.relocations()) { if (Reloc.getType() != RelativeRelocation) continue; if (auto AddendOrErr = object::ELFRelocationRef(Reloc).getAddend()) Relocs.insert({Reloc.getOffset(), *AddendOrErr}); } } } // Copy the instrumentation map data into the Sleds data structure. auto C = Contents.bytes_begin(); static constexpr size_t ELF64SledEntrySize = 32; if ((C - Contents.bytes_end()) % ELF64SledEntrySize != 0) return make_error<StringError>( Twine("Instrumentation map entries not evenly divisible by size of " "an XRay sled entry in ELF64."), std::make_error_code(std::errc::executable_format_error)); auto RelocateOrElse = [&](uint32_t Offset, uint64_t Address) { if (!Address) { uint64_t A = I->getAddress() + C - Contents.bytes_begin() + Offset; RelocMap::const_iterator R = Relocs.find(A); if (R != Relocs.end()) return R->second; } return Address; }; int32_t FuncId = 1; uint64_t CurFn = 0; for (; C != Contents.bytes_end(); C += ELF64SledEntrySize) { DataExtractor Extractor( StringRef(reinterpret_cast<const char *>(C), ELF64SledEntrySize), true, 8); Sleds.push_back({}); auto &Entry = Sleds.back(); uint32_t OffsetPtr = 0; uint32_t AddrOff = OffsetPtr; Entry.Address = RelocateOrElse(AddrOff, Extractor.getU64(&OffsetPtr)); uint32_t FuncOff = OffsetPtr; Entry.Function = RelocateOrElse(FuncOff, Extractor.getU64(&OffsetPtr)); auto Kind = Extractor.getU8(&OffsetPtr); static constexpr SledEntry::FunctionKinds Kinds[] = { SledEntry::FunctionKinds::ENTRY, SledEntry::FunctionKinds::EXIT, SledEntry::FunctionKinds::TAIL, SledEntry::FunctionKinds::LOG_ARGS_ENTER, SledEntry::FunctionKinds::CUSTOM_EVENT}; if (Kind >= sizeof(Kinds)) return errorCodeToError( std::make_error_code(std::errc::executable_format_error)); Entry.Kind = Kinds[Kind]; Entry.AlwaysInstrument = Extractor.getU8(&OffsetPtr) != 0; // We do replicate the function id generation scheme implemented in the // XRay runtime. // FIXME: Figure out how to keep this consistent with the XRay runtime. if (CurFn == 0) { CurFn = Entry.Function; FunctionAddresses[FuncId] = Entry.Function; FunctionIds[Entry.Function] = FuncId; } if (Entry.Function != CurFn) { ++FuncId; CurFn = Entry.Function; FunctionAddresses[FuncId] = Entry.Function; FunctionIds[Entry.Function] = FuncId; } } return Error::success(); }
Error llvm::codeview::consume(StringRef &Data, uint32_t &Item) { ArrayRef<uint8_t> Bytes(Data.bytes_begin(), Data.bytes_end()); auto EC = consume(Bytes, Item); Data = StringRef(reinterpret_cast<const char *>(Bytes.data()), Bytes.size()); return EC; }
// Returns true if S encloses T. static bool encloses(StringRef S, StringRef T) { return S.bytes_begin() <= T.bytes_begin() && T.bytes_end() <= S.bytes_end(); }
Error BinaryStreamWriter::writeFixedString(StringRef Str) { return writeBytes(ArrayRef<uint8_t>(Str.bytes_begin(), Str.bytes_end())); }
BinaryStreamRef::BinaryStreamRef(StringRef Data, endianness Endian) : BinaryStreamRef(makeArrayRef(Data.bytes_begin(), Data.bytes_end()), Endian) {}