[yaml2obj] Initial support for 32-bit XCOFF in yaml2obj.

[Esme]

Summary

This patch implements the mapping of the Yaml information to XCOFF object to enable the operation of yaml2obj.
Currently only 32-bit mode is supported.

[Esme]

1. Make more fields as possible optional.
2. Test the behaviours when the key is omitted.
3. Use the larger type for 32-bit and 64-bit.

[Esme]

Thank you so much for reviewing this patch @jhenderson @MaskRay @hubert.reinterpretcast and sorry for the late reply. I was on vacation the last few weeks.
Here is the doc about the structure of XCOFF files: https://www.ibm.com/support/knowledgecenter/ssw_aix_72/filesreference/XCOFF.html
I am working on adding 64-bit support but the other tools this patch may depend on do not support 64-bit for now. All of this has to be done step by step.

[jhenderson]

llvm/include/llvm/ObjectYAML/XCOFFYAML.h

59

Nit: missing trailing full stop for this comment. But really, I'm not sure this comment adds anything, as the name is pretty clear to me.

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

55

Two questions:

1. Why is this a signed type?
2. What is the maximum number of sections an XCOFF file can have? In ELF, it is effectively UINT32_MAX, for example. (In practice, it's unlikely that we'll see that many sections, but we shouldn't prevent it just due to the wrong type). This type should be big enough for whatever the max can be.

56

In general, we tend to avoid using auto these days in new code, unless the type is obvious. In this case, the type of the member of Obj.Sections is not obvious.

66

General point that applies here and in all other new error messages: the coding guidelines say error messages start with lower case and don't end in a full stop. They don't explicitly exclude ending in an exclamation mark, but I'd avoid it as well.

Specific point: it would be helpful if this error said what the maximum number of sections the code supports is.

73

Here and in similar cases below for sections etc, I don't think what you've done is good. I think you shouldn't emit an error if a user explicitly specifies the number of relocations (sections etc). Just use the specified value in the header.

Take a look at what we do for ELF yaml2obj already. For many fields there is a default value that is derived from the contents of the YAML, and an option to override that value. For example, the ELF header has an e_shnum field which states the number of sections in that object. This value is automatically populated with the number of sections provided in the YAML. However, if a different value is specified in the YAML for the e_shnum field, that value is written to e_shnum instead, whilst the real set of sections is still written out. This enables a user to create a deliberate inconsistency between the two properties, which allows for things like error handling testing of malformed objects.

llvm/lib/ObjectYAML/XCOFFYAML.cpp

111–112

In general, I think everything should be optional, unless there is no sensible default. I haven't looked at the spec yet, but presumably the magic is fixed, or used to distinguish between 32/64 bit. It seems reasonable that a user doesn't need to specify it and then yaml2obj just picks something like 32 bit automatically. I think it's important that you don't require more than you absolutely have to, because otherwise it bloats the YAML and makes it hard to identify what's actually important to the test case in question.

[Esme]

Addressed James's comments.

[Esme]

Thank you so much for your comments! @jhenderson They are very useful.

I've updated the summary with the description of common XCOFF file format.

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

55

1. There are 3 reserved signed number (-2, -1, 0) for sections, and thanks for your question, which remind me to add them to IndexMap.

2. The MaxSectionIndex, jasonliu defined in XCOFFObjectWriter.cpp, is also INT16_MAX, so I stuck with the number. I am not sure whether XCOFF supports a larger number of sections. I will have a look into this.

[Esme]

Update the parsing of address and flag of Section.

[jhenderson]

Sorry for the delay in looking at this further. I haven't had a chance to look at most of this again, but here are a few smaller comments.

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

66–69

It would probably be good to use some enum values or named constants for these, e.g. something like:

namespace xcoff {
enum {
  N_DEBUG = -2,
  N_ABS = -1,
  N_UNDEF = 0
}
}

This is similar to how special section indexes are handled for ELF.

75

79

LLVM style guide is to precalculate the number of sections, if the number cannot change within the loop, as per the suggestion inline. Also, prefer preincrement to postincrement.

[Esme]

Addressed @jhenderson 's comments.

[Esme]

Gently ping.

[jhenderson]

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

58

It might be a good idea to break this function up into smaller pieces, perhaps one function per loop, so you'd have a function that assigns the section offsets and addresses, another function for the relocations, another for the symbols etc.

68–70

Can you do this in the SectionIndexMap initialisation list, or at least in the constructor if that's not possible?

82

Put a blank line before this line, to help break up this function.

Same goes below: if you put a comment, followed immediately by an if statement or loop relating to that comment, add a blank line.

Also, I think it's more common grammatically in code comments to right "Assign" rather than "Assigns" (i.e. use the imperative form). Same for "Calculates" (use "Calculate") below.

94

Is "FileOffsetToData" the actual XCOFF field name, or is it something else? If something else, I recommend using the real field name.

96–97

And check whether the comment can be reflowed to fit within 80 characters width.

103

1. Can there be more than one each of .text/.data/.bss?
2. If so, are they all named the same?
3. Are the names actually ".text", ".data" etc?

110

If I'm reading this code correctly, if a user has put their sections in an order like:

.text
.somethingelse
.data

all sections are size 4, and the address of .text is 16, the address of .data is going to be 24, not 20. Is that supposed to be the case?

116

Reading this code, it looks like you can't have in XCOFF relocations that aren't attached to a section. Is that correct?

148

You probably need to make the Header fields optional themselves, so that this code can distinguish between the case where the user has explicitly specified the value as 0 and the case where it is unspecified.

The same likely goes for other structs like the Section.

Perhaps also worth pulling 0x01DF into a named constant somewhere.

149

Where the field name is self-explanatory, you don't need to have a comment. Same goes below.

175–177

Calculate the requested address value upfront, then use that value in both places, rather than repeat the logic to calculate it.

208

Same in similar messages below.

222

Probably best to make all these PaddingSize fields int64_t to prepare for 64-bit support.

225

272

At this point, it may be better to just use write_zeroes to fill the whole auxiliary entry. Alternatively, emit an error if NumberOfAuxEntries is non-zero.

290

This sounds like it prevents a user from writing a 32-bit XCOFF file, but with a messed up magic field. Perhaps you should put an optional explicit format field in the YAML (defaulting to 32-bit XCOFF), and use that to determine the file format to use.

295

It seems like if you failed to assign addresses or indices, it may be dangerous to continue? This should probably bail out. Same probably goes for the other cases where an error can occur too.

llvm/lib/ObjectYAML/XCOFFYAML.cpp

122

In ELF, the r_offset field of a relocation specifies where the relocation will patch, and is relative to either the section start or file start, depending on the context. Often in our test cases, it doesn't really matter where the relocation is patching, only that there is a relocation, hence the offset field is optional there. It seems likely that this will be the case for XCOFF too?

123

Can XCOFF relocations have no symbol? If so, I think a 0 index value would be a reasonable default.

125

Is there a reasonable default for the relocation type? In ELF, there isn't really, so I think it's a required field.

[Esme]

Addressed jhenderson's comments.

[Esme]

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

94

Yes, it's also defined in XCOFF.h.
The name "FileOffsetToData" has been used in all XCOFF related implementations，which corresponds to "s_scnptr" in the documentation.

103

1. Yes, multiple .text/.data/.bss sections are allowed.
2. Applications use the Flags field instead of the Name field to determine a section type. Two sections of the same type may have different names.
3. As introduced in Table 4.

110

Moving this calculation ahead of the calculation of FileOffsetToData gives the correct result.

116

Yes, the relocations are always attached to sections in XCOFF.

llvm/lib/ObjectYAML/XCOFFYAML.cpp

122

I agree that it's unfriendly to require the virtual address of the relocation from users.
While this item in XCOFF specifies the virtual address of the value that requires modification by the binder. And the offset to the data in the section will be calculated as follows:
offset_in_section = Relocation_Address - Section_Address
We can calculate the Section_Address from yaml contents, but hard to determine the Relocation_Address.
So this is hardly optional?

129

It's reasonable to make the name to be optimal and the flags to be required, since the flags are the unique identifier of the section type.

[Esme]

Only the .text, .data, .tdata, and STYP_DWARF sections have relocations.

[jhenderson]

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

56–57

Why not just use Obj.Header and Obj.Sections directly in the referencing code? Why do you need these member variables separately to Obj?

63–64

Is this a fundamental restriction of the XCOFF file format, or is it just what should happen? Is it possible to create (potentially by hand) a section with relocations if it isn't one of these types?

In general, to allow for testing of bad input paths etc, you want to allow as much flexibility in yaml2obj as possible. As such, it isn't yaml2obj's place to restrict what can be done, as long as it can physically represent what was requested.

77

MaxRawDataSize is an internal variable, right, not an XCOFF spec defined value? If MaxRawDataSize doesn't directly appear in the spec, don't mention it to the user in an error message. Instead, use general terms like "the maximum size permitted for XXX" (where XXX is the thing that is restricted, e.g. the object size).

103

It looks like from the spec that the names are merely conventions, so technically the names could be other thigns. It's probably fine to infer that if a section is text, it is called .text, unless otherwise specified by the YAML (and vice versa), but this bit applies to the section type, not the name, so we should refer to them by type rather than name (i.e. just "text", "data", "bss", not ".text" etc).

120

Is it definitely the address here that should be being aligned, or the offset? The two are different concepts, and the align function appears to align the offset, not the address.

136

191–192

Here, it's probably worth a comment saying which is the virtual address and which the physical address, like the inline edit, for example (which may be the wrong way around).

llvm/lib/ObjectYAML/XCOFFYAML.cpp

122

Could 0 be a reasonable default? If not, it's fine. I'm just wondering if it actually matters in all cases what the address is.

129

Sounds good to me.

[Esme]

Addressed James's comments.

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

56–57

Obj can't be changed in assignAddressesAndIndices(), because it will be used during writing. The value specified in the YAML has a higher priority to be written than the calculated valued derived from the contents. And only Header and Sections have these number/offset/address fields which need to be calculated, therefore I use InitSections and InitFileHdr to keep these calculated values.

120

The offset of data for each section is what I want to align. The comments may be confusing here.

llvm/lib/ObjectYAML/XCOFFYAML.cpp

122

As I see, 0 is not a reasonable default.

[Esme]

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

63–64

It is just what should happen.

Thanks for the advice, it makes sense to me to removing the restriction to allow more flexibility.

[jhenderson]

Some more minor comments. I'll take a look at the tests next time.

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

68

Sorry, I might have confused you with my previous comment. MaxRawDataSize is being compared to CurrentOffset, so it's not the size of the relocations/sections that is being constrained, if I read it correctly. Perhaps you could change the message to something like "maximum object size of XXX exceeded when writing relocation data". What do you think?

91

How about this?

137–138

Same as relocation comment above.

[jhenderson]

FYI, I will be off for just over two weeks from Thursday. Please don't feel the need to wait on further comments from me, if there are other yaml2obj developers that are happy with this change. Same goes for your other changes for llvm-objcopy and obj2yaml.

[Higuoxing]

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

14

Do we need this header file? I guess what we need is DenseMap ?

128

llvm/test/tools/yaml2obj/XCOFF/basic-doc.yaml

25–30

It looks that the Value, Type, StorageClass and NumberOfAuxEntries are optional too. Could you please add some test cases for them as well?

[Esme]

Thank you for your review! @jhenderson and @Higuoxing.
Looking forward to more comments from @hubert.reinterpretcast and @MaskRay.

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

68

Very good suggestion, thanks!

[jhenderson]

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

128

One better: const XCOFFYAML::Symbol &YamlSym

[Esme]

Added const

[Esme]

Gentle ping.

[Esme]

Added support for writing symbol name to string table.

[jhenderson]

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

14

Nit: LLVM usually has a new line between the licence header and the #include list (based on a quick look at 3 or 4 files).

68

You can drop the parentheses. Do you need to allow space for a null terminator, or does NameSize take that into account?

127–129

How about simply return initRelocations(CurrentOffset);?

294

Nit: the suggested inline edit sounds a bit better to me.

llvm/test/tools/yaml2obj/XCOFF/basic-doc.yaml

2

Nit: newer tests I'm involved with at least tend to use '##' for comments, to make them stand out from lit and FileCheck lines.

12

Is there an enum you could use to represent this set of flags? It would be preferable to be able write either of the following (flag values are placeholders):

Flags: Exec

or probably

Flags: [Exec, Alloc]

although Flags: 0x20 (or possibly Flags: [0x20]) should probably still be permitted.

13

It seems to me you could get away with much less data in this section (probably a half-dozen bytes)? I don't think this needs to be a real object for this test case? Same below.

[Esme]

Addressed James's comments.

[Esme]

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

68

Well, it seems that NameSize should have taken this into account.

llvm/test/tools/yaml2obj/XCOFF/basic-doc.yaml

12

Yes, we have the enum SectionTypeFlags. How about marking this as a TODO for follow-up work? Because this will have an impact on other tools, like obj2yaml.

enum SectionTypeFlags : int32_t {
  STYP_PAD = 0x0008,
  STYP_DWARF = 0x0010,
  STYP_TEXT = 0x0020,
  STYP_DATA = 0x0040,
  STYP_BSS = 0x0080,
  STYP_EXCEPT = 0x0100,
  STYP_INFO = 0x0200,
...
};

[Esme]

Used the enum SectionTypeFlags to represent the set of flags.

llvm/test/tools/yaml2obj/XCOFF/basic-doc.yaml

12

After double checking, this does not seem to affect other tools. Thanks for your input.

[jhenderson]

I've not had time to review test coverage yet, and I don't know XCOFF at all, so can't comment on the correctness either. You'll need others input for the latter.

llvm/test/tools/yaml2obj/XCOFF/basic-doc.yaml

12

As these are flags, you'll need the ability to specify multiple flags, just like for ELF sections. Looking at this, I'm guessing you don't currently have that option?

[Esme]

Added the ability to specify multiple flags.

[jhenderson]

I've taken another look and think you need a fair bit more testing.

1. You need to show that all the fields can be specified explicitly. Currently, you only do it for a subset of the fields.
2. You probably should show that all the flags are supported.
3. You need to test your error paths, to show that the errors are reported properly.
4. If you don't need the string table support in the initial patch (and by my understanding you don't), you can move all the related logic into another indepenedent patch, and then ensure it is properly tested there.
5. I think you need testing for undef and abs symbols too,
6. I think you need testing for non data/text/bss sections (with their zero addresses).

llvm/test/tools/yaml2obj/XCOFF/basic-doc.yaml

2

4–5

You can do this all at once.

[Esme]

Addressed comments.

[jhenderson]

In D95505#2767644, @Esme wrote:

Addressed comments.

Hi @Esme. Have you attempted to address all my comments? It doesn't look like you have. If you update a patch and haven't finished addressing all comments, please make it clear from the comment what you still plan to do.

llvm/test/tools/yaml2obj/XCOFF/basic-doc.yaml

24

Be consistent: above you've quoted the section data, and here you haven't. Pick one style (I'd recommend quoting).

25–26

Any particular reason these aren't all one section?

llvm/test/tools/yaml2obj/XCOFF/full-contents.yaml

68

Why are there blank lines here and below? Does this test actually pass? I was under the impression that CHECK-NEXT: without any contents was an error.

[Esme]

In D95505#2750262, @jhenderson wrote:

I've taken another look and think you need a fair bit more testing.

1. You need to show that all the fields can be specified explicitly. Currently, you only do it for a subset of the fields.
2. You probably should show that all the flags are supported.
3. You need to test your error paths, to show that the errors are reported properly.
4. If you don't need the string table support in the initial patch (and by my understanding you don't), you can move all the related logic into another indepenedent patch, and then ensure it is properly tested there.
5. I think you need testing for undef and abs symbols too,
6. I think you need testing for non data/text/bss sections (with their zero addresses).

Thanks! @jhenderson

1. The test file llvm/test/tools/yaml2obj/XCOFF/full-contents.yaml is added.
2. Addressed.
3. There are two types of errors, one is exceeding the maximum size/index, and the other is writing with offset overlap/redundant data. For the first type of error, it is difficult to write such a large file to show the error message; and for the second type, in order to allow users to write explicitly specifies values (allowing for invalid values), our offsets are derived from the contents, therefore these errors should not occur unless the yaml2obj itself has bugs.
4. I think we should support the string table in the patch, and I have added the long symbol name to test it.
5. Addressed.
6. Addressed.

[jhenderson]

In D95505#2778704, @Esme wrote:

3. There are two types of errors, one is exceeding the maximum size/index, and the other is writing with offset overlap/redundant data. For the first type of error, it is difficult to write such a large file to show the error message; and for the second type, in order to allow users to write explicitly specifies values (allowing for invalid values), our offsets are derived from the contents, therefore these errors should not occur unless the yaml2obj itself has bugs.

Fair enough. Could you at least test manually the max section limit case. It shouldn't be too hard to do (write a small script to generate such a case), please?

4. I think we should support the string table in the patch, and I have added the long symbol name to test it.

Why do you think string table support should be in this patch? Why not split the patch up into smaller pieces to make it easier for reviewers to review it? There's no need for the behaviour to be fully functional in the first case, especially as by my understanding not all XCOFF objects have string tables.

[Esme]

Leave the StringTable as a follow-up work.

[Esme]

Could you at least test manually the max section limit case.

I tested the case with a python script generating the yaml doc, and the error message was output as expected.

[jhenderson]

LGTM from a yaml2obj standpoint, but it would be a good idea to rope in someone with XCOFF experience to confirm they are happy with the file format writing before committing this.

llvm/test/tools/yaml2obj/XCOFF/basic-doc.yaml

39

Does this symbol test anything unique any more, or can we drop it?

[Esme]

Hi @jasonliu @DiggerLin @sfertile @shchenz @hubert.reinterpretcast, I would appreciate it if you could review this patch and check if the file format is written properly in your opinion. Thanks in advance!

llvm/test/tools/yaml2obj/XCOFF/basic-doc.yaml

39

It was used to test StringTable before, but now it's useless. I will drop this in next update.

[Esme]

1. Drop the useless Symbol test.
2. Add normalization/denormalization for the Section Flags set.

[shchenz]

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

242

We don't have to call write_zeros if PaddingSize is 0?

265

What about a symbol that does not have belonged sections? For example undefined external symbols?

llvm/test/tools/yaml2obj/XCOFF/basic-doc.yaml

17

Is it ok that the relocation address is not in the range of .data section?

20

use another section name that is not DWARF specific?

llvm/test/tools/yaml2obj/XCOFF/full-contents.yaml

37

Same as above

[Esme]

1. Addressed Zheng's comments.
2. Set more fields optional and modified the correspond testing.

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

265

Specifies a section number associated with one of the following symbols:
-2
Specifies N_DEBUG, a special symbolic debugging symbol.
-1
Specifies N_ABS, an absolute symbol. The symbol has a value but is not relocatable.
0
Specifies N_UNDEF, an undefined external symbol.
Any other value
Specifies the section number where the symbol was defined.

As the spec, there are 3 reserved section numbers for these symbols not defined in sections. The SectionName in the symbol entry is required now, however, we can also set the field optional and use N_UNDEF (maybe...) as the default section. Hmm... I am not sure which strategy is more reasonable. What do you think?

llvm/test/tools/yaml2obj/XCOFF/basic-doc.yaml

17

In general, yaml2obj will not report an error even though the user explicitly specifies an invalid values, which allows for things like error handling testing.

Also after getting more familiar with yaml2obj, I think it's reasonable to set more fields to optional, and these omitted values will be filled in with the default zero or values derived from contents. So I set the relocation address optional now and 0 is the default value for it.

[shchenz]

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

265

I think SectionName for reserved section number N_UNDEF is not defined because we don't need to do it. We only need a section number. So making SectionName attribute optional for a symbol makes more sense to me. You can not say that a section with section name N_UNDEF is the N_UNDEF(section number == 0) section. We can define a text section named by N_UNDEF by using section attribute like:

__attribute__((section ("N_UNDEF")))  int foo2(void)
{
}

llvm/test/tools/yaml2obj/XCOFF/basic-doc.yaml

17

Do you mean we setting the address as 0x3A on purpose? The address of the .data section is 0x8 and its size is 0x8, so if the relocation is valid, the address the relocation entry wants to resolve should be in 0x8 and 0x10.

[Esme]

Address comment.

llvm/test/tools/yaml2obj/XCOFF/basic-doc.yaml

17

I just set a random value, as this value isn't relevant for testing purposes here. Use a valid address now.

[shchenz]

LGTM too. Please wait for several days in case other reviewers have comments. Thanks for enabling this tool for AIX.

[thakis]

llvm/utils/gn/secondary/llvm/lib/ObjectYAML/BUILD.gn

29

(FYI, you don't need to update the files in llvm/utils/gn when you add files. Those are unsupported build files, and also for simple changes like this they are updated automatically based on the CMakeLists.txt files by a bot.

If you _do_ update them, please add a trailing , -- but it's better to not update them since it's less work for you and the bot will update them correctly :) )

[vitalybuka]

This patch introduce https://lab.llvm.org/buildbot/#/builders/85/builds/4886

llvm-project/llvm/lib/ObjectYAML/XCOFFEmitter.cpp:67:16: runtime error: null pointer passed as argument 2, which is declared to never be null
/usr/lib/gcc/x86_64-linux-gnu/8/../../../../x86_64-linux-gnu/include/string.h:43:28: note: nonnull attribute specified here
    #0 0x45c3df in (anonymous namespace)::XCOFFWriter::writeXCOFF() /b/sanitizer-x86_64-linux-bootstrap-ubsan/build/llvm-project/llvm/lib/ObjectYAML/XCOFFEmitter.cpp
    #1 0x45b0b1 in llvm::yaml::yaml2xcoff(llvm::XCOFFYAML::Object&, llvm::raw_ostream&, llvm::function_ref<void (llvm::Twine const&)>) /b/sanitizer-x86_64-linux-bootstrap-ubsan/build/llvm-project/llvm/lib/ObjectYAML/XCOFFEmitter.cpp:311:17
    #2 0x30a181 in llvm::yaml::convertYAML(llvm::yaml::Input&, llvm::raw_ostream&, llvm::function_ref<void (llvm::Twine const&)>, unsigned int, unsigned long) /b/sanitizer-x86_64-linux-bootstrap-ubsan/build/llvm-project/llvm/lib/ObjectYAML/yaml2obj.cpp:48:14
    #3 0x306322 in main /b/sanitizer-x86_64-linux-bootstrap-ubsan/build/llvm-project/llvm/tools/yaml2obj/yaml2obj.cpp:136:8
    #4 0x7f38e52b709a in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x2409a)
    #5 0x2eafd9 in _start (/b/sanitizer-x86_64-linux-bootstrap-ubsan/build/llvm_build_ubsan/bin/yaml2obj+0x2eafd9)

CC @eugenis

[Esme]

In D95505#2803450, @vitalybuka wrote:

This patch introduce https://lab.llvm.org/buildbot/#/builders/85/builds/4886

llvm-project/llvm/lib/ObjectYAML/XCOFFEmitter.cpp:67:16: runtime error: null pointer passed as argument 2, which is declared to never be null
/usr/lib/gcc/x86_64-linux-gnu/8/../../../../x86_64-linux-gnu/include/string.h:43:28: note: nonnull attribute specified here
    #0 0x45c3df in (anonymous namespace)::XCOFFWriter::writeXCOFF() /b/sanitizer-x86_64-linux-bootstrap-ubsan/build/llvm-project/llvm/lib/ObjectYAML/XCOFFEmitter.cpp
    #1 0x45b0b1 in llvm::yaml::yaml2xcoff(llvm::XCOFFYAML::Object&, llvm::raw_ostream&, llvm::function_ref<void (llvm::Twine const&)>) /b/sanitizer-x86_64-linux-bootstrap-ubsan/build/llvm-project/llvm/lib/ObjectYAML/XCOFFEmitter.cpp:311:17
    #2 0x30a181 in llvm::yaml::convertYAML(llvm::yaml::Input&, llvm::raw_ostream&, llvm::function_ref<void (llvm::Twine const&)>, unsigned int, unsigned long) /b/sanitizer-x86_64-linux-bootstrap-ubsan/build/llvm-project/llvm/lib/ObjectYAML/yaml2obj.cpp:48:14
    #3 0x306322 in main /b/sanitizer-x86_64-linux-bootstrap-ubsan/build/llvm-project/llvm/tools/yaml2obj/yaml2obj.cpp:136:8
    #4 0x7f38e52b709a in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x2409a)
    #5 0x2eafd9 in _start (/b/sanitizer-x86_64-linux-bootstrap-ubsan/build/llvm_build_ubsan/bin/yaml2obj+0x2eafd9)

CC @eugenis

The issue has been solved by rG310d2b4957c8, thanks.

llvm/utils/gn/secondary/llvm/lib/ObjectYAML/BUILD.gn

29

Thanks for the information. I will not update such file in future patches.

llvm/include/llvm/BinaryFormat/XCOFF.h

 constexpr size_t NameSize = 8;
 constexpr size_t SymbolTableEntrySize = 18;
 constexpr size_t RelocationSerializationSize32 = 10;
 constexpr uint16_t RelocOverflow = 65535;
 constexpr uint8_t AllocRegNo = 31;
 
 enum ReservedSectionNum : int16_t { N_DEBUG = -2, N_ABS = -1, N_UNDEF = 0 };
 
+enum MagicNumber : uint16_t { XCOFF32 = 0x01DF, XCOFF64 = 0x01F7 };
+
 // x_smclas field of x_csect from system header: /usr/include/syms.h
 /// Storage Mapping Class definitions.
 enum StorageMappingClass : uint8_t {
   //     READ ONLY CLASSES
   XMC_PR = 0,      ///< Program Code
   XMC_RO = 1,      ///< Read Only Constant
   XMC_DB = 2,      ///< Debug Dictionary Table
   XMC_GL = 6,      ///< Global Linkage (Interfile Interface Code)

llvm/include/llvm/ObjectYAML/ObjectYAML.h

 #define LLVM_OBJECTYAML_OBJECTYAML_H
 
 #include "llvm/ObjectYAML/ArchiveYAML.h"
 #include "llvm/ObjectYAML/COFFYAML.h"
 #include "llvm/ObjectYAML/ELFYAML.h"
 #include "llvm/ObjectYAML/MachOYAML.h"
 #include "llvm/ObjectYAML/MinidumpYAML.h"
 #include "llvm/ObjectYAML/WasmYAML.h"
+#include "llvm/ObjectYAML/XCOFFYAML.h"
 #include "llvm/Support/YAMLTraits.h"
 #include <memory>
 
 namespace llvm {
 namespace yaml {
 
 class IO;
 
 struct YamlObjectFile {
   std::unique_ptr<ArchYAML::Archive> Arch;
   std::unique_ptr<ELFYAML::Object> Elf;
   std::unique_ptr<COFFYAML::Object> Coff;
   std::unique_ptr<MachOYAML::Object> MachO;
   std::unique_ptr<MachOYAML::UniversalBinary> FatMachO;
   std::unique_ptr<MinidumpYAML::Object> Minidump;
   std::unique_ptr<WasmYAML::Object> Wasm;
+  std::unique_ptr<XCOFFYAML::Object> Xcoff;
 };
 
 template <> struct MappingTraits<YamlObjectFile> {
   static void mapping(IO &IO, YamlObjectFile &ObjectFile);
 };
 
 } // end namespace yaml
 } // end namespace llvm
 
 #endif // LLVM_OBJECTYAML_OBJECTYAML_H

llvm/include/llvm/ObjectYAML/XCOFFYAML.h

 
 namespace llvm {
 namespace XCOFFYAML {
 
 struct FileHeader {
   llvm::yaml::Hex16 Magic;
   uint16_t NumberOfSections;
   int32_t TimeStamp;
-  llvm::yaml::Hex32 SymbolTableOffset; // File offset to symbol table.
-  int32_t NumberOfSymTableEntries;
+  llvm::yaml::Hex64 SymbolTableOffset;
+  uint32_t NumberOfSymTableEntries;
   uint16_t AuxHeaderSize;
   llvm::yaml::Hex16 Flags;
 };
 
+struct Relocation {
+  llvm::yaml::Hex64 VirtualAddress;
+  llvm::yaml::Hex64 SymbolIndex;
+  llvm::yaml::Hex8 Info;
+  llvm::yaml::Hex8 Type;
+};
+
+struct Section {
+  StringRef SectionName;
+  llvm::yaml::Hex64 Address;
+  llvm::yaml::Hex64 Size;
+  llvm::yaml::Hex64 FileOffsetToData;
+  llvm::yaml::Hex64 FileOffsetToRelocations;
+  llvm::yaml::Hex64 FileOffsetToLineNumbers; // Line number pointer. Not supported yet.
+  llvm::yaml::Hex16 NumberOfRelocations;
+  llvm::yaml::Hex16 NumberOfLineNumbers; // Line number counts. Not supported yet.
+  uint32_t Flags;
+  yaml::BinaryRef SectionData;
+  std::vector<Relocation> Relocations;
+};
+
 struct Symbol {
   StringRef SymbolName;
-  llvm::yaml::Hex32 Value; // Symbol value; storage class-dependent.
+  llvm::yaml::Hex64 Value; // Symbol value; storage class-dependent.
   StringRef SectionName;
   llvm::yaml::Hex16 Type;
   XCOFF::StorageClass StorageClass;
-  uint8_t NumberOfAuxEntries; // Number of auxiliary entries
+  uint8_t NumberOfAuxEntries;
 };
 
 struct Object {
   FileHeader Header;
+  std::vector<Section> Sections;
   std::vector<Symbol> Symbols;
   Object();
 };
 } // namespace XCOFFYAML
 } // namespace llvm
+
 LLVM_YAML_IS_SEQUENCE_VECTOR(XCOFFYAML::Symbol)
+LLVM_YAML_IS_SEQUENCE_VECTOR(XCOFFYAML::Relocation)
+LLVM_YAML_IS_SEQUENCE_VECTOR(XCOFFYAML::Section)
+
 namespace llvm {
 namespace yaml {
 
+template <> struct ScalarBitSetTraits<XCOFF::SectionTypeFlags> {
+  static void bitset(IO &IO, XCOFF::SectionTypeFlags &Value);
+};
+
 template <> struct ScalarEnumerationTraits<XCOFF::StorageClass> {
   static void enumeration(IO &IO, XCOFF::StorageClass &Value);
 };
 
 template <> struct MappingTraits<XCOFFYAML::FileHeader> {
   static void mapping(IO &IO, XCOFFYAML::FileHeader &H);
 };
 
-template <> struct MappingTraits<XCOFFYAML::Object> {
-  static void mapping(IO &IO, XCOFFYAML::Object &Obj);
-};
 
 template <> struct MappingTraits<XCOFFYAML::Symbol> {
   static void mapping(IO &IO, XCOFFYAML::Symbol &S);
 };
 
+template <> struct MappingTraits<XCOFFYAML::Relocation> {
+  static void mapping(IO &IO, XCOFFYAML::Relocation &R);
+};
+
+template <> struct MappingTraits<XCOFFYAML::Section> {
+  static void mapping(IO &IO, XCOFFYAML::Section &Sec);
+};
+
+template <> struct MappingTraits<XCOFFYAML::Object> {
+  static void mapping(IO &IO, XCOFFYAML::Object &Obj);
+};
+
 } // namespace yaml
 } // namespace llvm
 
 #endif // LLVM_OBJECTYAML_XCOFFYAML_H

llvm/include/llvm/ObjectYAML/yaml2obj.h

 namespace MinidumpYAML {
 struct Object;
 }
 
 namespace WasmYAML {
 struct Object;
 }
 
+namespace XCOFFYAML {
+struct Object;
+}
+
 namespace ArchYAML {
 struct Archive;
 }
 
 namespace yaml {
 class Input;
 struct YamlObjectFile;
 
 using ErrorHandler = llvm::function_ref<void(const Twine &Msg)>;
 
 bool yaml2archive(ArchYAML::Archive &Doc, raw_ostream &Out, ErrorHandler EH);
 bool yaml2coff(COFFYAML::Object &Doc, raw_ostream &Out, ErrorHandler EH);
 bool yaml2elf(ELFYAML::Object &Doc, raw_ostream &Out, ErrorHandler EH,
               uint64_t MaxSize);
 bool yaml2macho(YamlObjectFile &Doc, raw_ostream &Out, ErrorHandler EH);
 bool yaml2minidump(MinidumpYAML::Object &Doc, raw_ostream &Out,
                    ErrorHandler EH);
 bool yaml2wasm(WasmYAML::Object &Doc, raw_ostream &Out, ErrorHandler EH);
+bool yaml2xcoff(XCOFFYAML::Object &Doc, raw_ostream &Out, ErrorHandler EH);
 
 bool convertYAML(Input &YIn, raw_ostream &Out, ErrorHandler ErrHandler,
                  unsigned DocNum = 1, uint64_t MaxSize = UINT64_MAX);
 
 /// Convenience function for tests.
 std::unique_ptr<object::ObjectFile>
 yaml2ObjectFile(SmallVectorImpl<char> &Storage, StringRef Yaml,
                 ErrorHandler ErrHandler);
 
 } // namespace yaml
 } // namespace llvm
 
 #endif

llvm/lib/ObjectYAML/CMakeLists.txt

add_llvm_component_library(LLVMObjectYAML
   ELFYAML.cpp
   MachOEmitter.cpp
   MachOYAML.cpp
   ObjectYAML.cpp
   MinidumpEmitter.cpp
   MinidumpYAML.cpp
   WasmEmitter.cpp
   WasmYAML.cpp
+  XCOFFEmitter.cpp
   XCOFFYAML.cpp
   YAML.cpp
   yaml2obj.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/ObjectYAML
 
   LINK_COMPONENTS
   BinaryFormat
   Object
   Support
   DebugInfoCodeView
   MC
   )

llvm/lib/ObjectYAML/ObjectYAML.cpp

if (IO.mapTag("!Arch")) {
       MappingTraits<MachOYAML::UniversalBinary>::mapping(IO,
                                                          *ObjectFile.FatMachO);
     } else if (IO.mapTag("!minidump")) {
       ObjectFile.Minidump.reset(new MinidumpYAML::Object());
       MappingTraits<MinidumpYAML::Object>::mapping(IO, *ObjectFile.Minidump);
     } else if (IO.mapTag("!WASM")) {
       ObjectFile.Wasm.reset(new WasmYAML::Object());
       MappingTraits<WasmYAML::Object>::mapping(IO, *ObjectFile.Wasm);
+    } else if (IO.mapTag("!XCOFF")) {
+      ObjectFile.Xcoff.reset(new XCOFFYAML::Object());
+      MappingTraits<XCOFFYAML::Object>::mapping(IO, *ObjectFile.Xcoff);
     } else if (const Node *N = In.getCurrentNode()) {
       if (N->getRawTag().empty())
         IO.setError("YAML Object File missing document type tag!");
       else
         IO.setError("YAML Object File unsupported document type tag '" +
                     N->getRawTag() + "'!");
     }
   }
 }

llvm/lib/ObjectYAML/XCOFFEmitter.cpp

+//===- yaml2xcoff - Convert YAML to a xcoff object file -------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// The xcoff component of yaml2obj.
+///
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/BinaryFormat/XCOFF.h"
+#include "llvm/Object/XCOFFObjectFile.h"
+#include "llvm/ObjectYAML/ObjectYAML.h"
+#include "llvm/ObjectYAML/yaml2obj.h"
+#include "llvm/Support/EndianStream.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/LEB128.h"
+
+using namespace llvm;
+
+namespace {
+
+constexpr unsigned DefaultSectionAlign = 4;
+constexpr int16_t MaxSectionIndex = INT16_MAX;
+constexpr uint32_t MaxRawDataSize = UINT32_MAX;
+
+class XCOFFWriter {
+public:
+  XCOFFWriter(XCOFFYAML::Object &Obj, raw_ostream &OS, yaml::ErrorHandler EH)
+      : Obj(Obj), W(OS, support::big), ErrHandler(EH) {
+    Is64Bit = Obj.Header.Magic == XCOFF::XCOFF64;
+  }
+  bool writeXCOFF();
+
+private:
+  bool initFileHeader(uint64_t CurrentOffset);
+  bool initSectionHeader(uint64_t &CurrentOffset);
+  bool initRelocations(uint64_t &CurrentOffset);
+  bool assignAddressesAndIndices();
+  void writeFileHeader();
+  void writeSectionHeader();
+  bool writeSectionData();
+  bool writeRelocations();
+  bool writeSymbols();
+
+  XCOFFYAML::Object &Obj;
+  bool Is64Bit = false;
+  support::endian::Writer W;
+  yaml::ErrorHandler ErrHandler;
+  uint64_t StartOffset;
+  // Map the section name to its corrresponding section index.
+  DenseMap<StringRef, int16_t> SectionIndexMap = {
+      {StringRef("N_DEBUG"), XCOFF::N_DEBUG},
+      {StringRef("N_ABS"), XCOFF::N_ABS},
+      {StringRef("N_UNDEF"), XCOFF::N_UNDEF}};
+  XCOFFYAML::FileHeader InitFileHdr = Obj.Header;
+  std::vector<XCOFFYAML::Section> InitSections = Obj.Sections;
+};
+
+static void writeName(StringRef StrName, support::endian::Writer W) {
+  char Name[XCOFF::NameSize];
+  memset(Name, 0, XCOFF::NameSize);
+  memcpy(Name, StrName.data(), StrName.size());
+  ArrayRef<char> NameRef(Name, XCOFF::NameSize);
+  W.write(NameRef);
+}
+
+bool XCOFFWriter::initRelocations(uint64_t &CurrentOffset) {
+  for (uint16_t I = 0, E = InitSections.size(); I < E; ++I) {
+    if (!InitSections[I].Relocations.empty()) {
+      InitSections[I].NumberOfRelocations = InitSections[I].Relocations.size();
+      InitSections[I].FileOffsetToRelocations = CurrentOffset;
+      CurrentOffset += InitSections[I].NumberOfRelocations *
+                       XCOFF::RelocationSerializationSize32;
+      if (CurrentOffset > MaxRawDataSize) {
+        ErrHandler("maximum object size of" + Twine(MaxRawDataSize) +
+                   "exceeded when writing relocation data");
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+bool XCOFFWriter::initSectionHeader(uint64_t &CurrentOffset) {
+  uint64_t CurrentSecAddr = 0;
+  for (uint16_t I = 0, E = InitSections.size(); I < E; ++I) {
+    if (CurrentOffset > MaxRawDataSize) {
+      ErrHandler("maximum object size of" + Twine(MaxRawDataSize) +
+                 "exceeded when writing section data");
+      return false;
+    }
+
+    // Assign indices for sections.
+    if (InitSections[I].SectionName.size() &&
+        !SectionIndexMap[InitSections[I].SectionName]) {
+      // The section index starts from 1.
+      SectionIndexMap[InitSections[I].SectionName] = I + 1;
+      if ((I + 1) > MaxSectionIndex) {
+        ErrHandler("exceeded the maximum permitted section index of " +
+                   Twine(MaxSectionIndex));
+        return false;
+      }
+    }
+
+    // Calculate the physical/virtual address. This field should contain 0 for
+    // all sections except the text, data and bss sections.
+    if (InitSections[I].Flags != XCOFF::STYP_TEXT &&
+        InitSections[I].Flags != XCOFF::STYP_DATA &&
+        InitSections[I].Flags != XCOFF::STYP_BSS)
+      InitSections[I].Address = 0;
+    else
+      InitSections[I].Address = CurrentSecAddr;
+
+    // Calculate the FileOffsetToData and data size for sections.
+    if (InitSections[I].SectionData.binary_size()) {
+      InitSections[I].FileOffsetToData = CurrentOffset;
+      CurrentOffset += InitSections[I].SectionData.binary_size();
+      // Ensure the offset is aligned to DefaultSectionAlign.
+      CurrentOffset = alignTo(CurrentOffset, DefaultSectionAlign);
+      InitSections[I].Size = CurrentOffset - InitSections[I].FileOffsetToData;
+      CurrentSecAddr += InitSections[I].Size;
+    }
+  }
+  return initRelocations(CurrentOffset);
+}
+
+bool XCOFFWriter::initFileHeader(uint64_t CurrentOffset) {
+  // The default format of the object file is XCOFF32.
+  InitFileHdr.Magic = XCOFF::XCOFF32;
+  InitFileHdr.NumberOfSections = Obj.Sections.size();
+  InitFileHdr.NumberOfSymTableEntries = Obj.Symbols.size();
+
+  for (const XCOFFYAML::Symbol &YamlSym : Obj.Symbols) {
+    // Add the number of auxiliary symbols to the total number.
+    InitFileHdr.NumberOfSymTableEntries += YamlSym.NumberOfAuxEntries;
+  }
+
+  // Calculate SymbolTableOffset for the file header.
+  if (InitFileHdr.NumberOfSymTableEntries) {
+    InitFileHdr.SymbolTableOffset = CurrentOffset;
+    CurrentOffset +=
+        InitFileHdr.NumberOfSymTableEntries * XCOFF::SymbolTableEntrySize;
+    if (CurrentOffset > MaxRawDataSize) {
+      ErrHandler("maximum object size of" + Twine(MaxRawDataSize) +
+                 "exceeded when writing symbols");
+      return false;
+    }
+  }
+  // TODO: Calculate FileOffsetToLineNumbers when line number supported.
+  return true;
+}
+
+bool XCOFFWriter::assignAddressesAndIndices() {
+  uint64_t CurrentOffset =
+      sizeof(XCOFF::FileHeader32) /* TODO: + auxiliaryHeaderSize() */ +
+      InitSections.size() * sizeof(XCOFF::SectionHeader32);
+
+  // Calculate section header info.
+  if (!initSectionHeader(CurrentOffset))
+    return false;
+  // Calculate file header info.
+  return initFileHeader(CurrentOffset);
+}
+
+void XCOFFWriter::writeFileHeader() {
+  W.write<uint16_t>(Obj.Header.Magic ? Obj.Header.Magic : InitFileHdr.Magic);
+  W.write<uint16_t>(Obj.Header.NumberOfSections ? Obj.Header.NumberOfSections
+                                                : InitFileHdr.NumberOfSections);
+  W.write<int32_t>(Obj.Header.TimeStamp);
+  W.write<uint32_t>(Obj.Header.SymbolTableOffset
+                        ? Obj.Header.SymbolTableOffset
+                        : InitFileHdr.SymbolTableOffset);
+  W.write<int32_t>(Obj.Header.NumberOfSymTableEntries
+                       ? Obj.Header.NumberOfSymTableEntries
+                       : InitFileHdr.NumberOfSymTableEntries);
+  W.write<uint16_t>(Obj.Header.AuxHeaderSize);
+  W.write<uint16_t>(Obj.Header.Flags);
+}
+
+void XCOFFWriter::writeSectionHeader() {
+  for (uint16_t I = 0, E = Obj.Sections.size(); I < E; ++I) {
+    XCOFFYAML::Section YamlSec = Obj.Sections[I];
+    XCOFFYAML::Section DerivedSec = InitSections[I];
+    writeName(YamlSec.SectionName, W);
+    // Virtual address is the same as physical address.
+    uint32_t SectionAddress =
+        YamlSec.Address ? YamlSec.Address : DerivedSec.Address;
+    W.write<uint32_t>(SectionAddress); // Physical address
+    W.write<uint32_t>(SectionAddress); // Virtual address
+    W.write<uint32_t>(YamlSec.Size ? YamlSec.Size : DerivedSec.Size);
+    W.write<uint32_t>(YamlSec.FileOffsetToData ? YamlSec.FileOffsetToData
+                                               : DerivedSec.FileOffsetToData);
+    W.write<uint32_t>(YamlSec.FileOffsetToRelocations
+                          ? YamlSec.FileOffsetToRelocations
+                          : DerivedSec.FileOffsetToRelocations);
+    W.write<uint32_t>(YamlSec.FileOffsetToLineNumbers);
+    W.write<uint16_t>(YamlSec.NumberOfRelocations
+                          ? YamlSec.NumberOfRelocations
+                          : DerivedSec.NumberOfRelocations);
+    W.write<uint16_t>(YamlSec.NumberOfLineNumbers);
+    W.write<int32_t>(YamlSec.Flags);
+  }
+}
+
+bool XCOFFWriter::writeSectionData() {
+  for (uint16_t I = 0, E = Obj.Sections.size(); I < E; ++I) {
+    XCOFFYAML::Section YamlSec = Obj.Sections[I];
+    if (YamlSec.SectionData.binary_size()) {
+      // Fill the padding size with zeros.
+      int64_t PaddingSize =
+          InitSections[I].FileOffsetToData - (W.OS.tell() - StartOffset);
+      if (PaddingSize < 0) {
+        ErrHandler("redundant data was written before section data");
+        return false;
+      }
+      if (PaddingSize > 0)
+        W.OS.write_zeros(PaddingSize);
+      YamlSec.SectionData.writeAsBinary(W.OS);
+    }
+  }
+  return true;
+}
+
+bool XCOFFWriter::writeRelocations() {
+  for (uint16_t I = 0, E = Obj.Sections.size(); I < E; ++I) {
+    XCOFFYAML::Section YamlSec = Obj.Sections[I];
+    if (!YamlSec.Relocations.empty()) {
+      int64_t PaddingSize =
+          InitSections[I].FileOffsetToRelocations - (W.OS.tell() - StartOffset);
+      if (PaddingSize < 0) {
+        ErrHandler("redundant data was written before relocations");
+        return false;
+      }
+      if (PaddingSize > 0)
+        W.OS.write_zeros(PaddingSize);
+      for (const XCOFFYAML::Relocation &YamlRel : YamlSec.Relocations) {
+        W.write<uint32_t>(YamlRel.VirtualAddress);
+        W.write<uint32_t>(YamlRel.SymbolIndex);
+        W.write<uint8_t>(YamlRel.Info);
+        W.write<uint8_t>(YamlRel.Type);
+      }
+    }
+  }
+  return true;
+}
+
+bool XCOFFWriter::writeSymbols() {
+  int64_t PaddingSize =
+      (uint64_t)InitFileHdr.SymbolTableOffset - (W.OS.tell() - StartOffset);
+  if (PaddingSize < 0) {
+    ErrHandler("redundant data was written before symbols");
+    return false;
+  }
+  if (PaddingSize > 0)
+    W.OS.write_zeros(PaddingSize);
+  for (const XCOFFYAML::Symbol &YamlSym : Obj.Symbols) {
+    writeName(YamlSym.SymbolName, W);
+    W.write<uint32_t>(YamlSym.Value);
+    W.write<int16_t>(
+        YamlSym.SectionName.size() ? SectionIndexMap[YamlSym.SectionName] : 0);
+    W.write<uint16_t>(YamlSym.Type);
+    W.write<uint8_t>(YamlSym.StorageClass);
+    W.write<uint8_t>(YamlSym.NumberOfAuxEntries);
+
+    // Now output the auxiliary entry.
+    for (uint8_t I = 0, E = YamlSym.NumberOfAuxEntries; I < E; ++I) {
+      // TODO: Auxiliary entry is not supported yet.
+      // The auxiliary entries for a symbol follow its symbol table entry. The
+      // length of each auxiliary entry is the same as a symbol table entry (18
+      // bytes). The format and quantity of auxiliary entries depend on the
+      // storage class (n_sclass) and type (n_type) of the symbol table entry.
+      W.OS.write_zeros(18);
+    }
+  }
+  return true;
+}
+
+bool XCOFFWriter::writeXCOFF() {
+  if (Is64Bit) {
+    ErrHandler("only XCOFF32 is currently supported");
+    return false;
+  }
+  if (!assignAddressesAndIndices())
+    return false;
+  StartOffset = W.OS.tell();
+  writeFileHeader();
+  if (!Obj.Sections.empty()) {
+    writeSectionHeader();
+    if (!writeSectionData())
+      return false;
+    if (!writeRelocations())
+      return false;
+  }
+  if (!Obj.Symbols.empty())
+    return writeSymbols();
+  return true;
+}
+
+} // end anonymous namespace
+
+namespace llvm {
+namespace yaml {
+
+bool yaml2xcoff(XCOFFYAML::Object &Doc, raw_ostream &Out, ErrorHandler EH) {
+  XCOFFWriter Writer(Doc, Out, EH);
+  return Writer.writeXCOFF();
+}
+
+} // namespace yaml
+} // namespace llvm

llvm/lib/ObjectYAML/XCOFFYAML.cpp

 namespace XCOFFYAML {
 
 Object::Object() { memset(&Header, 0, sizeof(Header)); }
 
 } // namespace XCOFFYAML
 
 namespace yaml {
 
+void ScalarBitSetTraits<XCOFF::SectionTypeFlags>::bitset(
+    IO &IO, XCOFF::SectionTypeFlags &Value) {
+#define ECase(X) IO.bitSetCase(Value, #X, XCOFF::X)
+  ECase(STYP_PAD);
+  ECase(STYP_DWARF);
+  ECase(STYP_TEXT);
+  ECase(STYP_DATA);
+  ECase(STYP_BSS);
+  ECase(STYP_EXCEPT);
+  ECase(STYP_INFO);
+  ECase(STYP_TDATA);
+  ECase(STYP_TBSS);
+  ECase(STYP_LOADER);
+  ECase(STYP_DEBUG);
+  ECase(STYP_TYPCHK);
+  ECase(STYP_OVRFLO);
+#undef ECase
+}
+
 void ScalarEnumerationTraits<XCOFF::StorageClass>::enumeration(
     IO &IO, XCOFF::StorageClass &Value) {
 #define ECase(X) IO.enumCase(Value, #X, XCOFF::X)
   ECase(C_NULL);
   ECase(C_AUTO);
   ECase(C_EXT);
   ECase(C_STAT);
   ECase(C_REG);
#define ECase(X) IO.enumCase(Value, #X, XCOFF::X)
   ECase(C_BSTAT);
   ECase(C_ESTAT);
   ECase(C_GTLS);
   ECase(C_STTLS);
   ECase(C_EFCN);
 #undef ECase
 }
 
+struct NSectionFlags {
+  NSectionFlags(IO &) : Flags(XCOFF::SectionTypeFlags(0)) {}
+  NSectionFlags(IO &, uint32_t C) : Flags(XCOFF::SectionTypeFlags(C)) {}
+
+  uint32_t denormalize(IO &) { return Flags; }
+
+  XCOFF::SectionTypeFlags Flags;
+};
+
 void MappingTraits<XCOFFYAML::FileHeader>::mapping(
     IO &IO, XCOFFYAML::FileHeader &FileHdr) {
-  IO.mapRequired("MagicNumber", FileHdr.Magic);
-  IO.mapRequired("NumberOfSections", FileHdr.NumberOfSections);
-  IO.mapRequired("CreationTime", FileHdr.TimeStamp);
-  IO.mapRequired("OffsetToSymbolTable", FileHdr.SymbolTableOffset);
-  IO.mapRequired("EntriesInSymbolTable", FileHdr.NumberOfSymTableEntries);
-  IO.mapRequired("AuxiliaryHeaderSize", FileHdr.AuxHeaderSize);
-  IO.mapRequired("Flags", FileHdr.Flags);
+  IO.mapOptional("MagicNumber", FileHdr.Magic);
+  IO.mapOptional("NumberOfSections", FileHdr.NumberOfSections);
+  IO.mapOptional("CreationTime", FileHdr.TimeStamp);
+  IO.mapOptional("OffsetToSymbolTable", FileHdr.SymbolTableOffset);
+  IO.mapOptional("EntriesInSymbolTable", FileHdr.NumberOfSymTableEntries);
+  IO.mapOptional("AuxiliaryHeaderSize", FileHdr.AuxHeaderSize);
+  IO.mapOptional("Flags", FileHdr.Flags);
+}
+
+void MappingTraits<XCOFFYAML::Relocation>::mapping(IO &IO,
+                                                   XCOFFYAML::Relocation &R) {
+  IO.mapOptional("Address", R.VirtualAddress);
+  IO.mapOptional("Symbol", R.SymbolIndex);
+  IO.mapOptional("Info", R.Info);
+  IO.mapOptional("Type", R.Type);
+}
+
+void MappingTraits<XCOFFYAML::Section>::mapping(IO &IO,
+                                                XCOFFYAML::Section &Sec) {
+  MappingNormalization<NSectionFlags, uint32_t> NC(IO, Sec.Flags);
+  IO.mapOptional("Name", Sec.SectionName);
+  IO.mapOptional("Address", Sec.Address);
+  IO.mapOptional("Size", Sec.Size);
+  IO.mapOptional("FileOffsetToData", Sec.FileOffsetToData);
+  IO.mapOptional("FileOffsetToRelocations", Sec.FileOffsetToRelocations);
+  IO.mapOptional("FileOffsetToLineNumbers", Sec.FileOffsetToLineNumbers);
+  IO.mapOptional("NumberOfRelocations", Sec.NumberOfRelocations);
+  IO.mapOptional("NumberOfLineNumbers", Sec.NumberOfLineNumbers);
+  IO.mapOptional("Flags", NC->Flags);
+  IO.mapOptional("SectionData", Sec.SectionData);
+  IO.mapOptional("Relocations", Sec.Relocations);
 }
 
 void MappingTraits<XCOFFYAML::Symbol>::mapping(IO &IO, XCOFFYAML::Symbol &S) {
   IO.mapRequired("Name", S.SymbolName);
-  IO.mapRequired("Value", S.Value);
-  IO.mapRequired("Section", S.SectionName);
-  IO.mapRequired("Type", S.Type);
-  IO.mapRequired("StorageClass", S.StorageClass);
-  IO.mapRequired("NumberOfAuxEntries", S.NumberOfAuxEntries);
+  IO.mapOptional("Value", S.Value);
+  IO.mapOptional("Section", S.SectionName);
+  IO.mapOptional("Type", S.Type);
+  IO.mapOptional("StorageClass", S.StorageClass);
+  IO.mapOptional("NumberOfAuxEntries", S.NumberOfAuxEntries);
 }
 
 void MappingTraits<XCOFFYAML::Object>::mapping(IO &IO, XCOFFYAML::Object &Obj) {
   IO.mapTag("!XCOFF", true);
   IO.mapRequired("FileHeader", Obj.Header);
-  IO.mapRequired("Symbols", Obj.Symbols);
+  IO.mapOptional("Sections", Obj.Sections);
+  IO.mapOptional("Symbols", Obj.Symbols);
 }
 
 } // namespace yaml
 } // namespace llvm

llvm/lib/ObjectYAML/yaml2obj.cpp

do {
     if (Doc.Coff)
       return yaml2coff(*Doc.Coff, Out, ErrHandler);
     if (Doc.MachO || Doc.FatMachO)
       return yaml2macho(Doc, Out, ErrHandler);
     if (Doc.Minidump)
       return yaml2minidump(*Doc.Minidump, Out, ErrHandler);
     if (Doc.Wasm)
       return yaml2wasm(*Doc.Wasm, Out, ErrHandler);
+    if (Doc.Xcoff)
+      return yaml2xcoff(*Doc.Xcoff, Out, ErrHandler);
 
     ErrHandler("unknown document type");
     return false;
 
   } while (YIn.nextDocument());
 
   ErrHandler("cannot find the " + Twine(DocNum) +
              getOrdinalSuffix(DocNum).data() + " document");

llvm/test/tools/yaml2obj/XCOFF/basic-doc.yaml

+## Check that yaml2obj automatically assigns omited fields with values.
+# RUN: yaml2obj %s -o %t
+# RUN: llvm-readobj --headers --symbols %t | FileCheck %s
+
+--- !XCOFF
+FileHeader:
+  MagicNumber:       0x1DF
+Sections:
+  - Name:            .text
+    Flags:           [ STYP_TEXT ]
+    SectionData:     "9061FFF880820000"
+  - Name:            .data
+    Flags:           [ STYP_DATA ]
+    SectionData:     "0000000000000FC0"
+    Relocations:
+      - Address:     0x08
+  - Name:            .data
+    Relocations:
+      - Type:        0x02
+  - Name:            .debug
+    Address:         0x0
+    Size:            0x60
+    Flags:           [ STYP_DEBUG, STYP_DATA ]
+    SectionData:     01110103
+  - Flags:           [ STYP_BSS, STYP_DWARF, STYP_EXCEPT,  STYP_INFO, STYP_TDATA, STYP_TBSS, STYP_LOADER, STYP_TYPCHK, STYP_OVRFLO ]
+Symbols:
+  - Name:            .file
+    Section:         N_DEBUG
+  - Name:            .undef
+  - Name:            .abs
+    Section:         N_ABS
+  - Name:            .text
+    Value:           0x0
+    Section:         .text
+    Type:            0x0
+    StorageClass:    C_HIDEXT
+    NumberOfAuxEntries: 1
+
+# CHECK:      AddressSize: 32bit
+# CHECK-NEXT: FileHeader {
+# CHECK-NEXT:   Magic: 0x1DF
+# CHECK-NEXT:   NumberOfSections: 5
+# CHECK-NEXT:   TimeStamp: None (0x0)
+# CHECK-NEXT:   SymbolTableOffset: 0x104
+# CHECK-NEXT:   SymbolTableEntries: 5
+# CHECK-NEXT:   OptionalHeaderSize: 0x0
+# CHECK-NEXT:   Flags: 0x0
+# CHECK-NEXT: }
+# CHECK-NEXT: Sections [
+# CHECK-NEXT:   Section {
+# CHECK-NEXT:     Index: 1
+# CHECK-NEXT:     Name: .text
+# CHECK-NEXT:     PhysicalAddress: 0x0
+# CHECK-NEXT:     VirtualAddress: 0x0
+# CHECK-NEXT:     Size: 0x8
+# CHECK-NEXT:     RawDataOffset: 0xDC
+# CHECK-NEXT:     RelocationPointer: 0x0
+# CHECK-NEXT:     LineNumberPointer: 0x0
+# CHECK-NEXT:     NumberOfRelocations: 0
+# CHECK-NEXT:     NumberOfLineNumbers: 0
+# CHECK-NEXT:     Type: STYP_TEXT (0x20)
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Section {
+# CHECK-NEXT:     Index: 2
+# CHECK-NEXT:     Name: .data
+# CHECK-NEXT:     PhysicalAddress: 0x8
+# CHECK-NEXT:     VirtualAddress: 0x8
+# CHECK-NEXT:     Size: 0x8
+# CHECK-NEXT:     RawDataOffset: 0xE4
+# CHECK-NEXT:     RelocationPointer: 0xF0
+# CHECK-NEXT:     LineNumberPointer: 0x0
+# CHECK-NEXT:     NumberOfRelocations: 1
+# CHECK-NEXT:     NumberOfLineNumbers: 0
+# CHECK-NEXT:     Type: STYP_DATA (0x40)
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Section {
+# CHECK-NEXT:     Index: 3
+# CHECK-NEXT:     Name: .data
+# CHECK-NEXT:     PhysicalAddress: 0x0
+# CHECK-NEXT:     VirtualAddress: 0x0
+# CHECK-NEXT:     Size: 0x0
+# CHECK-NEXT:     RawDataOffset: 0x0
+# CHECK-NEXT:     RelocationPointer: 0xFA
+# CHECK-NEXT:     LineNumberPointer: 0x0
+# CHECK-NEXT:     NumberOfRelocations: 1
+# CHECK-NEXT:     NumberOfLineNumbers: 0
+# CHECK-NEXT:     Type: 0x0
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Section {
+# CHECK-NEXT:     Index: 4
+# CHECK-NEXT:     Name: .debug
+# CHECK-NEXT:     PhysicalAddress: 0x0
+# CHECK-NEXT:     VirtualAddress: 0x0
+# CHECK-NEXT:     Size: 0x60
+# CHECK-NEXT:     RawDataOffset: 0xEC
+# CHECK-NEXT:     RelocationPointer: 0x0
+# CHECK-NEXT:     LineNumberPointer: 0x0
+# CHECK-NEXT:     NumberOfRelocations: 0
+# CHECK-NEXT:     NumberOfLineNumbers: 0
+# CHECK-NEXT:     Type: 0x2040
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Section {
+# CHECK-NEXT:     Index: 5
+# CHECK-NEXT:     Name: 
+# CHECK-NEXT:     PhysicalAddress: 0x0
+# CHECK-NEXT:     VirtualAddress: 0x0
+# CHECK-NEXT:     Size: 0x0
+# CHECK-NEXT:     RawDataOffset: 0x0
+# CHECK-NEXT:     RelocationPointer: 0x0
+# CHECK-NEXT:     LineNumberPointer: 0x0
+# CHECK-NEXT:     NumberOfRelocations: 0
+# CHECK-NEXT:     NumberOfLineNumbers: 0
+# CHECK-NEXT:     Type: 0xDF90
+# CHECK-NEXT:   }
+# CHECK-NEXT: ]
+# CHECK-NEXT: Symbols [
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Index: 0
+# CHECK-NEXT:     Name: .file
+# CHECK-NEXT:     Value: 0x0
+# CHECK-NEXT:     Section: N_DEBUG
+# CHECK-NEXT:     Type: 0x0
+# CHECK-NEXT:     StorageClass: C_NULL (0x0)
+# CHECK-NEXT:     NumberOfAuxEntries: 0
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Index: 1
+# CHECK-NEXT:     Name: .undef
+# CHECK-NEXT:     Value: 0x0
+# CHECK-NEXT:     Section: N_UNDEF
+# CHECK-NEXT:     Type: 0x0
+# CHECK-NEXT:     StorageClass: C_NULL (0x0)
+# CHECK-NEXT:     NumberOfAuxEntries: 0
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Index: 2
+# CHECK-NEXT:     Name: .abs
+# CHECK-NEXT:     Value: 0x0
+# CHECK-NEXT:     Section: N_ABS
+# CHECK-NEXT:     Type: 0x0
+# CHECK-NEXT:     StorageClass: C_NULL (0x0)
+# CHECK-NEXT:     NumberOfAuxEntries: 0
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Index: 3
+# CHECK-NEXT:     Name: .text
+# CHECK-NEXT:     Value (RelocatableAddress): 0x0
+# CHECK-NEXT:     Section: .text
+# CHECK-NEXT:     Type: 0x0
+# CHECK-NEXT:     StorageClass: C_HIDEXT (0x6B)
+# CHECK-NEXT:     NumberOfAuxEntries: 1
+# CHECK-NEXT:     CSECT Auxiliary Entry {
+# CHECK-NEXT:       Index: 4
+# CHECK-NEXT:       SectionLen: 0
+# CHECK-NEXT:       ParameterHashIndex: 0x0
+# CHECK-NEXT:       TypeChkSectNum: 0x0
+# CHECK-NEXT:       SymbolAlignmentLog2: 0
+# CHECK-NEXT:       SymbolType: XTY_ER (0x0)
+# CHECK-NEXT:       StorageMappingClass: XMC_PR (0x0)
+# CHECK-NEXT:       StabInfoIndex: 0x0
+# CHECK-NEXT:       StabSectNum: 0x0
+# CHECK-NEXT:     }
+# CHECK-NEXT:   }
+# CHECK-NEXT: ]

llvm/test/tools/yaml2obj/XCOFF/full-contents.yaml

+## Test that we can explicitly specify all the fields.
+# RUN: yaml2obj %s -o %t
+# RUN: llvm-readobj --headers --symbols %t | FileCheck %s
+
+--- !XCOFF
+FileHeader:
+  MagicNumber:          0x1DF
+  NumberOfSections:     2
+  CreationTime:         0
+  OffsetToSymbolTable:  0x7A
+  EntriesInSymbolTable: 4
+  AuxiliaryHeaderSize:  0
+  Flags:                0x0
+Sections:
+  - Name:                    .text
+    Address:                 0x0
+    Size:                    0x8
+    FileOffsetToData:        0x64
+    FileOffsetToRelocations: 0x0
+    FileOffsetToLineNumbers: 0x0
+    NumberOfRelocations:     0x0
+    NumberOfLineNumbers:     0x0
+    Flags:                   [ STYP_TEXT ]
+    SectionData:             "3860000048"
+  - Name:                    .data
+    Address:                 0x8
+    Size:                    0x4
+    FileOffsetToData:        0x6C
+    FileOffsetToRelocations: 0x70
+    FileOffsetToLineNumbers: 0x0
+    NumberOfRelocations:     0x1
+    NumberOfLineNumbers:     0x0
+    Flags:                   [ STYP_DATA ]
+    SectionData:             "00000088"
+    Relocations:
+      - Address:         0x80
+        Symbol:          0x21
+        Info:            0x1F
+        Type:            0x0
+Symbols:
+  - Name:               .text
+    Value:              0x0
+    Section:            .text
+    Type:               0x0
+    StorageClass:       C_STAT
+    NumberOfAuxEntries: 1
+  - Name:               .data
+    Value:              0x80
+    Section:            .data
+    Type:               0x0
+    StorageClass:       C_STAT
+    NumberOfAuxEntries: 1
+
+# CHECK:      FileHeader {
+# CHECK-NEXT:   Magic: 0x1DF
+# CHECK-NEXT:   NumberOfSections: 2
+# CHECK-NEXT:   TimeStamp: None (0x0)
+# CHECK-NEXT:   SymbolTableOffset: 0x7A
+# CHECK-NEXT:   SymbolTableEntries: 4
+# CHECK-NEXT:   OptionalHeaderSize: 0x0
+# CHECK-NEXT:   Flags: 0x0
+# CHECK-NEXT: }
+# CHECK-NEXT: Sections [
+# CHECK-NEXT:   Section {
+# CHECK-NEXT:     Index: 1
+# CHECK-NEXT:     Name: .text
+# CHECK-NEXT:     PhysicalAddress: 0x0
+# CHECK-NEXT:     VirtualAddress: 0x0
+# CHECK-NEXT:     Size: 0x8
+# CHECK-NEXT:     RawDataOffset: 0x64
+# CHECK-NEXT:     RelocationPointer: 0x0
+# CHECK-NEXT:     LineNumberPointer: 0x0
+# CHECK-NEXT:     NumberOfRelocations: 0
+# CHECK-NEXT:     NumberOfLineNumbers: 0
+# CHECK-NEXT:     Type: STYP_TEXT (0x20)
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Section {
+# CHECK-NEXT:     Index: 2
+# CHECK-NEXT:     Name: .data
+# CHECK-NEXT:     PhysicalAddress: 0x8
+# CHECK-NEXT:     VirtualAddress: 0x8
+# CHECK-NEXT:     Size: 0x4
+# CHECK-NEXT:     RawDataOffset: 0x6C
+# CHECK-NEXT:     RelocationPointer: 0x70
+# CHECK-NEXT:     LineNumberPointer: 0x0
+# CHECK-NEXT:     NumberOfRelocations: 1
+# CHECK-NEXT:     NumberOfLineNumbers: 0
+# CHECK-NEXT:     Type: STYP_DATA (0x40)
+# CHECK-NEXT:   }
+# CHECK-NEXT: ]
+# CHECK-NEXT: Symbols [
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Index: 0
+# CHECK-NEXT:     Name: .text
+# CHECK-NEXT:     Value (RelocatableAddress): 0x0
+# CHECK-NEXT:     Section: .text
+# CHECK-NEXT:     Type: 0x0
+# CHECK-NEXT:     StorageClass: C_STAT (0x3)
+# CHECK-NEXT:     NumberOfAuxEntries: 1
+# CHECK-NEXT:     Sect Auxiliary Entry For Stat {
+# CHECK-NEXT:       Index: 1
+# CHECK-NEXT:       SectionLength: 0
+# CHECK-NEXT:       NumberOfRelocEnt: 0
+# CHECK-NEXT:       NumberOfLineNum: 0
+# CHECK-NEXT:     }
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Index: 2
+# CHECK-NEXT:     Name: .data
+# CHECK-NEXT:     Value (RelocatableAddress): 0x80
+# CHECK-NEXT:     Section: .data
+# CHECK-NEXT:     Type: 0x0
+# CHECK-NEXT:     StorageClass: C_STAT (0x3)
+# CHECK-NEXT:     NumberOfAuxEntries: 1
+# CHECK-NEXT:     Sect Auxiliary Entry For Stat {
+# CHECK-NEXT:       Index: 3
+# CHECK-NEXT:       SectionLength: 0
+# CHECK-NEXT:       NumberOfRelocEnt: 0
+# CHECK-NEXT:       NumberOfLineNum: 0
+# CHECK-NEXT:     }
+# CHECK-NEXT:   }
+# CHECK-NEXT: ]

llvm/utils/gn/secondary/llvm/lib/ObjectYAML/BUILD.gn

sources = [
     "ELFYAML.cpp",
     "MachOEmitter.cpp",
     "MachOYAML.cpp",
     "MinidumpEmitter.cpp",
     "MinidumpYAML.cpp",
     "ObjectYAML.cpp",
     "WasmEmitter.cpp",
     "WasmYAML.cpp",
+    "XCOFFEmitter.cpp"
     "XCOFFYAML.cpp",
     "YAML.cpp",
     "yaml2obj.cpp",
   ]
 }