[yaml2obj] - Introduce the "Offset" property for sections.

[grimar]

Summary

Currently there is no good way to set a physical offset for a section:

• We have the ShOffset that allows to override the sh_offset, but it does not affect the real data written.
• We can use a Filler to create an artificial gap, but it is more like a hack rather than a proper solution for this problem.

This patch adds the Offset property which allows setting physical
offsets for sections.

It also generalizes the code, so that we set sh_offset field in one place.

[jhenderson]

llvm/lib/ObjectYAML/ELFEmitter.cpp

302–303

This comment looks stale to me. It doesn't even read right.

451–452

I think this comment needs to make clear that the code block it accompanies sets the offset of all sections. How about "Set the offset for all sections, except the SHN_UNDEF section with index 0 when not explicitly requested."?

453

Perhaps IsFirstUndefSection would be a bit clearer.

485

"The SHT_NOBITS section does" -> "SHT_NOBITS sections do not"

1027–1030

Should we really be reporting this error? I could imagine people wanting to create broken ELFs with a section at a specific offset and an alignment that doesn't match up.

(Also "requested alignment" is more correct - adjectives generally come before their nouns)

1035–1036

I can see why you've done this, but I think there's also a use-case for a section header table where the sections aren't in offset order, which I believe would run into this problem. You could use the SHOffset field instead, but that has its own problems (doesn't place data at the specified location, shouldn't be included in program header calculations etc).

llvm/test/tools/yaml2obj/ELF/section-offset.yaml

9

I'm not sure there's much point in this check?

39

I'm not sure this size check adds anything. The fact that the .strtab section's offset also increases is surely sufficient?

69–70

Replace with cmp %t1 %t3?

90

Rather than checking the file size, I think a clearer thing to do would be to check the offset of the section header table to show that it is/isn't impacted by the section's offset.

[grimar]

• Addressed review comments.

llvm/lib/ObjectYAML/ELFEmitter.cpp

1027–1030

I wasn't sure about this error, but using both "AddressAlign" and "Offset" in a YAML probably might lead to confusion:

Sections:
  - Name:         .bar
    Type:         SHT_PROGBITS
    Size:         0x10
    Offset:       0x100
    AddressAlign: 0x1000

Usually AddressAlign affects the offset. I.e. it is not a regular field that just sets a value.
And so it might raise a question: should an Offset be aligned by AddressAlign? Or should we use the Offset given and just ignore AddressAligns usual logic?

I am not sure we want to silently allow this combination (when an alignment doesn't match up).

Currently there is a way to achieve what you describe: it should be possible to use Filler(s) + ShOffset + AddressAlign to create any layout.
Perhaps it is sufficient?

1035–1036

yaml2obj does not support writing section out of order currently. This patch has no intention to change this.
We always write sections in the same order they are listed in a YAML.

To implement what you want perhaps we might want just to introduce another field, like "SectionHeaderIndex".
Or may be expand YAML format to it allow to describe section header table (and may be it's location) explicitly.

llvm/test/tools/yaml2obj/ELF/section-offset.yaml

9

Removed.

39

The fact that the .strtab section's offset also increases is surely sufficient?

If we assume that is not broken/overridden, then - yes.

[MaskRay]

llvm/lib/ObjectYAML/ELFEmitter.cpp

1027–1030

For SHT_NOBITS sections, sh_offset%sh_addralign!=0 is possible (sh_offset for SHT_NOBITS can generally be ignored). lld can create such output (ELF/Writer.cpp:computeFileOffset).

1035–1036

alignToOffset(sec) can be called according to the section offset order in Doc.Chunks in ELFState<ELFT>::initSectionHeaders may be sufficient, but I haven't tried.

[grimar]

llvm/lib/ObjectYAML/ELFEmitter.cpp

1035–1036

alignToOffset(sec) can be called according to the section offset order in Doc.Chunks in ELFState<ELFT>::initSectionHeaders may be sufficient.

Not sure I understand what you suggest? Calling of alignToOffset in initSectionHeaders is what this patch does already.

[jhenderson]

llvm/lib/ObjectYAML/ELFEmitter.cpp

303–306

section header -> section header table (or section headers)

The ELF header?

I thought someone made a change a while back to write the section header table at the end anyway? Or am I getting mixed up with a different thing?

485

Missed a bit:

section -> sections

1027–1030

I am not sure we want to silently allow this combination (when an alignment doesn't match up).

I'd probably suggest ignoring the alignment in this situation, since the Offset is more explicit - if I specified an Offset that was deliberately not aligned, I'd probably still expect it to get respected, and the alignment field just used to set the sh_addralign value.

You could add a warning if you wanted, but since those aren't likely to be seen, I'm not sure how useful that is.

llvm/test/tools/yaml2obj/ELF/section-offset.yaml

69–70

This referred to the llvm-readelf line. We don't need to do llvm-readelf twice, if the two outputs should be binary identical. Use cmp instead.

111

in Case 1.

[grimar]

• Addressed review comments.

llvm/lib/ObjectYAML/ELFEmitter.cpp

303–306

No, you are right, it is written to the end. I've broke this comment during rewriting somehow :/ Fixed.

1027–1030

OK. Done.

[MaskRay]

llvm/lib/ObjectYAML/ELFEmitter.cpp

1035–1036

Sorry for the confusion. I mean (in a future change), we may change the order ELFState<ELFT>::alignToOffset is called on each section. We call alignToOffset following the order of section offsets. This may allow out-of-order sh_offset fields in the section header table.

https://reviews.llvm.org/D78422#1991831 says

FWIW in embedded systems it is quite common to have linker scripts where different OutputSections need to be copied to various disjoint memory locations and these are often not in order of ascending address.

[grimar]

llvm/lib/ObjectYAML/ELFEmitter.cpp

1035–1036

What I do not like in idea of allowing disordered offsets is:

1. It might open a worm can: it will be easy to create overlapping sections or something alike. We then might want the code to diagnose it,

but it sounds a bit too complex and probably not what we want.

2. Out logic of creating program headers assumes that chunks are ordered by offsets. Changing this assumption will introduce an additional complexity there.

I am thinking about the possible extending the YAML instead. E.g. we could have something like:

--- !ELF
FileHeader:
  Class:   ELFCLASS64
  Data:    ELFDATA2LSB
  Type:    ET_REL
  Machine: EM_X86_64
  SectionHeader:
    Location: <location> ## before sections/after sections
    Sections:
      - .foo
      - .bar
Sections:
  - Name:  .foo
    Type:  SHT_PROGBITS
    Size:  0x8
...

The benefit is that it is more flexible and should not touch the rest of the code.

[grimar]

llvm/lib/ObjectYAML/ELFEmitter.cpp

1035–1036

SectionHeader in my sample should not be a part of FileHeader probably. E.g:

--- !ELF
FileHeader:
  Class:   ELFCLASS64
  Data:    ELFDATA2LSB
  Type:    ET_REL
  Machine: EM_X86_64
Sections:
  - Name:  .foo
    Type:  SHT_PROGBITS
    Size:  0x8
...
SectionHeader:
    Location: <location> ## before sections/after sections
    Sections:
      - .foo
      - .bar

[grimar]

Ping. @jhenderson, are you OK to land it?

[jhenderson]

In D78927#2031198, @grimar wrote:

Ping. @jhenderson, are you OK to land it?

Huh. This somehow fell through the cracks. I'll look at it tomorrow.

[jhenderson]

llvm/lib/ObjectYAML/ELFEmitter.cpp

221

They're not going to be that common, but sh_addralign and p_align are both 64-bit values for ELF64, so Align should be uint64_t here.

453

Nit: There's a double space after the variable name.

1032

Maybe worth a comment explicitly saying we ignore alignment when an explicit offset has been requested, just to show that it is 100% intentional.

1035–1036

Sounds reasonable, though I'd suggest a couple of minor changes: 1) Call it SectionHeaders or SectionHeaderTable; 2) Allow it to take an explicit Offset maybe, possibly instead of Location, any maybe even add special values for Offset like AutoBefore, and AutoAfter or something like that.

llvm/test/tools/yaml2obj/ELF/custom-null-section.yaml

205–206

The offset of a SHT_NULL section probably shouldn't affect that of other sections, since it is supposed to be "inactive". Not sure if it should be part of this change, but we should have a test case for it.

207–210

Any particular reason these aren't one test, with two SHT_NULL sections?

llvm/test/tools/yaml2obj/ELF/section-offset.yaml

5

This comment needs updating, since you're checking the section header table offset now.

96

"in Case 1" or "in the first case"

99

the 'Offset' field
the 'ShOffset' field

114

Ditto.

115

only affects the

[grimar]

• Addressed review comments.

llvm/test/tools/yaml2obj/ELF/custom-null-section.yaml

205–206

The offset of a SHT_NULL section probably shouldn't affect that of other sections, since it is supposed to be "inactive"

Not sure I understood this point right, but I see no reason to make an exception for it:
It is special and that is why we "do not write any content for special SHN_UNDEF section". We are currently able to override its sh_size, sh_info and sh_entsize though. But the offset is not a property of a section. I.e. it has no field like sh_offset.
If a person adds Offset: xx in a YAML for any section, it should have an effect and following sections should have offsets greater or equal to it anyways (unless ShOffset is used to override it).

207–210

yaml2obj normally creates a SHT_NULL section at index 0 implicitly:

// Insert SHT_NULL section implicitly when it is not defined in YAML.
if (Sections.empty() || Sections.front()->Type != ELF::SHT_NULL)
  Doc.Chunks.insert(
      Doc.Chunks.begin(),
      std::make_unique<ELFYAML::Section>(
          ELFYAML::Chunk::ChunkKind::RawContent, /*IsImplicit=*/true));

This patch adds the following code:

if (!IsFirstUndefSection || Sec->Offset)
  SHeader.sh_offset = alignToOffset(CBA, SHeader.sh_addralign, Sec->Offset);

I.e. the first SHT_NULL section is special, and I've added the code to handle the "Offset" properly.
Others SHT_NULL are not special. And I am testing here that
setting an Offset for such sections affects the start of the section headers. For that I need to set
different offsets for it and test the result.

llvm/test/tools/yaml2obj/ELF/section-offset.yaml

5

Actually what I think we want to show is that the Offset key might affect the file size.
It is the main difference with the ShOffset property which never can affect it.
Currently (since you asked to remove the file size test previously) it is tested implicitly:
the Offset changes physical offsets of the following sections, but still worth to mention I think.

Changing of the section header table offset is a size effect. If it was placed before sections and not after,
it would not change.

[jhenderson]

LGTM, with one remaining suggestion.

llvm/test/tools/yaml2obj/ELF/section-offset.yaml

5

I guess more generally, changing the Offset field changes the layout of the file. Consequently, anything appearing after the section will have a higher offset than it might otherwise do (including sections, the section header table, and the end of the file). Perhaps we should update the comment to say that:

"Show that it can affect the layout of the rest of the file."

[grimar]

llvm/lib/ObjectYAML/ELFEmitter.cpp

48

FTR, after commiting this patch I faced LLD test failture and fixed it:
https://github.com/llvm/llvm-project/commit/969c63a2ecfb536062ff2174645abe31e4036067
(it started to report "section [index 1] has a sh_offset (0x1000000000000000) + sh_size (0x4) that is greater than the file size (0x100000120)" instead of "section sh_addralign is too large" LLD's error)

The issue was related to "AddressAlign: 0x1000000000000000" line in the YAML:

- Name:            .text
  Type:            SHT_PROGBITS
  Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
  AddressAlign:    0x1000000000000000
  Content:         "00000000"

Previously, we had this piece of code which used unsigned, so AddressAlign was truncated.
As a result a little binary with sh_addrallign==0x1000000000000000 was produced.
After this patch, this piece does not exist and currently for that test a 500mb binary with with sh_addrallign==0x1000000000000000 is produced. I.e. it works a bit more correct, but
the binary is is still truncated.

It happens because of ELFState<ELFT>::alignToOffset, which has the following lines:

CBA.getOS().write_zeros(AlignedOffset - CurrentOffset);
return AlignedOffset;

AlignedOffset and CurrectOffset are uint64_t, but raw_ostream::write_zeros takes unsigned:

/// indent - Insert 'NumSpaces' spaces.
raw_ostream &raw_ostream::indent(unsigned NumSpaces) {
  return write_padding<' '>(*this, NumSpaces);
}

/// write_zeros - Insert 'NumZeros' nulls.
raw_ostream &raw_ostream::write_zeros(unsigned NumZeros) {
  return write_padding<'\0'>(*this, NumZeros);
}

Probably we want to change it to take uint64_t.
I do not think there is a way to write a test for it though as the result output would be huge.

[grimar]

llvm/lib/ObjectYAML/ELFEmitter.cpp

48

Ind I do not believe someone really needs uint64_t there to put so many zeroes, so I am not sure if we want to change it for "correctness" or not.

[jhenderson]

llvm/lib/ObjectYAML/ELFEmitter.cpp

48

You're probably right that nobody is likely to need to write that many zeroes at once, but should we have something instead that prevents a silent truncation? Fixing the issue would of course be one way of doing it.

[grimar]

llvm/lib/ObjectYAML/ELFEmitter.cpp

48

What if we limit the size of the object produced by yaml2obj to something? E.g 10mb. And introduce an option to change this limit.
Since it is used often for writing test cases, the outputs produced ideally should be small. And such limit would also allow to catch this and possible other mistakes that might lead to huge binaries. (I am thinking about the Offset field which might cause the same).

And I guess we can change write_zeros to take uint64_t, but error out when NumZeros>UINT32_MAX there too.

[jhenderson]

llvm/lib/ObjectYAML/ELFEmitter.cpp

48

I have nothing against a file size limit in yaml2obj, as long as it doesn't significantly increase complexity. It's probably a good safety net.

I'll leave it up to you what to do about write_zeros. I don't have a strong opinion on it.

llvm/include/llvm/ObjectYAML/ELFYAML.h

 
 struct Section : public Chunk {
   ELF_SHT Type;
   Optional<ELF_SHF> Flags;
   Optional<llvm::yaml::Hex64> Address;
   StringRef Link;
   llvm::yaml::Hex64 AddressAlign;
   Optional<llvm::yaml::Hex64> EntSize;
+  Optional<llvm::yaml::Hex64> Offset;
 
   // Usually sections are not created implicitly, but loaded from YAML.
   // When they are, this flag is used to signal about that.
   bool IsImplicit;
 
   // Holds the original section index.
   unsigned OriginalSecNdx;
 

llvm/lib/ObjectYAML/ELFEmitter.cpp

class ContiguousBlobAccumulator {
   const uint64_t InitialOffset;
   SmallVector<char, 128> Buf;
   raw_svector_ostream OS;
 
 public:
   ContiguousBlobAccumulator(uint64_t InitialOffset_)
       : InitialOffset(InitialOffset_), Buf(), OS(Buf) {}
 
-  template <class Integer>
-  raw_ostream &getOSAndAlignedOffset(Integer &Offset, unsigned Align) {
-    Offset = padToAlignment(Align);
-    return OS;
-  }
+  uint64_t getOffset() const { return InitialOffset + OS.tell(); }
+  raw_ostream &getOS() { return OS; }
 
   /// \returns The new offset.
   uint64_t padToAlignment(unsigned Align) {
     if (Align == 0)
       Align = 1;
-    uint64_t CurrentOffset = InitialOffset + OS.tell();
+    uint64_t CurrentOffset = getOffset();
     uint64_t AlignedOffset = alignTo(CurrentOffset, Align);
     OS.write_zeros(AlignedOffset - CurrentOffset);
     return AlignedOffset; // == CurrentOffset;
   }
 
   void writeBlobToStream(raw_ostream &Out) { Out << OS.str(); }
 };
 
void writeSectionContent(Elf_Shdr &SHeader,
                            ContiguousBlobAccumulator &CBA);
 
   void writeFill(ELFYAML::Fill &Fill, ContiguousBlobAccumulator &CBA);
 
   ELFState(ELFYAML::Object &D, yaml::ErrorHandler EH);
 
   void assignSectionAddress(Elf_Shdr &SHeader, ELFYAML::Section *YAMLSec);
 
+  uint64_t alignToOffset(ContiguousBlobAccumulator &CBA, uint64_t Align,
+                         llvm::Optional<llvm::yaml::Hex64> Offset);
+
 public:
   static bool writeELF(raw_ostream &OS, ELFYAML::Object &Doc,
                        yaml::ErrorHandler EH);
 };
 } // end anonymous namespace
 
 template <class T> static size_t arrayDataSize(ArrayRef<T> A) {
   return A.size() * sizeof(T);
void ELFState<ELFT>::writeELFHeader(ContiguousBlobAccumulator &CBA, raw_ostream &OS) {
   Header.e_entry = Doc.Header.Entry;
   Header.e_phoff = Doc.ProgramHeaders.size() ? sizeof(Header) : 0;
   Header.e_flags = Doc.Header.Flags;
   Header.e_ehsize = sizeof(Elf_Ehdr);
   Header.e_phentsize = Doc.ProgramHeaders.size() ? sizeof(Elf_Phdr) : 0;
   Header.e_phnum = Doc.ProgramHeaders.size();
 
   Header.e_shentsize =
       Doc.Header.SHEntSize ? (uint16_t)*Doc.Header.SHEntSize : sizeof(Elf_Shdr);
-  // Immediately following the ELF header and program headers.
-  // Align the start of the section header and write the ELF header.
-  uint64_t SHOff;
-  CBA.getOSAndAlignedOffset(SHOff, sizeof(typename ELFT::uint));
+  // Align the start of the section header table, which is written after all
+  // other sections to the end of the file.
+  uint64_t SHOff =
+      alignToOffset(CBA, sizeof(typename ELFT::uint), /*Offset=*/None);
   Header.e_shoff =
       Doc.Header.SHOff ? typename ELFT::uint(*Doc.Header.SHOff) : SHOff;
   Header.e_shnum =
       Doc.Header.SHNum ? (uint16_t)*Doc.Header.SHNum : Doc.getSections().size();
   Header.e_shstrndx = Doc.Header.SHStrNdx ? (uint16_t)*Doc.Header.SHStrNdx
                                           : SN2I.get(".shstrtab");
 
   OS.write((const char *)&Header, sizeof(Header));
void ELFState<ELFT>::initSectionHeaders(std::vector<Elf_Shdr> &SHeaders,
                                         ContiguousBlobAccumulator &CBA) {
   // Ensure SHN_UNDEF entry is present. An all-zero section header is a
   // valid SHN_UNDEF entry since SHT_NULL == 0.
   SHeaders.resize(Doc.getSections().size());
 
   size_t SecNdx = -1;
   for (const std::unique_ptr<ELFYAML::Chunk> &D : Doc.Chunks) {
     if (auto S = dyn_cast<ELFYAML::Fill>(D.get())) {
+      S->ShOffset = alignToOffset(CBA, /*Align=*/1, /*Offset=*/None);
       writeFill(*S, CBA);
       LocationCounter += S->Size;
       continue;
     }
 
     ++SecNdx;
     ELFYAML::Section *Sec = cast<ELFYAML::Section>(D.get());
     if (SecNdx == 0 && Sec->IsImplicit)
for (const std::unique_ptr<ELFYAML::Chunk> &D : Doc.Chunks) {
 
     SHeader.sh_name =
         DotShStrtab.getOffset(ELFYAML::dropUniqueSuffix(Sec->Name));
     SHeader.sh_type = Sec->Type;
     if (Sec->Flags)
       SHeader.sh_flags = *Sec->Flags;
     SHeader.sh_addralign = Sec->AddressAlign;
 
+    // Set the offset for all sections, except the SHN_UNDEF section with index
+    // 0 when not explicitly requested.
+    bool IsFirstUndefSection = SecNdx == 0;
+    if (!IsFirstUndefSection || Sec->Offset)
+      SHeader.sh_offset = alignToOffset(CBA, SHeader.sh_addralign, Sec->Offset);
+
     assignSectionAddress(SHeader, Sec);
 
     if (!Sec->Link.empty())
       SHeader.sh_link = toSectionIndex(Sec->Link, Sec->Name);
 
-    if (SecNdx == 0) {
+    if (IsFirstUndefSection) {
       if (auto RawSec = dyn_cast<ELFYAML::RawContentSection>(Sec)) {
         // We do not write any content for special SHN_UNDEF section.
         if (RawSec->Size)
           SHeader.sh_size = *RawSec->Size;
         if (RawSec->Info)
           SHeader.sh_info = *RawSec->Info;
       }
       if (Sec->EntSize)
         SHeader.sh_entsize = *Sec->EntSize;
     } else if (auto S = dyn_cast<ELFYAML::RawContentSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::SymtabShndxSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::RelocationSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::RelrSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::Group>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::MipsABIFlags>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::NoBitsSection>(Sec)) {
+      // SHT_NOBITS sections do not have any content to write.
       SHeader.sh_entsize = 0;
       SHeader.sh_size = S->Size;
-      // SHT_NOBITS section does not have content
-      // so just to setup the section offset.
-      CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
     } else if (auto S = dyn_cast<ELFYAML::DynamicSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::SymverSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::VerneedSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::VerdefSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
SHeader.sh_info = (RawSec && RawSec->Info) ? (unsigned)(*RawSec->Info)
                                              : findFirstNonGlobal(Symbols) + 1;
   SHeader.sh_entsize = (YAMLSec && YAMLSec->EntSize)
                            ? (uint64_t)(*YAMLSec->EntSize)
                            : sizeof(Elf_Sym);
   SHeader.sh_addralign = YAMLSec ? (uint64_t)YAMLSec->AddressAlign : 8;
 
   assignSectionAddress(SHeader, YAMLSec);
 
-  auto &OS = CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
+  SHeader.sh_offset = alignToOffset(CBA, SHeader.sh_addralign, /*Offset=*/None);
+  raw_ostream &OS = CBA.getOS();
+
   if (RawSec && (RawSec->Content || RawSec->Size)) {
     assert(Symbols.empty());
     SHeader.sh_size = writeContent(OS, RawSec->Content, RawSec->Size);
     return;
   }
 
   std::vector<Elf_Sym> Syms =
       toELFSymbols(Symbols, IsStatic ? DotStrtab : DotDynstr);
void ELFState<ELFT>::initStrtabSectionHeader(Elf_Shdr &SHeader, StringRef Name,
   zero(SHeader);
   SHeader.sh_name = DotShStrtab.getOffset(Name);
   SHeader.sh_type = YAMLSec ? YAMLSec->Type : ELF::SHT_STRTAB;
   SHeader.sh_addralign = YAMLSec ? (uint64_t)YAMLSec->AddressAlign : 1;
 
   ELFYAML::RawContentSection *RawSec =
       dyn_cast_or_null<ELFYAML::RawContentSection>(YAMLSec);
 
-  auto &OS = CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
+  SHeader.sh_offset = alignToOffset(CBA, SHeader.sh_addralign, /*Offset=*/None);
+  raw_ostream &OS = CBA.getOS();
+
   if (RawSec && (RawSec->Content || RawSec->Size)) {
     SHeader.sh_size = writeContent(OS, RawSec->Content, RawSec->Size);
   } else {
     STB.write(OS);
     SHeader.sh_size = STB.getSize();
   }
 
   if (YAMLSec && YAMLSec->EntSize)
for (auto &YamlPhdr : Doc.ProgramHeaders) {
     }
   }
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::RawContentSection &Section,
     ContiguousBlobAccumulator &CBA) {
-  raw_ostream &OS =
-      CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
-  SHeader.sh_size = writeContent(OS, Section.Content, Section.Size);
+  SHeader.sh_size = writeContent(CBA.getOS(), Section.Content, Section.Size);
 
   if (Section.EntSize)
     SHeader.sh_entsize = *Section.EntSize;
 
   if (Section.Info)
     SHeader.sh_info = *Section.Info;
 }
 
void ELFState<ELFT>::writeSectionContent(
   // For relocation section set link to .symtab by default.
   unsigned Link = 0;
   if (Section.Link.empty() && SN2I.lookup(".symtab", Link))
     SHeader.sh_link = Link;
 
   if (!Section.RelocatableSec.empty())
     SHeader.sh_info = toSectionIndex(Section.RelocatableSec, Section.Name);
 
-  auto &OS = CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
+  raw_ostream &OS = CBA.getOS();
   for (const auto &Rel : Section.Relocations) {
     unsigned SymIdx = Rel.Symbol ? toSymbolIndex(*Rel.Symbol, Section.Name,
                                                  Section.Link == ".dynsym")
                                  : 0;
     if (IsRela) {
       Elf_Rela REntry;
       zero(REntry);
       REntry.r_offset = Rel.Offset;
for (const auto &Rel : Section.Relocations) {
     }
   }
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::RelrSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
-  raw_ostream &OS =
-      CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
   SHeader.sh_entsize =
       Section.EntSize ? uint64_t(*Section.EntSize) : sizeof(Elf_Relr);
 
+  raw_ostream &OS = CBA.getOS();
   if (Section.Content) {
     SHeader.sh_size = writeContent(OS, Section.Content, None);
     return;
   }
 
   if (!Section.Entries)
     return;
 
   for (llvm::yaml::Hex64 E : *Section.Entries) {
     if (!ELFT::Is64Bits && E > UINT32_MAX)
       reportError(Section.Name + ": the value is too large for 32-bits: 0x" +
                   Twine::utohexstr(E));
     support::endian::write<uintX_t>(OS, E, ELFT::TargetEndianness);
   }
 
   SHeader.sh_size = sizeof(uintX_t) * Section.Entries->size();
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::SymtabShndxSection &Shndx,
     ContiguousBlobAccumulator &CBA) {
-  raw_ostream &OS =
-      CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
-
   for (uint32_t E : Shndx.Entries)
-    support::endian::write<uint32_t>(OS, E, ELFT::TargetEndianness);
+    support::endian::write<uint32_t>(CBA.getOS(), E, ELFT::TargetEndianness);
 
   SHeader.sh_entsize = Shndx.EntSize ? (uint64_t)*Shndx.EntSize : 4;
   SHeader.sh_size = Shndx.Entries.size() * SHeader.sh_entsize;
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::Group &Section,
                                          ContiguousBlobAccumulator &CBA) {
   assert(Section.Type == llvm::ELF::SHT_GROUP &&
          "Section type is not SHT_GROUP");
 
   unsigned Link = 0;
   if (Section.Link.empty() && SN2I.lookup(".symtab", Link))
     SHeader.sh_link = Link;
 
   SHeader.sh_entsize = 4;
   SHeader.sh_size = SHeader.sh_entsize * Section.Members.size();
 
   if (Section.Signature)
     SHeader.sh_info =
         toSymbolIndex(*Section.Signature, Section.Name, /*IsDynamic=*/false);
 
-  raw_ostream &OS =
-      CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
-
+  raw_ostream &OS = CBA.getOS();
   for (const ELFYAML::SectionOrType &Member : Section.Members) {
     unsigned int SectionIndex = 0;
     if (Member.sectionNameOrType == "GRP_COMDAT")
       SectionIndex = llvm::ELF::GRP_COMDAT;
     else
       SectionIndex = toSectionIndex(Member.sectionNameOrType, Section.Name);
     support::endian::write<uint32_t>(OS, SectionIndex, ELFT::TargetEndianness);
   }
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::SymverSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
-  raw_ostream &OS =
-      CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
+  raw_ostream &OS = CBA.getOS();
   for (uint16_t Version : Section.Entries)
     support::endian::write<uint16_t>(OS, Version, ELFT::TargetEndianness);
 
   SHeader.sh_entsize = Section.EntSize ? (uint64_t)*Section.EntSize : 2;
   SHeader.sh_size = Section.Entries.size() * SHeader.sh_entsize;
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::StackSizesSection &Section,
     ContiguousBlobAccumulator &CBA) {
-  raw_ostream &OS =
-      CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
-
+  raw_ostream &OS = CBA.getOS();
   if (Section.Content || Section.Size) {
     SHeader.sh_size = writeContent(OS, Section.Content, Section.Size);
     return;
   }
 
   for (const ELFYAML::StackSizeEntry &E : *Section.Entries) {
     support::endian::write<uintX_t>(OS, E.Address, ELFT::TargetEndianness);
     SHeader.sh_size += sizeof(uintX_t) + encodeULEB128(E.Size, OS);
   }
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::LinkerOptionsSection &Section,
     ContiguousBlobAccumulator &CBA) {
-  raw_ostream &OS =
-      CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
-
+  raw_ostream &OS = CBA.getOS();
   if (Section.Content) {
     SHeader.sh_size = writeContent(OS, Section.Content, None);
     return;
   }
 
   if (!Section.Options)
     return;
 
   for (const ELFYAML::LinkerOption &LO : *Section.Options) {
     OS.write(LO.Key.data(), LO.Key.size());
     OS.write('\0');
     OS.write(LO.Value.data(), LO.Value.size());
     OS.write('\0');
     SHeader.sh_size += (LO.Key.size() + LO.Value.size() + 2);
   }
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::DependentLibrariesSection &Section,
     ContiguousBlobAccumulator &CBA) {
-  raw_ostream &OS =
-      CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
-
+  raw_ostream &OS = CBA.getOS();
   if (Section.Content) {
     SHeader.sh_size = writeContent(OS, Section.Content, None);
     return;
   }
 
   if (!Section.Libs)
     return;
 
   for (StringRef Lib : *Section.Libs) {
     OS.write(Lib.data(), Lib.size());
     OS.write('\0');
     SHeader.sh_size += Lib.size() + 1;
   }
 }
 
 template <class ELFT>
+uint64_t
+ELFState<ELFT>::alignToOffset(ContiguousBlobAccumulator &CBA, uint64_t Align,
+                              llvm::Optional<llvm::yaml::Hex64> Offset) {
+  uint64_t CurrentOffset = CBA.getOffset();
+  uint64_t AlignedOffset;
+
+  if (Offset) {
+    if ((uint64_t)*Offset < CurrentOffset) {
+      reportError("the 'Offset' value (0x" +
+                  Twine::utohexstr((uint64_t)*Offset) + ") goes backward");
+      return CurrentOffset;
+    }
+
+    // We ignore an alignment when an explicit offset has been requested.
+    AlignedOffset = *Offset;
+  } else {
+    AlignedOffset = alignTo(CurrentOffset, std::max(Align, (uint64_t)1));
+  }
+
+  CBA.getOS().write_zeros(AlignedOffset - CurrentOffset);
+  return AlignedOffset;
+}
+
+template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::CallGraphProfileSection &Section,
     ContiguousBlobAccumulator &CBA) {
-  raw_ostream &OS =
-      CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
-
   if (Section.EntSize)
     SHeader.sh_entsize = *Section.EntSize;
   else
     SHeader.sh_entsize = 16;
 
   unsigned Link = 0;
   if (Section.Link.empty() && SN2I.lookup(".symtab", Link))
     SHeader.sh_link = Link;
 
+  raw_ostream &OS = CBA.getOS();
   if (Section.Content) {
     SHeader.sh_size = writeContent(OS, Section.Content, None);
     return;
   }
 
   if (!Section.Entries)
     return;
 
   for (const ELFYAML::CallGraphEntry &E : *Section.Entries) {
     unsigned From = toSymbolIndex(E.From, Section.Name, /*IsDynamic=*/false);
     unsigned To = toSymbolIndex(E.To, Section.Name, /*IsDynamic=*/false);
 
     support::endian::write<uint32_t>(OS, From, ELFT::TargetEndianness);
     support::endian::write<uint32_t>(OS, To, ELFT::TargetEndianness);
     support::endian::write<uint64_t>(OS, E.Weight, ELFT::TargetEndianness);
     SHeader.sh_size += 16;
   }
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::HashSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
-  raw_ostream &OS =
-      CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
-
   unsigned Link = 0;
   if (Section.Link.empty() && SN2I.lookup(".dynsym", Link))
     SHeader.sh_link = Link;
 
+  raw_ostream &OS = CBA.getOS();
   if (Section.Content || Section.Size) {
     SHeader.sh_size = writeContent(OS, Section.Content, Section.Size);
     return;
   }
 
   support::endian::write<uint32_t>(
       OS, Section.NBucket.getValueOr(llvm::yaml::Hex64(Section.Bucket->size())),
       ELFT::TargetEndianness);

 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::VerdefSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   typedef typename ELFT::Verdef Elf_Verdef;
   typedef typename ELFT::Verdaux Elf_Verdaux;
-  raw_ostream &OS =
-      CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
 
   SHeader.sh_info = Section.Info;
 
+  raw_ostream &OS = CBA.getOS();
   if (Section.Content) {
     SHeader.sh_size = writeContent(OS, Section.Content, None);
     return;
   }
 
   if (!Section.Entries)
     return;
 

 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::VerneedSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   typedef typename ELFT::Verneed Elf_Verneed;
   typedef typename ELFT::Vernaux Elf_Vernaux;
 
-  auto &OS = CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
   SHeader.sh_info = Section.Info;
 
+  raw_ostream &OS = CBA.getOS();
   if (Section.Content) {
     SHeader.sh_size = writeContent(OS, Section.Content, None);
     return;
   }
 
   if (!Section.VerneedV)
     return;
 
void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
   assert(Section.Type == llvm::ELF::SHT_MIPS_ABIFLAGS &&
          "Section type is not SHT_MIPS_ABIFLAGS");
 
   object::Elf_Mips_ABIFlags<ELFT> Flags;
   zero(Flags);
   SHeader.sh_entsize = sizeof(Flags);
   SHeader.sh_size = SHeader.sh_entsize;
 
-  auto &OS = CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
   Flags.version = Section.Version;
   Flags.isa_level = Section.ISALevel;
   Flags.isa_rev = Section.ISARevision;
   Flags.gpr_size = Section.GPRSize;
   Flags.cpr1_size = Section.CPR1Size;
   Flags.cpr2_size = Section.CPR2Size;
   Flags.fp_abi = Section.FpABI;
   Flags.isa_ext = Section.ISAExtension;
   Flags.ases = Section.ASEs;
   Flags.flags1 = Section.Flags1;
   Flags.flags2 = Section.Flags2;
-  OS.write((const char *)&Flags, sizeof(Flags));
+  CBA.getOS().write((const char *)&Flags, sizeof(Flags));
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::DynamicSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   assert(Section.Type == llvm::ELF::SHT_DYNAMIC &&
          "Section type is not SHT_DYNAMIC");
 
   if (!Section.Entries.empty() && Section.Content)
     reportError("cannot specify both raw content and explicit entries "
                 "for dynamic section '" +
                 Section.Name + "'");
 
   if (Section.Content)
     SHeader.sh_size = Section.Content->binary_size();
   else
     SHeader.sh_size = 2 * sizeof(uintX_t) * Section.Entries.size();
   if (Section.EntSize)
     SHeader.sh_entsize = *Section.EntSize;
   else
     SHeader.sh_entsize = sizeof(Elf_Dyn);
 
-  raw_ostream &OS =
-      CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
+  raw_ostream &OS = CBA.getOS();
   for (const ELFYAML::DynamicEntry &DE : Section.Entries) {
     support::endian::write<uintX_t>(OS, DE.Tag, ELFT::TargetEndianness);
     support::endian::write<uintX_t>(OS, DE.Val, ELFT::TargetEndianness);
   }
   if (Section.Content)
     Section.Content->writeAsBinary(OS);
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::AddrsigSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
-  raw_ostream &OS =
-      CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
-
   unsigned Link = 0;
   if (Section.Link.empty() && SN2I.lookup(".symtab", Link))
     SHeader.sh_link = Link;
 
+  raw_ostream &OS = CBA.getOS();
   if (Section.Content || Section.Size) {
     SHeader.sh_size = writeContent(OS, Section.Content, Section.Size);
     return;
   }
 
   for (StringRef Sym : *Section.Symbols)
     SHeader.sh_size += encodeULEB128(
         toSymbolIndex(Sym, Section.Name, /*IsDynamic=*/false), OS);
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::NoteSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
-  raw_ostream &OS =
-      CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
+  raw_ostream &OS = CBA.getOS();
   uint64_t Offset = OS.tell();
-
   if (Section.Content || Section.Size) {
     SHeader.sh_size = writeContent(OS, Section.Content, Section.Size);
     return;
   }
 
   for (const ELFYAML::NoteEntry &NE : *Section.Notes) {
     // Write name size.
     if (NE.Name.empty())
void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
 
   SHeader.sh_size = OS.tell() - Offset;
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::GnuHashSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
-  raw_ostream &OS =
-      CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
-
   unsigned Link = 0;
   if (Section.Link.empty() && SN2I.lookup(".dynsym", Link))
     SHeader.sh_link = Link;
 
+  raw_ostream &OS = CBA.getOS();
   if (Section.Content) {
     SHeader.sh_size = writeContent(OS, Section.Content, None);
     return;
   }
 
   // We write the header first, starting with the hash buckets count. Normally
   // it is the number of entries in HashBuckets, but the "NBuckets" property can
   // be used to override this field, which is useful for producing broken
SHeader.sh_size = 16 /*Header size*/ +
                     Section.BloomFilter->size() * sizeof(typename ELFT::uint) +
                     Section.HashBuckets->size() * 4 +
                     Section.HashValues->size() * 4;
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeFill(ELFYAML::Fill &Fill,
                                ContiguousBlobAccumulator &CBA) {
-  raw_ostream &OS = CBA.getOSAndAlignedOffset(Fill.ShOffset, /*Align=*/1);
-
+  raw_ostream &OS = CBA.getOS();
   size_t PatternSize = Fill.Pattern ? Fill.Pattern->binary_size() : 0;
   if (!PatternSize) {
     OS.write_zeros(Fill.Size);
     return;
   }
 
   // Fill the content with the specified pattern.
   uint64_t Written = 0;

llvm/lib/ObjectYAML/ELFYAML.cpp

 static void commonSectionMapping(IO &IO, ELFYAML::Section &Section) {
   IO.mapOptional("Name", Section.Name, StringRef());
   IO.mapRequired("Type", Section.Type);
   IO.mapOptional("Flags", Section.Flags);
   IO.mapOptional("Address", Section.Address);
   IO.mapOptional("Link", Section.Link, StringRef());
   IO.mapOptional("AddressAlign", Section.AddressAlign, Hex64(0));
   IO.mapOptional("EntSize", Section.EntSize);
+  IO.mapOptional("Offset", Section.Offset);
 
   // obj2yaml does not dump these fields. They are expected to be empty when we
   // are producing YAML, because yaml2obj sets appropriate values for them
   // automatically when they are not explicitly defined.
   assert(!IO.outputting() ||
          (!Section.ShOffset.hasValue() && !Section.ShSize.hasValue() &&
           !Section.ShName.hasValue() && !Section.ShFlags.hasValue()));
   IO.mapOptional("ShName", Section.ShName);

llvm/test/tools/yaml2obj/ELF/custom-null-section.yaml

FileHeader:
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Type:     SHT_NULL
     Size:     0x2
     ShOffset: 0x7
     ShSize:   0x8
+
+## Check that we can set an offset for the SHT_NULL section explicitly using the "Offset" key.
+## Check it affects the section header table offset.
+# RUN: yaml2obj --docnum=10 %s -DOFFSET=0x100 -o %t10
+# RUN: llvm-readelf --headers --sections %t10 | FileCheck %s --check-prefix=EXPLICIT-OFFSET-A
+# RUN: yaml2obj --docnum=10 %s -DOFFSET=0x200 -o %t11
+# RUN: llvm-readelf --headers --sections %t11 | FileCheck %s --check-prefix=EXPLICIT-OFFSET-B
+
+# EXPLICIT-OFFSET-A:      Start of section headers: 280 (bytes into file)
+# EXPLICIT-OFFSET-A:      [Nr] Name  Type Address          Off
+# EXPLICIT-OFFSET-A-NEXT: [ 0]       NULL 0000000000000000 000100
+
+# EXPLICIT-OFFSET-B:      Start of section headers: 536 (bytes into file)
+# EXPLICIT-OFFSET-B:      [Nr] Name  Type Address          Off
+# EXPLICIT-OFFSET-B-NEXT: [ 0]       NULL 0000000000000000 000200
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Type:   SHT_NULL
+    Offset: [[OFFSET]]

llvm/test/tools/yaml2obj/ELF/section-offset.yaml

+## Check we are able to set an offset field for sections using the 'Offset' key.
+
+## Show how the 'Offset' field key can be used.
+## Show that it can affect the layout of the rest of the file.
+
+# RUN: yaml2obj --docnum=1 %s -o %t1
+# RUN: llvm-readelf --sections %t1 | FileCheck %s --check-prefix=DEFAULT
+
+# DEFAULT:      [Nr] Name      Type     Address          Off
+# DEFAULT:      [ 1] .foo      PROGBITS 0000000000000000 000040
+# DEFAULT-NEXT: [ 2] .bar      PROGBITS 0000000000000000 000048
+# DEFAULT-NEXT: [ 3] .strtab   STRTAB   0000000000000000 000058
+# DEFAULT-NEXT: [ 4] .shstrtab STRTAB   0000000000000000 000059
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name:  .foo
+    Type:  SHT_PROGBITS
+    Size:  0x8
+  - Name:         .bar
+    Type:         SHT_PROGBITS
+    Size:         0x10
+## It is a no-op. We set it to reduce amount
+## of differences with the second YAML below.
+    AddressAlign: 0x0
+
+## The same as previous, but an arbitrary 'Offset' is set for the .bar section.
+# RUN: yaml2obj --docnum=2 %s -o %t2 -DOFFSET=0x50 -DALIGN=0x0
+# RUN: llvm-readelf --sections %t2 | FileCheck %s --check-prefix=OFFSET
+
+# OFFSET:      [Nr] Name      Type     Address          Off
+# OFFSET:      [ 1] .foo      PROGBITS 0000000000000000 000040
+# OFFSET-NEXT: [ 2] .bar      PROGBITS 0000000000000000 000050
+# OFFSET-NEXT: [ 3] .strtab   STRTAB   0000000000000000 000060
+# OFFSET-NEXT: [ 4] .shstrtab STRTAB   0000000000000000 000061
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name:   .foo
+    Type:   SHT_PROGBITS
+    Size:   0x8
+  - Name:         .bar
+    Type:         SHT_PROGBITS
+    Size:         0x10
+    Offset:       [[OFFSET]]
+    AddressAlign: [[ALIGN]]
+
+## Set the 'Offset' to the same value as was set by default to show
+## that there is no difference in the output in this case.
+# RUN: yaml2obj --docnum=2 %s -o %t3 -DOFFSET=0x48 -DALIGN=0x0
+# RUN: cmp %t1 %t3
+
+## Show that we can set an offset and an address alignment independently for a section.
+# RUN: yaml2obj --docnum=2 %s -o %t4 -DOFFSET=0x48 -DALIGN=0x5
+# RUN: llvm-readelf --sections %t4 | FileCheck %s --check-prefix=OFFSET-AND-ALIGN
+
+# OFFSET-AND-ALIGN: [Nr] Name Type     Address          Off    Size   ES Flg Lk Inf Al
+# OFFSET-AND-ALIGN: [ 2] .bar PROGBITS 0000000000000000 000048 000010 00     0   0  5
+
+## Show we do not allow an 'Offset' to go backward.
+# RUN: not yaml2obj --docnum=2 %s -DOFFSET=0x47 -DALIGN=0x0 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=ERR-BACKWARD
+
+# ERR-BACKWARD: error: the 'Offset' value (0x47) goes backward
+
+## Show that the 'Offset' key can be used together with the 'ShOffset' key.
+
+## Case 1: set the same value for 'Offset' and 'ShOffset' keys.
+# RUN: yaml2obj --docnum=3 %s -o %t5 -DSHOFFSET=0x100 -DOFFSET=0x100
+# RUN: llvm-readelf --headers --sections %t5 | FileCheck %s --check-prefix=BOTH-SAME
+
+## The same offset as in the Case 3.
+# BOTH-SAME: Start of section headers: 288 (bytes into file)
+
+# BOTH-SAME:      [Nr] Name     Type     Address          Off
+# BOTH-SAME:      [ 1] .foo     PROGBITS 0000000000000000 000100
+# BOTH-SAME-NEXT: [ 2] .bar     PROGBITS 0000000000000000 000101
+# BOTH-SAME-NEXT: [ 3] .strtab  STRTAB   0000000000000000 000102
+
+## Case 2: set the 'Offset' value to be less than the 'ShOffset'.
+
+# RUN: yaml2obj --docnum=3 %s -o %t6 -DSHOFFSET=0x100 -DOFFSET=0x90
+# RUN: llvm-readelf --headers --sections %t6 | FileCheck %s --check-prefix=BOTH-A
+
+## 176 < 288 (start of section headers in Case 1).
+# BOTH-A: Start of section headers: 176 (bytes into file)
+
+## Show that the 'Offset' field sets the physical offset in a file and the `ShOffset`
+## field only overrides the sh_offset value of the .foo section.
+# BOTH-A:      [Nr] Name     Type     Address          Off
+# BOTH-A:      [ 1] .foo     PROGBITS 0000000000000000 000100
+# BOTH-A-NEXT: [ 2] .bar     PROGBITS 0000000000000000 000091
+# BOTH-A-NEXT: [ 3] .strtab  STRTAB   0000000000000000 000092
+
+## Case 3: set the 'Offset' value to be greater than the 'ShOffset' value.
+
+# RUN: yaml2obj --docnum=3 %s -o %t7 -DSHOFFSET=0x90 -DOFFSET=0x100
+# RUN: llvm-readelf --sections --headers %t7 | FileCheck %s --check-prefix=BOTH-B
+
+## The same offset as in Case 1.
+# BOTH-B: Start of section headers: 288 (bytes into file)
+
+## Show that the 'Offset' field sets the physical offset in file and `ShOffset`
+## field only affects the sh_offset value of the .foo section (overrides it).
+# BOTH-B:      [Nr] Name    Type     Address          Off
+# BOTH-B:      [ 1] .foo    PROGBITS 0000000000000000 000090
+# BOTH-B-NEXT: [ 2] .bar    PROGBITS 0000000000000000 000101
+# BOTH-B-NEXT: [ 3] .strtab STRTAB   0000000000000000 000102
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name:     .foo
+    Type:     SHT_PROGBITS
+    Size:     0x1
+    ShOffset: [[SHOFFSET]]
+    Offset:   [[OFFSET]]
+  - Name:     .bar
+    Type:     SHT_PROGBITS
+    Size:     0x1