|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
References
include/llvm/DebugInfo/CodeView/SymbolSerializer.h 41 Prefix.RecordKind = Kind;
42 Prefix.RecordLen = 0;
include/llvm/DebugInfo/CodeView/TypeIndex.h 111 void setIndex(uint32_t I) { Index = I; }
include/llvm/DebugInfo/PDB/Native/HashTable.h 185 H.Size = size();
186 H.Capacity = capacity();
include/llvm/Object/COFF.h 729 void setNameOffset(uint32_t Offset) { NameOffset = Offset | (1 << 31); }
include/llvm/Object/ELFTypes.h 371 r_info = R;
421 r_info = (R >> 32) | ((R & 0xff000000) << 8) | ((R & 0x00ff0000) << 24) |
424 r_info = R;
include/llvm/Object/WindowsResource.h 75 TypeID = ID;
80 NameID = ID;
include/llvm/Support/Endian.h 215 explicit packed_endian_specific_integral(value_type val) { *this = val; }
228 *this = *this + newValue;
233 *this = *this - newValue;
238 *this = *this | newValue;
243 *this = *this & newValue;
394 *(detail::packed_endian_specific_integral<T, E, unaligned> *)P = V;
include/llvm/Support/SwapByteOrder.h 154 Value = getSwappedBytes(Value);
include/llvm/Support/Win64EH.h 140 *reinterpret_cast<support::ulittle32_t *>(getLanguageSpecificData()) =
include/llvm/Support/YAMLTraits.h 1287 E = V;
1302 E = V;
lib/CodeGen/AsmPrinter/CodeViewDebug.cpp 2662 DRHdr.Offset = Offset;
2672 DRHdr.Register = Reg;
2673 DRHdr.Flags = RegRelFlags;
2674 DRHdr.BasePointerOffset = Offset;
2681 DRHdr.Register = DefRange.CVRegister;
2682 DRHdr.MayHaveNoName = 0;
2683 DRHdr.OffsetInParent = DefRange.StructOffset;
2687 DRHdr.Register = DefRange.CVRegister;
2688 DRHdr.MayHaveNoName = 0;
lib/DebugInfo/CodeView/ContinuationRecordBuilder.cpp 14 SegmentInjection(TypeLeafKind Kind) { Prefix.RecordKind = Kind; }
159 Prefix->RecordLen = Data.size() - sizeof(RecordPrefix::RecordLen);
167 CR->IndexRef = RefersTo->getIndex();
lib/DebugInfo/CodeView/DebugChecksumsSubsection.cpp 99 Header.FileNameOffset = FC.FileNameOffset;
lib/DebugInfo/CodeView/DebugCrossImpSubsection.cpp 88 Imp.ModuleNameOffset = Strings.getIdForString(Item->getKey());
89 Imp.Count = Item->getValue().size();
lib/DebugInfo/CodeView/DebugInlineeLinesSubsection.cpp 122 Entry.Header.FileID = Offset;
123 Entry.Header.SourceLineNum = SourceLine;
lib/DebugInfo/CodeView/DebugLinesSubsection.cpp 84 LNE.Flags = Line.getRawData();
85 LNE.Offset = Offset;
98 CNE.StartColumn = ColStart;
99 CNE.EndColumn = ColEnd;
105 Header.CodeSize = CodeSize;
106 Header.Flags = hasColumnInfo() ? LF_HaveColumns : 0;
107 Header.RelocOffset = RelocOffset;
108 Header.RelocSegment = RelocSegment;
117 BlockHeader.NumLines = B.Lines.size();
118 BlockHeader.BlockSize = sizeof(LineBlockFragmentHeader);
122 BlockHeader.NameIndex = B.ChecksumBufferOffset;
lib/DebugInfo/CodeView/DebugSubsectionRecord.cpp 76 Header.Kind = uint32_t(Subsection ? Subsection->kind() : Contents.kind());
81 Header.Length = alignTo(DataSize, alignOf(Container));
lib/DebugInfo/CodeView/SimpleTypeSerializer.cpp 42 Prefix->RecordKind = CVT.kind();
43 Prefix->RecordLen = Writer.getOffset() - sizeof(uint16_t);
lib/DebugInfo/MSF/MSFBuilder.cpp 256 SB->BlockMapAddr = BlockMapAddr;
257 SB->BlockSize = BlockSize;
258 SB->NumDirectoryBytes = computeDirectoryByteSize();
259 SB->FreeBlockMapBlock = FreePageMap;
260 SB->Unknown1 = Unknown1;
284 SB->NumBlocks = FreeBlocks.size();
298 Sizes[I] = StreamData[I].first;
lib/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.cpp 44 Layout.Mod = ModIndex;
106 Layout.FileNameOffs = 0; // TODO: Fix this
107 Layout.Flags = 0; // TODO: Fix this
108 Layout.C11Bytes = 0;
109 Layout.C13Bytes = calculateC13DebugInfoSize();
112 Layout.NumFiles = SourceFiles.size();
113 Layout.PdbFilePathNI = PdbFilePathNI;
114 Layout.SrcFileNameNI = 0;
118 Layout.SymBytes =
123 this->Layout.ModDiStream = kInvalidStreamIndex;
131 Layout.ModDiStream = *ExpectedSN;
lib/DebugInfo/PDB/Native/DbiStreamBuilder.cpp 266 H->VersionHeader = *VerHeader;
267 H->VersionSignature = -1;
268 H->Age = Age;
269 H->BuildNumber = BuildNumber;
270 H->Flags = Flags;
271 H->PdbDllRbld = PdbDllRbld;
272 H->PdbDllVersion = PdbDllVersion;
273 H->MachineType = static_cast<uint16_t>(MachineType);
275 H->ECSubstreamSize = ECNamesBuilder.calculateSerializedSize();
276 H->FileInfoSize = FileInfoBuffer.getLength();
277 H->ModiSubstreamSize = calculateModiSubstreamSize();
278 H->OptionalDbgHdrSize = DbgStreams.size() * sizeof(uint16_t);
279 H->SecContrSubstreamSize = calculateSectionContribsStreamSize();
280 H->SectionMapSize = calculateSectionMapStreamSize();
281 H->TypeServerSize = 0;
282 H->SymRecordStreamIndex = SymRecordStreamIndex;
283 H->PublicSymbolStreamIndex = PublicsStreamIndex;
284 H->MFCTypeServerIndex = 0; // Not sure what this is, but link.exe writes 0.
285 H->GlobalSymbolStreamIndex = GlobalsStreamIndex;
366 Entry.Frame = Idx + 1;
369 Entry.SecName = UINT16_MAX;
370 Entry.ClassName = UINT16_MAX;
377 Entry.Flags = toSecMapFlags(Hdr.Characteristics);
384 Entry.Flags = static_cast<uint16_t>(OMFSegDescFlags::AddressIs32Bit) |
386 Entry.SecByteLength = UINT32_MAX;
lib/DebugInfo/PDB/Native/GSIStreamBuilder.cpp 96 Header.VerSignature = GSIHashHeader::HdrSignature;
97 Header.VerHdr = GSIHashHeader::HdrVersion;
98 Header.HrSize = HashRecords.size() * sizeof(PSHashRecord);
99 Header.NumBuckets = HashBitmap.size() * 4 + HashBuckets.size() * 4;
140 HR.Off = SymOffset + 1;
141 HR.CRef = 1; // Always use a refcount of 1.
154 Word = 0;
335 Header.SymHash = PSH->calculateSerializedLength();
336 Header.AddrMap = PSH->Records.size() * 4;
337 Header.NumThunks = 0;
338 Header.SizeOfThunk = 0;
339 Header.ISectThunkTable = 0;
341 Header.OffThunkTable = 0;
342 Header.NumSections = 0;
lib/DebugInfo/PDB/Native/InfoStreamBuilder.cpp 68 H.Version = Ver;
lib/DebugInfo/PDB/Native/PDBFileBuilder.cpp 181 Entry.Size = sizeof(SrcHeaderBlockEntry);
182 Entry.FileSize = IS.Content->getBufferSize();
183 Entry.FileNI = IS.NameIndex;
184 Entry.VFileNI = IS.VNameIndex;
185 Entry.ObjNI = 1;
187 Entry.Version =
189 Entry.CRC = CRC.getCRC();
236 Header.Version = static_cast<uint32_t>(PdbRaw_SrcHeaderBlockVer::SrcVerOne);
237 Header.Size = Writer.bytesRemaining();
338 H->Age = 1;
345 H->Signature = static_cast<uint32_t>(Digest);
350 H->Age = Info->getAge();
353 H->Signature = Sig.hasValue() ? *Sig : time(nullptr);
lib/DebugInfo/PDB/Native/PDBStringTableBuilder.cpp 156 H.Signature = PDBStringTableSignature;
157 H.HashVersion = 1;
158 H.ByteSize = Strings.calculateSerializedSize();
189 Buckets[Slot] = Offset;
lib/DebugInfo/PDB/Native/TpiStreamBuilder.cpp 70 H->Version = VerHeader;
71 H->HeaderSize = sizeof(TpiStreamHeader);
72 H->TypeIndexBegin = codeview::TypeIndex::FirstNonSimpleIndex;
73 H->TypeIndexEnd = H->TypeIndexBegin + Count;
74 H->TypeRecordBytes = TypeRecordBytes;
76 H->HashStreamIndex = HashStreamIndex;
77 H->HashAuxStreamIndex = kInvalidStreamIndex;
78 H->HashKeySize = sizeof(ulittle32_t);
79 H->NumHashBuckets = MaxTpiHashBuckets - 1;
84 H->HashValueBuffer.Off = 0;
85 H->HashValueBuffer.Length = calculateHashBufferSize();
89 H->HashAdjBuffer.Off = H->HashValueBuffer.Off + H->HashValueBuffer.Length;
90 H->HashAdjBuffer.Length = 0;
92 H->IndexOffsetBuffer.Off = H->HashAdjBuffer.Off + H->HashAdjBuffer.Length;
93 H->IndexOffsetBuffer.Length = calculateIndexOffsetSize();
132 HashBuffer[I] = TypeHashes[I] % (MaxTpiHashBuckets - 1);
lib/ExecutionEngine/JITLink/MachO_arm64.cpp 565 *(little32_t *)FixupPtr = FixedInstr;
572 *(ulittle32_t *)FixupPtr = Value;
577 *(ulittle64_t *)FixupPtr = Value;
597 *(ulittle32_t *)FixupPtr = FixedInstr;
612 *(ulittle32_t *)FixupPtr = FixedInstr;
626 *(ulittle32_t *)FixupPtr = FixedInstr;
643 *(ulittle32_t *)FixupPtr = FixedInstr;
660 *(little32_t *)FixupPtr = Value;
662 *(little64_t *)FixupPtr = Value;
lib/ExecutionEngine/JITLink/MachO_x86_64.cpp 495 *(little32_t *)FixupPtr = Value;
501 *(ulittle64_t *)FixupPtr = Value;
513 *(little32_t *)FixupPtr = Value;
525 *(little32_t *)FixupPtr = Value;
542 *(little32_t *)FixupPtr = Value;
544 *(little64_t *)FixupPtr = Value;
551 *(ulittle32_t *)FixupPtr = Value;
lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp 177 shdr->sh_addr = static_cast<addr_type>(SecLoadAddr);
lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOAArch64.h 183 *reinterpret_cast<support::ulittle32_t *>(LocalAddress) = Addend;
185 *reinterpret_cast<support::ulittle64_t *>(LocalAddress) = Addend;
199 *p = (*p & 0xFC000000) | ((uint32_t)(Addend >> 2) & 0x03FFFFFF);
215 *p = (*p & 0x9F00001F) | ImmHiValue | ImmLoValue;
266 *p = (*p & 0xFFC003FF) | ((uint32_t)(Addend << 10) & 0x003FFC00);
lib/MC/MCParser/AsmParser.cpp 3912 DRHdr.Register = DRRegister;
3913 DRHdr.MayHaveNoName = 0;
3925 DRHdr.Offset = DROffset;
3942 DRHdr.Register = DRRegister;
3943 DRHdr.MayHaveNoName = 0;
3944 DRHdr.OffsetInParent = DROffsetInParent;
3967 DRHdr.Register = DRRegister;
3968 DRHdr.Flags = DRFlags;
3969 DRHdr.BasePointerOffset = DRBasePointerOffset;
lib/Object/COFFImportFile.cpp 301 SymbolTable[0].Name.Offset.Offset =
303 SymbolTable[5].Name.Offset.Offset =
305 SymbolTable[6].Name.Offset.Offset =
370 SymbolTable[0].Name.Offset.Offset = sizeof(uint32_t);
452 SymbolTable[0].Name.Offset.Offset = sizeof(uint32_t);
475 Imp->Sig2 = 0xFFFF;
476 Imp->Machine = Machine;
477 Imp->SizeOfData = ImpSize;
479 Imp->OrdinalHint = Ordinal;
480 Imp->TypeInfo = (NameType << 2) | ImportType;
555 SymbolTable[2].Name.Offset.Offset = sizeof(uint32_t);
559 SymbolTable[3].Name.Offset.Offset =
lib/Object/ELF.cpp 304 Rela.r_info = 0;
305 Rela.r_addend = 0;
324 Rela.r_offset = Entry;
336 Rela.r_offset = Offset;
412 R.r_offset = Offset;
413 R.r_info = GroupedByInfo ? GroupRInfo : ReadSLEB();
416 R.r_addend = Addend;
lib/Object/IRSymtab.cpp 95 S.Offset = StrtabBuilder.add(Value);
96 S.Size = Value.size();
101 R.Offset = Symtab.size();
102 R.Size = Objs.size();
129 Mod.Begin = Syms.size();
130 Mod.End = Syms.size() + Msymtab.symbols().size();
131 Mod.UncBegin = Uncommons.size();
238 Sym.ComdatIndex = -1;
267 Uncommon().CommonSize = GV->getParent()->getDataLayout().getTypeAllocSize(
269 Uncommon().CommonAlign = GV->getAlignment();
280 Sym.ComdatIndex = *ComdatIndexOrErr;
311 Hdr.Version = storage::Header::kCurrentVersion;
lib/Object/WindowsResource.cpp 731 Header->Machine = MachineType;
732 Header->NumberOfSections = 2;
733 Header->TimeDateStamp = TimeDateStamp;
734 Header->PointerToSymbolTable = SymbolTableOffset;
736 Header->NumberOfSymbols = Data.size() + 5;
737 Header->SizeOfOptionalHeader = 0;
739 Header->Characteristics = COFF::IMAGE_FILE_32BIT_MACHINE;
748 SectionOneHeader->VirtualSize = 0;
749 SectionOneHeader->VirtualAddress = 0;
750 SectionOneHeader->SizeOfRawData = SectionOneSize;
751 SectionOneHeader->PointerToRawData = SectionOneOffset;
752 SectionOneHeader->PointerToRelocations = SectionOneRelocations;
753 SectionOneHeader->PointerToLinenumbers = 0;
754 SectionOneHeader->NumberOfRelocations = Data.size();
755 SectionOneHeader->NumberOfLinenumbers = 0;
766 SectionTwoHeader->VirtualSize = 0;
767 SectionTwoHeader->VirtualAddress = 0;
768 SectionTwoHeader->SizeOfRawData = SectionTwoSize;
769 SectionTwoHeader->PointerToRawData = SectionTwoOffset;
770 SectionTwoHeader->PointerToRelocations = 0;
771 SectionTwoHeader->PointerToLinenumbers = 0;
772 SectionTwoHeader->NumberOfRelocations = 0;
773 SectionTwoHeader->NumberOfLinenumbers = 0;
774 SectionTwoHeader->Characteristics = COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
804 Symbol->Value = 0x11;
805 Symbol->SectionNumber = 0xffff;
806 Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
814 Symbol->Value = 0;
815 Symbol->SectionNumber = 1;
816 Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
822 Aux->Length = SectionOneSize;
823 Aux->NumberOfRelocations = Data.size();
824 Aux->NumberOfLinenumbers = 0;
825 Aux->CheckSum = 0;
826 Aux->NumberLowPart = 0;
833 Symbol->Value = 0;
834 Symbol->SectionNumber = 2;
835 Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
841 Aux->Length = SectionTwoSize;
842 Aux->NumberOfRelocations = 0;
843 Aux->NumberOfLinenumbers = 0;
844 Aux->CheckSum = 0;
845 Aux->NumberLowPart = 0;
854 Symbol->Value = DataOffsets[i];
855 Symbol->SectionNumber = 2;
856 Symbol->Type = COFF::IMAGE_SYM_DTYPE_NULL;
886 Table->Characteristics = CurrentNode->getCharacteristics();
887 Table->TimeDateStamp = 0;
888 Table->MajorVersion = CurrentNode->getMajorVersion();
889 Table->MinorVersion = CurrentNode->getMinorVersion();
892 Table->NumberOfNameEntries = StringChildren.size();
893 Table->NumberOfIDEntries = IDChildren.size();
904 Entry->Offset.DataEntryOffset = NextLevelOffset;
908 Entry->Offset.SubdirOffset = NextLevelOffset + (1 << 31);
921 Entry->Identifier.ID = Child.first;
923 Entry->Offset.DataEntryOffset = NextLevelOffset;
927 Entry->Offset.SubdirOffset = NextLevelOffset + (1 << 31);
945 Entry->DataRVA = 0; // Set to zero because it is a relocation.
946 Entry->DataSize = Data[DataNodes->getDataIndex()].size();
947 Entry->Codepage = 0;
948 Entry->Reserved = 0;
979 Reloc->VirtualAddress = RelocationAddresses[i];
980 Reloc->SymbolTableIndex = NextSymbolIndex++;
983 Reloc->Type = COFF::IMAGE_REL_ARM_ADDR32NB;
986 Reloc->Type = COFF::IMAGE_REL_AMD64_ADDR32NB;
989 Reloc->Type = COFF::IMAGE_REL_I386_DIR32NB;
992 Reloc->Type = COFF::IMAGE_REL_ARM64_ADDR32NB;
lib/ObjectYAML/COFFEmitter.cpp 120 *reinterpret_cast<support::aligned_ulittle32_t *>(Sym.Header.Name + 4) =
307 *reinterpret_cast<support::ulittle32_t *>(&CP.StringTable[0]) =
351 Header->Magic = Magic;
352 Header->SectionAlignment = CP.Obj.OptionalHeader->Header.SectionAlignment;
353 Header->FileAlignment = CP.Obj.OptionalHeader->Header.FileAlignment;
368 Header->BaseOfCode = S.Header.VirtualAddress; // RVA
374 Header->SizeOfCode = SizeOfCode;
375 Header->SizeOfInitializedData = SizeOfInitializedData;
376 Header->SizeOfUninitializedData = SizeOfUninitializedData;
377 Header->AddressOfEntryPoint =
379 Header->ImageBase = CP.Obj.OptionalHeader->Header.ImageBase;
380 Header->MajorOperatingSystemVersion =
382 Header->MinorOperatingSystemVersion =
384 Header->MajorImageVersion = CP.Obj.OptionalHeader->Header.MajorImageVersion;
385 Header->MinorImageVersion = CP.Obj.OptionalHeader->Header.MinorImageVersion;
386 Header->MajorSubsystemVersion =
388 Header->MinorSubsystemVersion =
390 Header->SizeOfImage = SizeOfImage;
391 Header->SizeOfHeaders = SizeOfHeaders;
392 Header->Subsystem = CP.Obj.OptionalHeader->Header.Subsystem;
393 Header->DLLCharacteristics = CP.Obj.OptionalHeader->Header.DLLCharacteristics;
394 Header->SizeOfStackReserve = CP.Obj.OptionalHeader->Header.SizeOfStackReserve;
395 Header->SizeOfStackCommit = CP.Obj.OptionalHeader->Header.SizeOfStackCommit;
396 Header->SizeOfHeapReserve = CP.Obj.OptionalHeader->Header.SizeOfHeapReserve;
397 Header->SizeOfHeapCommit = CP.Obj.OptionalHeader->Header.SizeOfHeapCommit;
398 Header->NumberOfRvaAndSize = COFF::NUM_DATA_DIRECTORIES + 1;
414 DH.AddressOfRelocationTable = sizeof(DH);
416 DH.AddressOfNewExeHeader = DOSStubSize;
456 PEH.BaseOfData = BaseOfData;
lib/ObjectYAML/CodeViewYAMLDebugSections.cpp 516 F.CodeSize = YF.CodeSize;
517 F.Flags = YF.Flags;
518 F.LocalSize = YF.LocalSize;
519 F.MaxStackSize = YF.MaxStackSize;
520 F.ParamsSize = YF.ParamsSize;
521 F.PrologSize = YF.PrologSize;
522 F.RvaStart = YF.RvaStart;
523 F.SavedRegsSize = YF.SavedRegsSize;
524 F.FrameFunc = SC.strings()->insert(YF.FrameFunc);
lib/ObjectYAML/CodeViewYAMLSymbols.cpp 246 Prefix.RecordKind = Kind;
247 Prefix.RecordLen = TotalLen - 2;
lib/ObjectYAML/ELFEmitter.cpp 45 Offset = padToAlignment(Align);
262 Header.e_type = Doc.Header.Type;
263 Header.e_machine = Doc.Header.Machine;
264 Header.e_version = EV_CURRENT;
265 Header.e_entry = Doc.Header.Entry;
266 Header.e_phoff = Doc.ProgramHeaders.size() ? sizeof(Header) : 0;
267 Header.e_flags = Doc.Header.Flags;
268 Header.e_ehsize = sizeof(Elf_Ehdr);
269 Header.e_phentsize = Doc.ProgramHeaders.size() ? sizeof(Elf_Phdr) : 0;
270 Header.e_phnum = Doc.ProgramHeaders.size();
272 Header.e_shentsize =
278 Header.e_shoff =
280 Header.e_shnum =
282 Header.e_shstrndx = Doc.Header.SHStrNdx ? (uint16_t)*Doc.Header.SHStrNdx
292 Phdr.p_type = YamlPhdr.Type;
293 Phdr.p_flags = YamlPhdr.Flags;
294 Phdr.p_vaddr = YamlPhdr.VAddr;
295 Phdr.p_paddr = YamlPhdr.PAddr;
356 Header.sh_name = *YAMLSec->ShName;
358 Header.sh_offset = *YAMLSec->ShOffset;
360 Header.sh_size = *YAMLSec->ShSize;
397 SHeader.sh_name =
399 SHeader.sh_type = Sec->Type;
401 SHeader.sh_flags = *Sec->Flags;
402 SHeader.sh_addr = Sec->Address;
403 SHeader.sh_addralign = Sec->AddressAlign;
406 SHeader.sh_link = toSectionIndex(Sec->Link, Sec->Name);
412 SHeader.sh_size = *RawSec->Size;
414 SHeader.sh_info = *RawSec->Info;
417 SHeader.sh_entsize = *Sec->EntSize;
429 SHeader.sh_entsize = 0;
430 SHeader.sh_size = S->Size;
457 SHeader.sh_name = *Sec->ShName;
459 SHeader.sh_offset = *Sec->ShOffset;
461 SHeader.sh_size = *Sec->ShSize;
504 Symbol.st_name = *Sym.NameIndex;
506 Symbol.st_name = Strtab.getOffset(ELFYAML::dropUniqueSuffix(Sym.Name));
510 Symbol.st_shndx = toSectionIndex(Sym.Section, "", Sym.Name);
512 Symbol.st_shndx = *Sym.Index;
514 Symbol.st_value = Sym.Value;
516 Symbol.st_size = Sym.Size;
550 SHeader.sh_name = DotShStrtab.getOffset(IsStatic ? ".symtab" : ".dynsym");
553 SHeader.sh_type = YAMLSec->Type;
555 SHeader.sh_type = IsStatic ? ELF::SHT_SYMTAB : ELF::SHT_DYNSYM;
560 SHeader.sh_link = toSectionIndex(RawSec->Link, RawSec->Name);
571 SHeader.sh_link = Link;
575 SHeader.sh_flags = *YAMLSec->Flags;
577 SHeader.sh_flags = ELF::SHF_ALLOC;
581 SHeader.sh_info = (RawSec && RawSec->Info) ? (unsigned)(*RawSec->Info)
583 SHeader.sh_entsize = (YAMLSec && YAMLSec->EntSize)
586 SHeader.sh_addralign = YAMLSec ? (uint64_t)YAMLSec->AddressAlign : 8;
587 SHeader.sh_addr = YAMLSec ? (uint64_t)YAMLSec->Address : 0;
592 SHeader.sh_size = writeContent(OS, RawSec->Content, RawSec->Size);
599 SHeader.sh_size = arrayDataSize(makeArrayRef(Syms));
608 SHeader.sh_name = DotShStrtab.getOffset(Name);
609 SHeader.sh_type = YAMLSec ? YAMLSec->Type : ELF::SHT_STRTAB;
610 SHeader.sh_addralign = YAMLSec ? (uint64_t)YAMLSec->AddressAlign : 1;
617 SHeader.sh_size = writeContent(OS, RawSec->Content, RawSec->Size);
620 SHeader.sh_size = STB.getSize();
624 SHeader.sh_entsize = *YAMLSec->EntSize;
627 SHeader.sh_info = *RawSec->Info;
630 SHeader.sh_flags = *YAMLSec->Flags;
632 SHeader.sh_flags = ELF::SHF_ALLOC;
637 SHeader.sh_addr = YAMLSec->Address;
664 PHeader.p_offset = *YamlPhdr.Offset;
667 PHeader.p_offset = UINT32_MAX;
669 PHeader.p_offset = 0;
689 PHeader.p_filesz = YamlPhdr.FileSize ? uint64_t(*YamlPhdr.FileSize)
691 PHeader.p_memsz = YamlPhdr.MemSize ? uint64_t(*YamlPhdr.MemSize)
695 PHeader.p_align = *YamlPhdr.Align;
700 PHeader.p_align = 1;
713 SHeader.sh_size = writeContent(OS, Section.Content, Section.Size);
716 SHeader.sh_entsize = *Section.EntSize;
718 SHeader.sh_entsize = sizeof(Elf_Relr);
720 SHeader.sh_entsize = 0;
723 SHeader.sh_info = *Section.Info;
741 SHeader.sh_entsize = IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
742 SHeader.sh_size = SHeader.sh_entsize * Section.Relocations.size();
746 SHeader.sh_link = SN2I.get(".symtab");
749 SHeader.sh_info = toSectionIndex(Section.RelocatableSec, Section.Name);
759 REntry.r_offset = Rel.Offset;
760 REntry.r_addend = Rel.Addend;
766 REntry.r_offset = Rel.Offset;
783 SHeader.sh_entsize = Shndx.EntSize ? (uint64_t)*Shndx.EntSize : 4;
784 SHeader.sh_size = Shndx.Entries.size() * SHeader.sh_entsize;
794 SHeader.sh_entsize = 4;
795 SHeader.sh_size = SHeader.sh_entsize * Section.Members.size();
796 SHeader.sh_info =
821 SHeader.sh_entsize = Section.EntSize ? (uint64_t)*Section.EntSize : 2;
822 SHeader.sh_size = Section.Entries.size() * SHeader.sh_entsize;
834 SHeader.sh_size = writeContent(OS, Section.Content, Section.Size);
853 SHeader.sh_link = Link;
856 SHeader.sh_size = writeContent(OS, Section.Content, Section.Size);
869 SHeader.sh_size = (2 + Section.Bucket->size() + Section.Chain->size()) * 4;
886 VerDef.vd_version = E.Version;
887 VerDef.vd_flags = E.Flags;
888 VerDef.vd_ndx = E.VersionNdx;
889 VerDef.vd_hash = E.Hash;
890 VerDef.vd_aux = sizeof(Elf_Verdef);
891 VerDef.vd_cnt = E.VerNames.size();
893 VerDef.vd_next = 0;
895 VerDef.vd_next =
901 VernAux.vda_name = DotDynstr.getOffset(E.VerNames[J]);
903 VernAux.vda_next = 0;
905 VernAux.vda_next = sizeof(Elf_Verdaux);
910 SHeader.sh_size = Section.Entries.size() * sizeof(Elf_Verdef) +
912 SHeader.sh_info = Section.Info;
929 VerNeed.vn_version = VE.Version;
930 VerNeed.vn_file = DotDynstr.getOffset(VE.File);
932 VerNeed.vn_next = 0;
934 VerNeed.vn_next =
936 VerNeed.vn_cnt = VE.AuxV.size();
937 VerNeed.vn_aux = sizeof(Elf_Verneed);
944 VernAux.vna_hash = VAuxE.Hash;
945 VernAux.vna_flags = VAuxE.Flags;
946 VernAux.vna_other = VAuxE.Other;
947 VernAux.vna_name = DotDynstr.getOffset(VAuxE.Name);
949 VernAux.vna_next = 0;
951 VernAux.vna_next = sizeof(Elf_Vernaux);
956 SHeader.sh_size = Section.VerneedV.size() * sizeof(Elf_Verneed) +
958 SHeader.sh_info = Section.Info;
970 SHeader.sh_entsize = sizeof(Flags);
974 Flags.version = Section.Version;
981 Flags.isa_ext = Section.ISAExtension;
982 Flags.ases = Section.ASEs;
983 Flags.flags1 = Section.Flags1;
984 Flags.flags2 = Section.Flags2;
1003 SHeader.sh_size = Section.Content->binary_size();
1005 SHeader.sh_size = 2 * sizeof(uintX_t) * Section.Entries.size();
1007 SHeader.sh_entsize = *Section.EntSize;
1009 SHeader.sh_entsize = sizeof(Elf_Dyn);
1030 SHeader.sh_link = Link;
1033 SHeader.sh_size = writeContent(OS, Section.Content, Section.Size);
1054 SHeader.sh_size = writeContent(OS, Section.Content, Section.Size);
1091 SHeader.sh_size = OS.tell() - Offset;
lib/ObjectYAML/MinidumpEmitter.cpp 143 M.Entry.ModuleNameRVA = File.allocateString(M.Name);
174 Result.Type = S.Type;
175 Result.Location.RVA = File.tell();
209 SystemInfo.Info.CSDVersionRVA = File.allocateString(SystemInfo.CSDVersion);
221 Result.Location.DataSize =
235 Obj.Header.StreamDirectoryRVA =
237 Obj.Header.NumberOfStreams = StreamDirectory.size();
lib/ObjectYAML/MinidumpYAML.cpp 31 Val = static_cast<typename EndianType::value_type>(Mapped);
41 Val = static_cast<typename EndianType::value_type>(Mapped);
tools/lld/COFF/Chunks.cpp 759 begin[cnt++] = co.inputChunk->getRVA() + co.offset;
780 table[0] = 0;
781 table[1] = 0;
782 table[2] = 1;
786 table[idx + 0] = rpr.sym->getRVA();
787 table[idx + 1] = rpr.target->getRVA() + rpr.targetOffset;
788 table[idx + 2] = rpr.flags;
tools/lld/COFF/DLL.cpp 110 e->ImportLookupTableRVA = lookupTab->getRVA();
111 e->NameRVA = dllName->getRVA();
112 e->ImportAddressTableRVA = addressTab->getRVA();
176 e->Attributes = 1;
177 e->Name = dllName->getRVA();
178 e->ModuleHandle = moduleHandle->getRVA();
179 e->DelayImportAddressTable = addressTab->getRVA();
180 e->DelayImportNameTable = nameTab->getRVA();
485 e->NameRVA = dllName->getRVA();
486 e->OrdinalBase = 0;
487 e->AddressTableEntries = maxOrdinal + 1;
488 e->NumberOfNamePointers = nameTabSize;
489 e->ExportAddressTableRVA = addressTab->getRVA();
490 e->NamePointerRVA = nameTab->getRVA();
491 e->OrdinalTableRVA = ordinalTab->getRVA();
tools/lld/COFF/DriverUtils.cpp 471 prefix->DataSize = manifestSize;
472 prefix->HeaderSize = sizeof(object::WinResHeaderPrefix) +
485 suffix->DataVersion = 0;
486 suffix->MemoryFlags = object::WIN_RES_PURE_MOVEABLE;
487 suffix->Language = SUBLANG_ENGLISH_US;
488 suffix->Version = 0;
489 suffix->Characteristics = 0;
tools/lld/COFF/PDB.cpp 660 prefix->RecordKind = SymbolKind::S_END;
693 prefix->RecordKind = uint16_t(kind);
715 prefix->RecordLen = size - 2;
736 s.openingRecord->ptrParent = stack.empty() ? 0 : stack.back().scopeOffset;
747 s.openingRecord->ptrEnd = curOffset;
953 sc.ISect = os ? os->sectionIndex : llvm::pdb::kInvalidStreamIndex;
954 sc.Off = c && os ? c->getRVA() - os->getRVA() : 0;
955 sc.Size = c ? c->getSize() : -1;
958 sc.Imod = secChunk->file->moduleDBI->getModuleIndex();
962 sc.DataCrc = crc.getCRC();
964 sc.Characteristics = os ? os->header.Characteristics : 0;
965 sc.Imod = modi;
967 sc.RelocCrc = 0; // FIXME
1131 fd.FrameFunc =
1138 *ref = translateStringTableIndex(*ref, cVStrTab, linker.pdbStrTab);
1619 buildId->Signature.CVSignature = OMF::Signature::PDB70;
1622 buildId->PDB70.Age = 1;
tools/lld/COFF/Writer.cpp 124 *tds = timeDateStamp;
130 d->Characteristics = 0;
131 d->TimeDateStamp = 0;
132 d->MajorVersion = 0;
133 d->MinorVersion = 0;
134 d->Type = debugType;
135 d->SizeOfData = size;
136 d->AddressOfRawData = rva;
137 d->PointerToRawData = offs;
488 newRelocs[i].SymbolTableIndex = nextReplacement->second;
1087 sym.Value = def->getRVA();
1088 sym.SectionNumber = IMAGE_SYM_ABSOLUTE;
1103 sym.Value = def->getRVA() - os->getRVA();
1104 sym.SectionNumber = os->sectionIndex;
1118 sym.Name.Offset.Zeroes = 0;
1119 sym.Name.Offset.Offset = addEntryToStringTable(name);
1127 sym.Type = ref.getType();
1130 sym.Type = IMAGE_SYM_TYPE_NULL;
1228 sec->header.VirtualAddress = rva;
1249 sec->header.VirtualSize = virtualSize;
1250 sec->header.SizeOfRawData = rawSize;
1252 sec->header.PointerToRawData = fileSize;
1275 dos->UsedBytesInTheLastPage = dosStubSize % 512;
1276 dos->FileSizeInPages = divideCeil(dosStubSize, 512);
1277 dos->HeaderSizeInParagraphs = sizeof(dos_header) / 16;
1279 dos->AddressOfRelocationTable = sizeof(dos_header);
1280 dos->AddressOfNewExeHeader = dosStubSize;
1293 coff->Machine = config->machine;
1294 coff->NumberOfSections = outputSections.size();
1295 coff->Characteristics = IMAGE_FILE_EXECUTABLE_IMAGE;
1308 coff->SizeOfOptionalHeader =
1314 pe->Magic = config->is64() ? PE32Header::PE32_PLUS : PE32Header::PE32;
1324 pe->ImageBase = config->imageBase;
1325 pe->SectionAlignment = config->align;
1326 pe->FileAlignment = config->fileAlign;
1327 pe->MajorImageVersion = config->majorImageVersion;
1328 pe->MinorImageVersion = config->minorImageVersion;
1329 pe->MajorOperatingSystemVersion = config->majorOSVersion;
1330 pe->MinorOperatingSystemVersion = config->minorOSVersion;
1331 pe->MajorSubsystemVersion = config->majorOSVersion;
1332 pe->MinorSubsystemVersion = config->minorOSVersion;
1333 pe->Subsystem = config->subsystem;
1334 pe->SizeOfImage = sizeOfImage;
1335 pe->SizeOfHeaders = sizeOfHeaders;
1338 pe->AddressOfEntryPoint = entry->getRVA();
1343 pe->SizeOfStackReserve = config->stackReserve;
1344 pe->SizeOfStackCommit = config->stackCommit;
1345 pe->SizeOfHeapReserve = config->heapReserve;
1346 pe->SizeOfHeapCommit = config->heapCommit;
1367 pe->NumberOfRvaAndSize = numberOfDataDirectory;
1369 pe->BaseOfCode = textSec->getRVA();
1370 pe->SizeOfCode = textSec->getRawSize();
1372 pe->SizeOfInitializedData = getSizeOfInitializedData();
1378 dir[EXPORT_TABLE].RelativeVirtualAddress = edataStart->getRVA();
1379 dir[EXPORT_TABLE].Size =
1383 dir[IMPORT_TABLE].RelativeVirtualAddress = importTableStart->getRVA();
1384 dir[IMPORT_TABLE].Size = importTableSize;
1387 dir[IAT].RelativeVirtualAddress = iatStart->getRVA();
1388 dir[IAT].Size = iatSize;
1391 dir[RESOURCE_TABLE].RelativeVirtualAddress = rsrcSec->getRVA();
1392 dir[RESOURCE_TABLE].Size = rsrcSec->getVirtualSize();
1395 dir[EXCEPTION_TABLE].RelativeVirtualAddress = firstPdata->getRVA();
1396 dir[EXCEPTION_TABLE].Size =
1400 dir[BASE_RELOCATION_TABLE].RelativeVirtualAddress = relocSec->getRVA();
1401 dir[BASE_RELOCATION_TABLE].Size = relocSec->getVirtualSize();
1405 dir[TLS_TABLE].RelativeVirtualAddress = b->getRVA();
1406 dir[TLS_TABLE].Size = config->is64()
1412 dir[DEBUG_DIRECTORY].RelativeVirtualAddress = debugDirectory->getRVA();
1413 dir[DEBUG_DIRECTORY].Size = debugDirectory->getSize();
1428 dir[LOAD_CONFIG_TABLE].RelativeVirtualAddress = b->getRVA();
1429 dir[LOAD_CONFIG_TABLE].Size = loadConfigSize;
1433 dir[DELAY_IMPORT_DESCRIPTOR].RelativeVirtualAddress =
1435 dir[DELAY_IMPORT_DESCRIPTOR].Size = delayIdata.getDirSize();
1449 coff->PointerToSymbolTable = pointerToSymbolTable;
1451 coff->NumberOfSymbols = numberOfSymbols;
1794 buildId->buildId->PDB70.CVSignature = OMF::Signature::PDB70;
1795 buildId->buildId->PDB70.Age = 1;
1808 coffHeader->TimeDateStamp = timestamp;
tools/lld/COFF/Writer.h 42 header.Characteristics = chars;
tools/lld/ELF/InputSection.cpp 395 *to++ = sections[idx]->getOutputSection()->sectionIndex;
421 p->r_addend = getAddend<ELFT>(rel);
425 p->r_offset = sec->getVA(rel.r_offset);
485 p->r_addend = sym.getVA(addend) - section->getOutputSection()->addr;
tools/lld/ELF/OutputSections.cpp 57 shdr->sh_entsize = entsize;
58 shdr->sh_addralign = alignment;
59 shdr->sh_type = type;
60 shdr->sh_offset = offset;
61 shdr->sh_flags = flags;
62 shdr->sh_info = info;
63 shdr->sh_link = link;
64 shdr->sh_addr = addr;
65 shdr->sh_size = size;
66 shdr->sh_name = shName;
268 hdr->ch_type = ELFCOMPRESS_ZLIB;
269 hdr->ch_size = size;
270 hdr->ch_addralign = alignment;
tools/lld/ELF/SyntheticSections.cpp 162 reginfo.ri_gp_value = in.mipsGot->getGp();
219 reginfo.ri_gp_value = in.mipsGot->getGp();
1503 p->d_tag = kv.first;
1504 p->d_un.d_val = kv.second();
1584 p->r_addend = rel.computeAddend();
1585 p->r_offset = rel.getOffset();
2136 eSym->st_name = ent.strTabOffset;
2138 eSym->st_shndx = getSymSectionIndex(ent.sym);
2140 eSym->st_shndx = 0;
2148 eSym->st_size = 0;
2150 eSym->st_size = sym->getSize();
2156 eSym->st_value = commonSec->alignment;
2158 eSym->st_value = sym->getVA();
2160 eSym->st_value = 0;
2740 hdr->version = 7;
2744 hdr->cuListOff = buf - start;
2754 hdr->cuTypesOff = buf - start;
2755 hdr->addressAreaOff = buf - start;
2769 hdr->symtabOff = buf - start;
2788 hdr->constantPoolOff = buf - start;
2998 verneed->vn_version = 1;
2999 verneed->vn_cnt = vn.vernauxs.size();
3000 verneed->vn_file = vn.nameStrTab;
3001 verneed->vn_aux =
3003 verneed->vn_next = sizeof(Elf_Verneed);
3008 vernaux->vna_hash = vna.hash;
3009 vernaux->vna_flags = 0;
3010 vernaux->vna_other = vna.verneedIndex;
3011 vernaux->vna_name = vna.nameStrTab;
3012 vernaux->vna_next = sizeof(Elf_Vernaux);
3016 vernaux[-1].vna_next = 0;
3018 verneed[-1].vn_next = 0;
3501 eHdr->e_machine = config->emachine;
3502 eHdr->e_version = EV_CURRENT;
3503 eHdr->e_flags = config->eflags;
3504 eHdr->e_ehsize = sizeof(typename ELFT::Ehdr);
3505 eHdr->e_phnum = part.phdrs.size();
3506 eHdr->e_shentsize = sizeof(typename ELFT::Shdr);
3509 eHdr->e_phoff = sizeof(typename ELFT::Ehdr);
3510 eHdr->e_phentsize = sizeof(typename ELFT::Phdr);
3518 hBuf->p_type = p->p_type;
3519 hBuf->p_flags = p->p_flags;
3520 hBuf->p_offset = p->p_offset;
3521 hBuf->p_vaddr = p->p_vaddr;
3522 hBuf->p_paddr = p->p_paddr;
3523 hBuf->p_filesz = p->p_filesz;
3524 hBuf->p_memsz = p->p_memsz;
3525 hBuf->p_align = p->p_align;
3545 eHdr->e_type = ET_DYN;
tools/lld/ELF/Writer.cpp 2553 eHdr->e_type = getELFType();
2554 eHdr->e_entry = getEntryAddr();
2555 eHdr->e_shoff = sectionHeaderOff;
2569 sHdrs->sh_size = num;
2571 eHdr->e_shnum = num;
2575 sHdrs->sh_link = strTabIndex;
2576 eHdr->e_shstrndx = SHN_XINDEX;
2578 eHdr->e_shstrndx = strTabIndex;
tools/lld/lib/ReaderWriter/MachO/ArchHandler_arm.cpp 931 *loc32 = value32;
938 *loc32 = setWordFromThumbMov(*loc32, value16);
943 *loc32 = setWordFromThumbMov(*loc32, value16);
950 *loc32 = setWordFromThumbMov(*loc32, value16);
955 *loc32 = setWordFromThumbMov(*loc32, value16);
962 *loc32 = value32;
969 *loc32 = setWordFromArmMov(*loc32, value16);
974 *loc32 = setWordFromArmMov(*loc32, value16);
981 *loc32 = setWordFromArmMov(*loc32, value16);
986 *loc32 = setWordFromArmMov(*loc32, value16);
990 *loc32 = targetAddress + ref.addend() + 1;
992 *loc32 = targetAddress + ref.addend();
996 *loc32 = targetAddress - fixupAddress + ref.addend() + 1;
998 *loc32 = targetAddress - fixupAddress + ref.addend();
1004 *loc32 = ref.addend();
1100 *loc32 = value32;
1108 *loc32 = setWordFromThumbMov(*loc32, value16);
1116 *loc32 = setWordFromThumbMov(*loc32, value16);
1121 *loc32 = setWordFromThumbMov(*loc32, value16);
1126 *loc32 = setWordFromThumbMov(*loc32, value16);
1137 *loc32 = value32;
1145 *loc32 = setWordFromArmMov(*loc32, value16);
1153 *loc32 = setWordFromArmMov(*loc32, value16);
1158 *loc32 = setWordFromArmMov(*loc32, value16);
1163 *loc32 = setWordFromArmMov(*loc32, value16);
1166 *loc32 = targetAddress + ref.addend();
1169 *loc32 = targetAddress - fixupAddress + ref.addend();
tools/lld/lib/ReaderWriter/MachO/ArchHandler_arm64.cpp 601 *loc32 = setDisplacementInBranch26(*loc32, displacement);
608 *loc32 = setDisplacementInADRP(*loc32, displacement);
614 *loc32 = setImm12(*loc32, displacement);
620 *loc32 = setImm12(*loc32, displacement >> 1);
626 *loc32 = setImm12(*loc32, displacement >> 2);
632 *loc32 = setImm12(*loc32, displacement >> 3);
638 *loc32 = setImm12(*loc32, displacement >> 4);
647 *loc32 = instruction;
651 *loc64 = targetAddress + ref.addend();
655 *loc64 = (targetAddress - fixupAddress) + ref.addend();
660 *loc32 = (targetAddress - fixupAddress) + ref.addend();
663 *loc32 = fixupAddress - targetAddress + ref.addend();
669 *loc32 = ref.addend();
672 *loc32 = (targetAddress - imageBaseAddress) + ref.addend();
680 *loc32 = (*loc32 & 0xff000000U) | value64;
702 *loc32 = setDisplacementInBranch26(*loc32, 0);
707 *loc32 = setDisplacementInADRP(*loc32, 0);
716 *loc32 = setImm12(*loc32, 0);
720 *loc64 = targetAddress + ref.addend();
722 *loc64 = ref.addend();
725 *loc64 = ref.addend() + inAtomAddress - fixupAddress;
732 *loc64 = targetAddress - fixupAddress;
735 *loc32 = ref.addend() + inAtomAddress - fixupAddress;
742 *loc32 = fixupAddress - targetAddress + ref.addend();
745 *loc64 = 0;
748 *loc32 = inAtomAddress - fixupAddress;
755 *loc32 = targetAddress - fixupAddress;
tools/lld/lib/ReaderWriter/MachO/ArchHandler_x86.cpp 449 *loc32 = (targetAddress - (fixupAddress + 4)) + ref.addend();
452 *loc32 = (targetAddress - (fixupAddress + 2)) + ref.addend();
456 *loc32 = targetAddress + ref.addend();
459 *loc32 = targetAddress - inAtomAddress + ref.addend();
462 *loc32 = targetAddress - fixupAddress + ref.addend();
465 *loc32 = fixupAddress - targetAddress + ref.addend();
473 *loc32 = ref.addend();
495 *loc32 = ref.addend() - (fixupAddress + 4);
497 *loc32 =(targetAddress - (fixupAddress+4)) + ref.addend();
501 *loc16 = ref.addend() - (fixupAddress + 2);
503 *loc16 = (targetAddress - (fixupAddress+2)) + ref.addend();
507 *loc32 = targetAddress + ref.addend();
510 *loc32 = targetAddress - inAtomAddress + ref.addend(); // FIXME
513 *loc32 = targetAddress - fixupAddress + ref.addend();
516 *loc32 = fixupAddress - targetAddress + ref.addend();
tools/lld/lib/ReaderWriter/MachO/ArchHandler_x86_64.cpp 589 *loc32 = targetAddress - (fixupAddress + 4) + ref.addend();
593 *loc64 = targetAddress + ref.addend();
596 *loc64 = targetAddress - findSectionAddress(*ref.target()) + ref.addend();
600 *loc32 = targetAddress - (fixupAddress + 5) + ref.addend();
604 *loc32 = targetAddress - (fixupAddress + 6) + ref.addend();
608 *loc32 = targetAddress - (fixupAddress + 8) + ref.addend();
612 *loc32 = targetAddress - fixupAddress + ref.addend();
617 *loc64 = targetAddress - fixupAddress + ref.addend();
623 *loc32 = targetAddress - (fixupAddress + 4) + ref.addend();
626 *loc64 = fixupAddress - targetAddress + ref.addend();
629 *loc32 = fixupAddress - targetAddress + ref.addend();
637 *loc32 = ref.addend();
641 *loc32 = (targetAddress - imageBaseAddress) + ref.addend();
646 *loc32 = (*loc32 & 0xff000000U) | val;
672 *loc32 = ref.addend();
675 *loc32 = (targetAddress - (fixupAddress + 4)) + ref.addend();
679 *loc64 = ref.addend();
682 *loc64 = targetAddress + ref.addend();
685 *loc32 = ref.addend() - 1;
688 *loc32 = (targetAddress - (fixupAddress + 5)) + ref.addend();
691 *loc32 = ref.addend() - 2;
694 *loc32 = (targetAddress - (fixupAddress + 6)) + ref.addend();
697 *loc32 = ref.addend() - 4;
700 *loc32 = (targetAddress - (fixupAddress + 8)) + ref.addend();
703 *loc32 = ref.addend() + inAtomAddress - fixupAddress;
716 *loc32 = (targetAddress + ref.addend()) - (fixupAddress - inAtomAddress);
719 *loc64 = ref.addend() + inAtomAddress - fixupAddress;
732 *loc64 = (targetAddress + ref.addend()) - (fixupAddress - inAtomAddress);
735 *loc64 = ref.addend() + fixupAddress - inAtomAddress;
738 *loc32 = ref.addend() + fixupAddress - inAtomAddress;
tools/lld/lib/ReaderWriter/MachO/MachONormalizedFileFromAtoms.cpp 1525 *loc = offset;
tools/lldb/source/Plugins/ObjectFile/Breakpad/BreakpadRecords.cpp 117 data.age = age;
tools/lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp 71 info.Guid.Data1 = read32be(sig);
73 info.Guid.Data2 = read16be(sig);
75 info.Guid.Data3 = read16be(sig);
81 info.Age = read32be(&pdb_info->PDB70.Age);
tools/lldb/source/Plugins/SymbolFile/NativePDB/DWARFLocationExpression.cpp 241 Value.I = constant.getSExtValue();
243 Value.U = constant.getZExtValue();
tools/lldb/unittests/Process/minidump/RegisterContextMinidumpTest.cpp 31 Context.context_flags =
36 Context.eax = 0x00010203;
37 Context.ebx = 0x04050607;
38 Context.ecx = 0x08090a0b;
39 Context.edx = 0x0c0d0e0f;
40 Context.edi = 0x10111213;
41 Context.esi = 0x14151617;
42 Context.ebp = 0x18191a1b;
43 Context.esp = 0x1c1d1e1f;
44 Context.eip = 0x20212223;
45 Context.eflags = 0x24252627;
46 Context.cs = 0x2829;
47 Context.fs = 0x2a2b;
48 Context.gs = 0x2c2d;
49 Context.ss = 0x2e2f;
50 Context.ds = 0x3031;
51 Context.es = 0x3233;
84 Context.context_flags =
89 Context.rax = 0x0001020304050607;
90 Context.rbx = 0x08090a0b0c0d0e0f;
91 Context.rcx = 0x1011121314151617;
92 Context.rdx = 0x18191a1b1c1d1e1f;
93 Context.rdi = 0x2021222324252627;
94 Context.rsi = 0x28292a2b2c2d2e2f;
95 Context.rbp = 0x3031323334353637;
96 Context.rsp = 0x38393a3b3c3d3e3f;
97 Context.r8 = 0x4041424344454647;
98 Context.r9 = 0x48494a4b4c4d4e4f;
99 Context.r10 = 0x5051525354555657;
100 Context.r11 = 0x58595a5b5c5d5e5f;
101 Context.r12 = 0x6061626364656667;
102 Context.r13 = 0x68696a6b6c6d6e6f;
103 Context.r14 = 0x7071727374757677;
104 Context.r15 = 0x78797a7b7c7d7e7f;
105 Context.rip = 0x8081828384858687;
106 Context.eflags = 0x88898a8b;
107 Context.cs = 0x8c8d;
108 Context.fs = 0x8e8f;
109 Context.gs = 0x9091;
110 Context.ss = 0x9293;
111 Context.ds = 0x9495;
112 Context.ss = 0x9697;
tools/llvm-objcopy/COFF/COFFObjcopy.cpp 68 Sec.Header.VirtualSize = NeedVA ? Sec.getContents().size() : 0u;
69 Sec.Header.VirtualAddress = NeedVA ? getNextRVA(Obj) : 0u;
70 Sec.Header.SizeOfRawData =
75 Sec.Header.PointerToRelocations = 0;
76 Sec.Header.PointerToLinenumbers = 0;
78 Sec.Header.NumberOfLinenumbers = 0;
79 Sec.Header.Characteristics = Characteristics;
tools/llvm-objcopy/COFF/Object.cpp 130 Sec.Header.SizeOfRawData = 0;
tools/llvm-objcopy/COFF/Object.h 166 Dest.SectionNumber = Src.SectionNumber;
184 Dest.ImageBase = Src.ImageBase;
199 Dest.SizeOfStackReserve = Src.SizeOfStackReserve;
200 Dest.SizeOfStackCommit = Src.SizeOfStackCommit;
201 Dest.SizeOfHeapReserve = Src.SizeOfHeapReserve;
202 Dest.SizeOfHeapCommit = Src.SizeOfHeapCommit;
tools/llvm-objcopy/COFF/Writer.cpp 34 R.Reloc.SymbolTableIndex = Sym->RawIndex;
45 Sym.Sym.SectionNumber = static_cast<uint32_t>(Sym.TargetSectionId);
52 Sym.Sym.SectionNumber = Sec->Index;
74 SD->NumberLowPart = static_cast<uint16_t>(SDSectionNumber);
75 SD->NumberHighPart = static_cast<uint16_t>(SDSectionNumber >> 16);
88 WE->TagIndex = Target->RawIndex;
97 S.Header.PointerToRawData = FileSize;
100 S.Header.NumberOfRelocations = S.Relocs.size();
101 S.Header.PointerToRelocations =
133 S.Sym.Name.Offset.Zeroes = 0;
134 S.Sym.Name.Offset.Offset = StrTabBuilder.getOffset(S.Name);
173 Obj.DosHeader.AddressOfNewExeHeader =
178 Obj.PeHeader.NumberOfRvaAndSize = Obj.DataDirectories.size();
184 Obj.CoffFileHeader.NumberOfSections = Obj.getSections().size();
190 Obj.CoffFileHeader.SizeOfOptionalHeader =
199 Obj.PeHeader.SizeOfHeaders = SizeOfHeaders;
200 Obj.PeHeader.SizeOfInitializedData = SizeOfInitializedData;
204 Obj.PeHeader.SizeOfImage =
211 Obj.PeHeader.CheckSum = 0;
227 Obj.CoffFileHeader.PointerToSymbolTable = PointerToSymbolTable;
228 Obj.CoffFileHeader.NumberOfSymbols = NumRawSymbols;
253 BigObjHeader.Sig1 = IMAGE_FILE_MACHINE_UNKNOWN;
254 BigObjHeader.Sig2 = 0xffff;
255 BigObjHeader.Version = BigObjHeader::MinBigObjectVersion;
259 BigObjHeader.unused1 = 0;
260 BigObjHeader.unused2 = 0;
261 BigObjHeader.unused3 = 0;
262 BigObjHeader.unused4 = 0;
265 BigObjHeader.NumberOfSections = Obj.getSections().size();
280 PeHeader.BaseOfData = Obj.BaseOfData;
393 Debug->PointerToRawData =
tools/llvm-objcopy/ELF/Object.cpp 43 Phdr.p_type = Seg.Type;
44 Phdr.p_flags = Seg.Flags;
45 Phdr.p_offset = Seg.Offset;
46 Phdr.p_vaddr = Seg.VAddr;
47 Phdr.p_paddr = Seg.PAddr;
48 Phdr.p_filesz = Seg.FileSize;
49 Phdr.p_memsz = Seg.MemSize;
50 Phdr.p_align = Seg.Align;
72 Shdr.sh_name = Sec.NameIndex;
73 Shdr.sh_type = Sec.Type;
74 Shdr.sh_flags = Sec.Flags;
75 Shdr.sh_addr = Sec.Addr;
76 Shdr.sh_offset = Sec.Offset;
77 Shdr.sh_size = Sec.Size;
78 Shdr.sh_link = Sec.Link;
79 Shdr.sh_info = Sec.Info;
80 Shdr.sh_addralign = Sec.Align;
81 Shdr.sh_entsize = Sec.EntrySize;
493 Chdr.ch_type = ELF::ELFCOMPRESS_ZLIB;
494 Chdr.ch_size = Sec.DecompressedSize;
495 Chdr.ch_addralign = Sec.DecompressedAlign;
785 Sym->st_name = Symbol->NameIndex;
786 Sym->st_value = Symbol->Value;
787 Sym->st_size = Symbol->Size;
791 Sym->st_shndx = Symbol->getShndx();
863 Rela.r_addend = Addend;
869 Buf->r_offset = Reloc.Offset;
1028 *CRC = Sec.CRC32;
1700 Ehdr.e_type = Obj.Type;
1701 Ehdr.e_machine = Obj.Machine;
1702 Ehdr.e_version = Obj.Version;
1703 Ehdr.e_entry = Obj.Entry;
1706 Ehdr.e_phnum = llvm::size(Obj.segments());
1707 Ehdr.e_phoff = (Ehdr.e_phnum != 0) ? Obj.ProgramHdrSegment.Offset : 0;
1708 Ehdr.e_phentsize = (Ehdr.e_phnum != 0) ? sizeof(Elf_Phdr) : 0;
1709 Ehdr.e_flags = Obj.Flags;
1710 Ehdr.e_ehsize = sizeof(Elf_Ehdr);
1712 Ehdr.e_shentsize = sizeof(Elf_Shdr);
1713 Ehdr.e_shoff = Obj.SHOff;
1722 Ehdr.e_shnum = 0;
1724 Ehdr.e_shnum = Shnum;
1732 Ehdr.e_shstrndx = SHN_XINDEX;
1734 Ehdr.e_shstrndx = Obj.SectionNames->Index;
1736 Ehdr.e_shentsize = 0;
1737 Ehdr.e_shoff = 0;
1738 Ehdr.e_shnum = 0;
1739 Ehdr.e_shstrndx = 0;
1753 Shdr.sh_name = 0;
1754 Shdr.sh_type = SHT_NULL;
1755 Shdr.sh_flags = 0;
1756 Shdr.sh_addr = 0;
1757 Shdr.sh_offset = 0;
1761 Shdr.sh_size = Shnum;
1763 Shdr.sh_size = 0;
1766 Shdr.sh_link = Obj.SectionNames->Index;
1768 Shdr.sh_link = 0;
1769 Shdr.sh_info = 0;
1770 Shdr.sh_addralign = 0;
1771 Shdr.sh_entsize = 0;
tools/llvm-pdbutil/YAMLOutputStyle.cpp 87 Obj.Headers->SuperBlock.NumBlocks = File.getBlockCount();
88 Obj.Headers->SuperBlock.BlockMapAddr = File.getBlockMapIndex();
89 Obj.Headers->SuperBlock.BlockSize = File.getBlockSize();
93 Obj.Headers->SuperBlock.NumDirectoryBytes = File.getNumDirectoryBytes();
96 Obj.Headers->SuperBlock.FreeBlockMapBlock = File.getFreeBlockMapBlock();
97 Obj.Headers->SuperBlock.Unknown1 = File.getUnknown1();
tools/llvm-rc/ResourceFileWriter.cpp 578 HeaderPrefix.DataSize = tell() - DataLoc;
579 HeaderPrefix.HeaderSize = DataLoc - HeaderLoc;
609 Entry.Flags = Obj.Flags & ~Opt::ASCII;
939 NewHeader.Cursor.Width = OldHeader.Icon.Width;
944 NewHeader.Cursor.Height = OldHeader.Icon.Height * 2;
963 NewHeader.Planes = 1;
964 NewHeader.BitCount = 32;
1478 FixedInfo.FileVersionMS = (FileVer[0] << 16) | FileVer[1];
1479 FixedInfo.FileVersionLS = (FileVer[2] << 16) | FileVer[3];
1485 FixedInfo.ProductVersionMS = (ProdVer[0] << 16) | ProdVer[1];
1486 FixedInfo.ProductVersionLS = (ProdVer[2] << 16) | ProdVer[3];
1488 FixedInfo.FileFlagsMask = GetField(VersionInfoFixed::FtFileFlagsMask)[0];
1489 FixedInfo.FileFlags = GetField(VersionInfoFixed::FtFileFlags)[0];
1490 FixedInfo.FileOS = GetField(VersionInfoFixed::FtFileOS)[0];
1491 FixedInfo.FileType = GetField(VersionInfoFixed::FtFileType)[0];
1492 FixedInfo.FileSubtype = GetField(VersionInfoFixed::FtFileSubtype)[0];
tools/llvm-readobj/ARMEHABIPrinter.h 418 RelA.r_addend = 0;
tools/llvm-readobj/ELFDumper.cpp 3035 Rela.r_addend = 0;
3723 Rela.r_addend = 0;
3758 Rela.r_addend = 0;
5275 Rela.r_addend = 0;
5539 Rela.r_addend = 0;
5557 Rela.r_addend = 0;
unittests/DebugInfo/MSF/MSFBuilderTest.cpp 26 SB.NumBlocks = 1000;
27 SB.NumDirectoryBytes = 8192;
34 SB.FreeBlockMapBlock = 1;
35 SB.BlockMapAddr = 1;
36 SB.BlockSize = 4096;
37 SB.NumDirectoryBytes = 0;
38 SB.NumBlocks = 2; // one for the Super Block, one for the directory
64 SB.BlockMapAddr = 0;
69 SB.BlockSize = 3120;
74 SB.NumDirectoryBytes = SB.BlockSize * SB.BlockSize / 4;
76 SB.NumDirectoryBytes = SB.NumDirectoryBytes + 4;
unittests/DebugInfo/MSF/MSFCommonTest.cpp 27 SB.FreeBlockMapBlock = 1;
28 SB.BlockSize = 4096;
33 SB.NumBlocks = 12;
37 SB.NumBlocks = SB.BlockSize + 1;
39 SB.NumBlocks = SB.BlockSize * 8;
41 SB.NumBlocks = SB.BlockSize * 8 + 1;
44 SB.NumBlocks = 12;
48 SB.NumBlocks = SB.BlockSize * 8;
95 SB.FreeBlockMapBlock = 1;
98 SB.BlockSize = 4096;
104 SB.NumBlocks = 8000;
116 SB.NumBlocks = SB.BlockSize * 8 + 1;
132 SB.NumBlocks = SB.BlockSize * 8 + 3;
unittests/DebugInfo/MSF/MappedBlockStreamTest.cpp 508 SB.FreeBlockMapBlock = 1;
509 SB.BlockSize = 4096;
516 SB.NumBlocks = NumFileBlocks;
unittests/Support/YAMLIOTest.cpp 552 map.u64 = 6000000000ULL;
553 map.u32 = 3000000000U;
554 map.u16 = 50000;
555 map.s64 = -6000000000LL;
556 map.s32 = -2000000000;
557 map.s16 = -32000;
558 map.f = 3.25f;
559 map.d = -2.8625;
644 map.LittleEnum = Enum::Two;
645 map.BigEnum = Enum::One;
646 map.LittleBitset = BitsetEnum::OneZero | BitsetEnum::ZeroOne;
647 map.BigBitset = BitsetEnum::OneZero;
usr/include/c++/7.4.0/bits/stl_algobase.h 324 *__result = *__first;