Iasm and obj lowering for advanced switch lowering.

src/IceELFObjectWriter.cpp

 //===- subzero/src/IceELFObjectWriter.cpp - ELF object file writer --------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file defines the writer for ELF relocatable object files.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "IceELFObjectWriter.h"
 
 #include "IceAssembler.h"
 #include "IceDefs.h"
 #include "IceELFSection.h"
 #include "IceELFStreamer.h"
 #include "IceGlobalContext.h"
 #include "IceGlobalInits.h"
+#include "IceInst.h"
 #include "IceOperand.h"
 #include "llvm/Support/MathExtras.h"
 
 using namespace llvm::ELF;
 
 namespace Ice {
 
 namespace {
 
 struct {
@@ skipping 513 matching lines @@
 template void ELFObjectWriter::writeConstantPool<ConstantDouble>(Type Ty);
 
 template void ELFObjectWriter::writeConstantPool<ConstantInteger32>(Type Ty);
 
 void ELFObjectWriter::writeAllRelocationSections() {
   writeRelocationSections(RelTextSections);
   writeRelocationSections(RelDataSections);
   writeRelocationSections(RelRODataSections);
 }
 
+void ELFObjectWriter::writeJumpTable(const JumpTableData &JT,
+                                     FixupKind RelocationKind) {
+  ELFDataSection *Section;
+  ELFRelocationSection *RelSection;
+  const Elf64_Xword PointerSize = typeWidthInBytes(getPointerType());
+  const Elf64_Xword ShAddralign = PointerSize;
+  const Elf64_Xword ShEntsize = PointerSize;
+  const IceString SectionName =
+      MangleSectionName(".rodata", JT.getFunctionName() + "$jumptable");
+  Section = createSection<ELFDataSection>(SectionName, SHT_PROGBITS, SHF_ALLOC,
+                                          ShAddralign, ShEntsize);
+  Section->setFileOffset(alignFileOffset(ShAddralign));
+  RODataSections.push_back(Section);
+  RelSection = createRelocationSection(Section);
+  RelRODataSections.push_back(RelSection);
+
+  const uint8_t SymbolType = STT_OBJECT;
+  Section->padToAlignment(Str, PointerSize);
+  bool IsExternal = Ctx.getFlags().getDisableInternal();
+  const uint8_t SymbolBinding = IsExternal ? STB_GLOBAL : STB_LOCAL;
+  IceString JumpTableName =
+      InstJumpTable::makeName(JT.getFunctionName(), JT.getId());
+  SymTab->createDefinedSym(JumpTableName, SymbolType, SymbolBinding, Section,
+                           Section->getCurrentSize(), PointerSize);
+  StrTab->add(JumpTableName);
+
+  for (intptr_t TargetOffset : JT.getTargetOffsets()) {
+    AssemblerFixup NewFixup;
+    NewFixup.set_position(Section->getCurrentSize());
+    NewFixup.set_kind(RelocationKind);
+    constexpr bool SuppressMangling = true;
+    NewFixup.set_value(Ctx.getConstantSym(TargetOffset, JT.getFunctionName(),
+                                          SuppressMangling));
+    RelSection->addRelocation(NewFixup);
+    Section->appendRelocationOffset(Str, RelSection->isRela(), TargetOffset);
+  }
+}
+
 void ELFObjectWriter::setUndefinedSyms(const ConstantList &UndefSyms) {
   for (const Constant *S : UndefSyms) {
     const auto Sym = llvm::cast<ConstantRelocatable>(S);
     const IceString &Name = Sym->getName();
     bool BadIntrinsic;
     const Intrinsics::FullIntrinsicInfo *Info =
         Ctx.getIntrinsicsInfo().find(Name, BadIntrinsic);
     if (Info)
       continue;
     assert(!BadIntrinsic);
@@ skipping 60 matching lines @@
   if (ELF64) {
     writeELFHeaderInternal<true>(ShOffset, ShStrTab->getNumber(),
                                  AllSections.size());
   } else {
     writeELFHeaderInternal<false>(ShOffset, ShStrTab->getNumber(),
                                   AllSections.size());
   }
 }
 
 } // end of namespace Ice