[WebAssembly] Emit clangast in custom section aligned by 4 bytes

[kateinoigakukun]

Summary

Emit __clangast in custom section instead of named data segment
to find it while iterating sections.
This could be avoided if all data segements (the wasm sense) were
represented as their own sections (in the llvm sense).
This can be resolved by https://github.com/WebAssembly/tool-conventions/issues/138

And the on-disk hashtable in clangast needs to be aligned by 4 bytes,
so add paddings in name length field in custom section header.

The length of clangast section name can be represented in 1 byte
by leb128, and possible maximum pads are 3 bytes, so the section
name length won't be invalid in theory.

Fixes https://bugs.llvm.org/show_bug.cgi?id=35928

[sbc100]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

1701 ↗

(On Diff #244358)

Hmm.. it looks like this function isn't actually needed: https://reviews.llvm.org/D74565.

Does this change work if you simply return K here? I guess/hope it does.

llvm/lib/MC/WasmObjectWriter.cpp

383

I general this seems like trick that could work. However, I think this value is encoded as an LEB32 which means its max length is technically 5. I don't think a 6 byte LEB is valid .

1113

Why this part needed ? What happens if you don't specify this? I looks like removes section symbol from the symtab?

[sbc100]

Can we get a test to see the effect of this patch?

[sbc100]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

1701 ↗

(On Diff #244358)

Let me know if this change is uneeded with https://reviews.llvm.org/D74565.? I'll hold of landing that until I hear back. Hopefully it will just work and simplify this patch once it lands.

[kateinoigakukun]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

1701 ↗

(On Diff #244358)

Thanks for suggestion. But this special treatment is necessary to put the clangast in custom section.
The section kind K come from TargetLoweringObjectFile::getKindForGlobal which is called from AsmPrinter::EmitGlobalVariable, but the getKindForGlobal infers that __clangast global variable should be put in readonly section.

Then readonly section is put in data segment for WebAssembly. But what we really want in WebAssembly context is to put clangast metadata in custom section.

Should I change getKindForGlobal to return metadata section kind for clangast? But I'm not sure how the change effects to other object formats.

llvm/lib/MC/WasmObjectWriter.cpp

383

Thanks. I see, I confirmed that you are right https://webassembly.github.io/spec/core/binary/values.html#integers

Then how should I pad section start? Should I pad with empty data segment or something else?

1113

This part prevents the clangast section symbol from putting it in symbol table.
This part is necessary to put clangast in custom section because the sym is treated as data type but the actual content is not in data section, so WasmObjectWriter raised abortion with "data symbols must live in a data section: __clang_ast" when it tries to write the sym in symtab.

[kateinoigakukun]

Could you take a look again?

[sbc100]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

1701 ↗

(On Diff #244358)

I see. I'd still rather get rid of this function completely in the long run, so if I land my change first you can just do this check directly in TargetLoweringObjectFileWasm::getExplicitSectionGlobal. Is there some other way we can identify __clang_ast here other than by section name? Is it a special kind of symbol?

In the long run I think this problem will be solved by putting each symbol in its own wasm section but to do that we need to diverge from the spec a little. Would you mind added a TODO here and referencing this bug: https://github.com/WebAssembly/tool-conventions/issues/138.

I think it we fix this bug we won't need this change.

It won't solve the alignment issue though :(

llvm/lib/MC/WasmObjectWriter.cpp

383

I think the problem is that the wasm file itself doesn't have the concept of alignment of sections, since its not designed to memory mapped in that way. Its designed to be parsed. Is the loading code expecting the file offset of the section to be aligned? I'm not sure how we can work around this.

llvm/test/MC/WebAssembly/clangast.ll

29 ↗

(On Diff #245051)

I'm confused by this size value. Shouldn't it be at least 27?

[sbc100]

My colleague pointed out that one way to archive padding in the binary format would be to create a synthetic custom section that precedes that one you want to align. Its kind of horrible, but wasm files were not designed to used memory mapped like this.

[kateinoigakukun]

In D74531#1885606, @sbc100 wrote:

My colleague pointed out that one way to archive padding in the binary format would be to create a synthetic custom section that precedes that one you want to align. Its kind of horrible, but wasm files were not designed to used memory mapped like this.

Thanks! I'll try this way. My only concern is whether the order of custom sections are guaranteed.

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

1701 ↗

(On Diff #244358)

OK, I'll update after https://reviews.llvm.org/D74565 merged.

Is there some other way we can identify __clang_ast here other than by section name? Is it a special kind of symbol?

I couldn't find any other way to identify the section. I think it's a really special case to support PCH.

In the long run I think this problem will be solved by putting each symbol in its own wasm section but to do that we need to diverge from the spec a little. Would you mind added a TODO here and referencing this bug: https://github.com/WebAssembly/tool-conventions/issues/138.

I see. I agree with you. I'll add TODO comment here.

[sbc100]

Thanks! I'll try this way. My only concern is whether the order of custom sections are guaranteed.

If you simple create the extra section right there in the WasmObjectFileWriter it will be in the right order. I wasn't recommending creating an extra section at the llvm level.

[sbc100]

I just landed https://reviews.llvm.org/D77115 which does similar thing for the embedded bitcode sections and should simplify this CL a little. Although it doesn't try to do the file offset alignment.

If we can figure out way to do alignment I think that is the only remaining blocker for this.

llvm/lib/MC/WasmObjectWriter.cpp

1113

I think this part might no longer be needed after https://reviews.llvm.org/D77115

[patcheng]

llvm/lib/MC/WasmObjectWriter.cpp

383

BTW, here was an implementation I did way back: https://reviews.llvm.org/D42233

If I remember correct, you could spread the extra padding across multiple integer fields.

[kateinoigakukun]

I'm sorry to keep you waiting. I updated to reduce hacks in backend to emit clangast in custom section and move it to clang.
And emit paddings for alignment to fit into 5 bytes.

[sbc100]

llvm/lib/MC/WasmObjectWriter.cpp

399

I would leave the first sentence alone which that applies to all custom sections. The second part of this sentence (the new part) is maybe not needed since you have a comment already on line 378.

Also, how about keeping the simpler form in the default case, and putting this new code in a new method. e.g.:

if (Name != "__clangast") {
  writeString(Name);
} else {
  writeStringWithAlignment(Name, 4);
}

Then the entire new method can be marked with the TODO to remove it if/when we change the section mapping.

[kateinoigakukun]

Thank you for taking a look again. OK, I extracted writeStringWithAlignment and updated comment lines.

[kateinoigakukun]

Thanks for reviewing! Can you merge this patch? I have no commit access.

clang/lib/CodeGen/ObjectFilePCHContainerOperations.cpp

void HandleTranslationUnit(ASTContext &Ctx) override {
     auto Triple = Ctx.getTargetInfo().getTriple();
     if (!llvm::TargetRegistry::lookupTarget(Triple.getTriple(), Error))
       llvm::report_fatal_error(llvm::Twine(Error));
 
     // Emit the serialized Clang AST into its own section.
     assert(Buffer->IsComplete && "serialization did not complete");
     auto &SerializedAST = Buffer->Data;
     auto Size = SerializedAST.size();
+
+    if (Triple.isOSBinFormatWasm()) {
+      // Emit __clangast in custom section instead of named data segment
+      // to find it while iterating sections.
+      // This could be avoided if all data segements (the wasm sense) were
+      // represented as their own sections (in the llvm sense).
+      // TODO: https://github.com/WebAssembly/tool-conventions/issues/138
+      llvm::NamedMDNode *MD =
+          M->getOrInsertNamedMetadata("wasm.custom_sections");
+      llvm::Metadata *Ops[2] = {
+          llvm::MDString::get(*VMContext, "__clangast"),
+          llvm::MDString::get(*VMContext,
+                              StringRef(SerializedAST.data(), Size))};
+      auto *NameAndContent = llvm::MDTuple::get(*VMContext, Ops);
+      MD->addOperand(NameAndContent);
+    } else {
       auto Int8Ty = llvm::Type::getInt8Ty(*VMContext);
       auto *Ty = llvm::ArrayType::get(Int8Ty, Size);
       auto *Data = llvm::ConstantDataArray::getString(
           *VMContext, StringRef(SerializedAST.data(), Size),
           /*AddNull=*/false);
       auto *ASTSym = new llvm::GlobalVariable(
-        *M, Ty, /*constant*/ true, llvm::GlobalVariable::InternalLinkage, Data,
-        "__clang_ast");
+          *M, Ty, /*constant*/ true, llvm::GlobalVariable::InternalLinkage,
+          Data, "__clang_ast");
       // The on-disk hashtable needs to be aligned.
       ASTSym->setAlignment(llvm::Align(8));
 
       // Mach-O also needs a segment name.
       if (Triple.isOSBinFormatMachO())
         ASTSym->setSection("__CLANG,__clangast");
       // COFF has an eight character length limit.
       else if (Triple.isOSBinFormatCOFF())
         ASTSym->setSection("clangast");
       else
         ASTSym->setSection("__clangast");
+    }
 
     LLVM_DEBUG({
       // Print the IR for the PCH container to the debug output.
       llvm::SmallString<0> Buffer;
       clang::EmitBackendOutput(
           Diags, HeaderSearchOpts, CodeGenOpts, TargetOpts, LangOpts,
           Ctx.getTargetInfo().getDataLayoutString(), M.get(),
           BackendAction::Backend_EmitLL,

clang/test/PCH/pch-wasm.c

+// REQUIRES: webassembly-registered-target
+// RUN: %clang_cc1 -triple wasm32-unknown-unknown-wasm -emit-pch -fmodule-format=obj %S/pchpch1.h -o - | llvm-objdump --section-headers - | FileCheck %s
+
+// Ensure that clangast section should be emitted in a section for wasm object file
+
+// CHECK: file format wasm
+// CHECK: __clangast   {{[0-9a-f]+}} {{[0-9a-f]+}}

llvm/lib/MC/WasmObjectWriter.cpp

private:
   uint64_t writeOneObject(MCAssembler &Asm, const MCAsmLayout &Layout,
                           DwoMode Mode);
 
   void writeString(const StringRef Str) {
     encodeULEB128(Str.size(), W->OS);
     W->OS << Str;
   }
 
+  void writeStringWithAlignment(const StringRef Str, unsigned Alignment);
+
   void writeI32(int32_t val) {
     char Buffer[4];
     support::endian::write32le(Buffer, val);
     W->OS.write(Buffer, sizeof(Buffer));
   }
 
   void writeI64(int64_t val) {
     char Buffer[8];
void WasmObjectWriter::startSection(SectionBookkeeping &Section,
   encodeULEB128(0, W->OS, 5);
 
   // The position where the section starts, for measuring its size.
   Section.ContentsOffset = W->OS.tell();
   Section.PayloadOffset = W->OS.tell();
   Section.Index = SectionCount++;
 }
 
+// Write a string with extra paddings for trailing alignment
+// TODO: support alignment at asm and llvm level?
+void WasmObjectWriter::writeStringWithAlignment(const StringRef Str,
+                                                unsigned Alignment) {
+
+  // Calculate the encoded size of str length and add pads based on it and
+  // alignment.
+  raw_null_ostream NullOS;
+  uint64_t StrSizeLength = encodeULEB128(Str.size(), NullOS);
+  uint64_t Offset = W->OS.tell() + StrSizeLength + Str.size();
+  uint64_t Paddings = offsetToAlignment(Offset, Align(Alignment));
+  Offset += Paddings;
+
+  // LEB128 greater than 5 bytes is invalid
+  assert((StrSizeLength + Paddings) <= 5 && "too long string to align");
+
+  encodeSLEB128(Str.size(), W->OS, StrSizeLength + Paddings);
+  W->OS << Str;
+
+  assert(W->OS.tell() == Offset && "invalid padding");
+}
+
 void WasmObjectWriter::startCustomSection(SectionBookkeeping &Section,
                                           StringRef Name) {
   LLVM_DEBUG(dbgs() << "startCustomSection " << Name << "\n");
   startSection(Section, wasm::WASM_SEC_CUSTOM);
 
   // The position where the section header ends, for measuring its size.
   Section.PayloadOffset = W->OS.tell();
 
   // Custom sections in wasm also have a string identifier.
+  if (Name != "__clangast") {
     writeString(Name);
+  } else {
+    // The on-disk hashtable in clangast needs to be aligned by 4 bytes.
+    writeStringWithAlignment(Name, 4);
+  }
 
   // The position where the custom section starts.
   Section.ContentsOffset = W->OS.tell();
 }
 
 // Now that the section is complete and we know how big it is, patch up the
 // section size field at the start of the section.
 void WasmObjectWriter::endSection(SectionBookkeeping &Section) {
llvm::stable_sort(
       });
 
   SectionBookkeeping Section;
   startCustomSection(Section, std::string("reloc.") + Name.str());
 
   encodeULEB128(SectionIndex, W->OS);
   encodeULEB128(Relocs.size(), W->OS);
   for (const WasmRelocationEntry &RelEntry : Relocs) {
     uint64_t Offset =
         RelEntry.Offset + RelEntry.FixupSection->getSectionOffset();
     uint32_t Index = getRelocationIndexValue(RelEntry);
 
     W->OS << char(RelEntry.Type);
     encodeULEB128(Offset, W->OS);
     encodeULEB128(Index, W->OS);
     if (RelEntry.hasAddend())
       encodeSLEB128(RelEntry.Addend, W->OS);

llvm/test/MC/WebAssembly/custom-section-alignment.ll

+; RUN: llc -filetype=obj %s -o - | od -t x1 -v | FileCheck %s
+
+target triple = "wasm32-unknown-unknown"
+
+!0 = !{ !"before", !"\de\ad\be\ef" }
+!1 = !{ !"__clangast", !"\fe\ed\fa\ce" }
+!wasm.custom_sections = !{ !0, !1 }
+
+; Ensure that __clangast content is aligned by 4 bytes
+; CHECK: {{(([0-9a-f]{2} ){4})*}}fe ed fa ce