Subzero: Add Non-SFI support for x86-32.

src/IceTargetLowering.cpp

 //===- subzero/src/IceTargetLowering.cpp - Basic lowering implementation --===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 88 matching lines @@
 TargetLowering *TargetLowering::createLowering(TargetArch Target, Cfg *Func) {
 #define SUBZERO_TARGET(X)                                                      \
   if (Target == Target_##X)                                                    \
     return Target##X::create(Func);
 #include "llvm/Config/SZTargets.def"
 
   Func->setError("Unsupported target");
   return nullptr;
 }
 
-void TargetLowering::staticInit(TargetArch Target) {
+void TargetLowering::staticInit(const ClFlags &Flags) {
+  const TargetArch Target = Flags.getTargetArch();
   // Call the specified target's static initializer.
   switch (Target) {
   default:
     llvm::report_fatal_error("Unsupported target");
     break;
 #define SUBZERO_TARGET(X)                                                      \
   case Target_##X: {                                                           \
     static bool InitGuard##X = false;                                          \
     if (InitGuard##X)                                                          \
       return;                                                                  \
     InitGuard##X = true;                                                       \
-    Target##X::staticInit();                                                   \
+    Target##X::staticInit(Flags);                                              \
   } break;
 #include "llvm/Config/SZTargets.def"
   }
 }
 
 TargetLowering::TargetLowering(Cfg *Func)
     : Func(Func), Ctx(Func->getContext()), Context() {}
 
 std::unique_ptr<Assembler> TargetLowering::createAssembler(TargetArch Target,
                                                            Cfg *Func) {
@@ skipping 373 matching lines @@
   InstCall *Call =
       InstCall::create(Func, MaxSrcs, Dest, CallTarget, HasTailCall);
   return Call;
 }
 
 bool TargetLowering::shouldOptimizeMemIntrins() {
   return Ctx->getFlags().getOptLevel() >= Opt_1 ||
          Ctx->getFlags().getForceMemIntrinOpt();
 }
 
-void TargetLowering::emitWithoutPrefix(const ConstantRelocatable *C) const {
+void TargetLowering::emitWithoutPrefix(const ConstantRelocatable *C,
+                                       const char *Suffix) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Ctx->getStrEmit();
   if (C->getSuppressMangling())
     Str << C->getName();
   else
     Str << Ctx->mangleName(C->getName());
+  Str << Suffix;
   RelocOffsetT Offset = C->getOffset();
   if (Offset) {
     if (Offset > 0)
       Str << "+";
     Str << Offset;
   }
 }
 
-void TargetLowering::emit(const ConstantRelocatable *C) const {
-  if (!BuildDefs::dump())
-    return;
-  Ostream &Str = Ctx->getStrEmit();
-  Str << getConstantPrefix();
-  emitWithoutPrefix(C);
-}
-
 std::unique_ptr<TargetDataLowering>
 TargetDataLowering::createLowering(GlobalContext *Ctx) {
   TargetArch Target = Ctx->getFlags().getTargetArch();
 #define SUBZERO_TARGET(X)                                                      \
   if (Target == Target_##X)                                                    \
     return TargetData##X::create(Ctx);
 #include "llvm/Config/SZTargets.def"
 
   llvm::report_fatal_error("Unsupported target data lowering");
 }
@@ skipping 37 matching lines @@
 
   Ostream &Str = Ctx->getStrEmit();
   const bool HasNonzeroInitializer = Var.hasNonzeroInitializer();
   const bool IsConstant = Var.getIsConstant();
   const SizeT Size = Var.getNumBytes();
   const IceString MangledName = Var.mangleName(Ctx);
 
   Str << "\t.type\t" << MangledName << ",%object\n";
 
   const bool UseDataSections = Ctx->getFlags().getDataSections();
+  const bool UseNonsfi = Ctx->getFlags().getUseNonsfi();
   const IceString Suffix =
       dataSectionSuffix(SectionSuffix, MangledName, UseDataSections);
-  if (IsConstant)
+  if (IsConstant && UseNonsfi)
+    Str << "\t.section\t.data.rel.ro" << Suffix << ",\"aw\",%progbits\n";
+  else if (IsConstant)
     Str << "\t.section\t.rodata" << Suffix << ",\"a\",%progbits\n";
   else if (HasNonzeroInitializer)
     Str << "\t.section\t.data" << Suffix << ",\"aw\",%progbits\n";
   else
     Str << "\t.section\t.bss" << Suffix << ",\"aw\",%nobits\n";
 
   if (IsExternal)
     Str << "\t.globl\t" << MangledName << "\n";
 
   const uint32_t Align = Var.getAlignment();
@@ skipping 56 matching lines @@
   if (Target == Target_##X)                                                    \
     return TargetHeader##X::create(Ctx);
 #include "llvm/Config/SZTargets.def"
 
   llvm::report_fatal_error("Unsupported target header lowering");
 }
 
 TargetHeaderLowering::~TargetHeaderLowering() = default;
 
 } // end of namespace Ice