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 21 matching lines @@
 // (TargetLowering, TargetDataLowering, and TargetHeaderLowering) we use the
 // following named constructors. For reference, each target Foo needs to
 // implement the following named constructors and initializer:
 //
 // namespace Foo {
 //   unique_ptr<Ice::TargetLowering> createTargetLowering(Ice::Cfg *);
 //   unique_ptr<Ice::TargetDataLowering>
 //       createTargetDataLowering(Ice::GlobalContext*);
 //   unique_ptr<Ice::TargetHeaderLowering>
 //       createTargetHeaderLowering(Ice::GlobalContext *);
-//   void staticInit();
+//   void staticInit(const ::Ice::ClFlags &Flags);
 // }
 #define SUBZERO_TARGET(X)                                                      \
   namespace X {                                                                \
   std::unique_ptr<::Ice::TargetLowering>                                       \
   createTargetLowering(::Ice::Cfg *Func);                                      \
   std::unique_ptr<::Ice::TargetDataLowering>                                   \
   createTargetDataLowering(::Ice::GlobalContext *Ctx);                         \
   std::unique_ptr<::Ice::TargetHeaderLowering>                                 \
   createTargetHeaderLowering(::Ice::GlobalContext *Ctx);                       \
-  void staticInit();                                                           \
+  void staticInit(const ::Ice::ClFlags &Flags);                                \
   } // end of namespace X
 #include "llvm/Config/SZTargets.def"
 #undef SUBZERO_TARGET
 
 namespace Ice {
 void LoweringContext::init(CfgNode *N) {
   Node = N;
   End = getNode()->getInsts().end();
   rewind();
   advanceForward(Next);
@@ skipping 59 matching lines @@
   default:
     llvm::report_fatal_error("Unsupported target");
 #define SUBZERO_TARGET(X)                                                      \
   case Target_##X:                                                             \
     return ::X::createTargetLowering(Func);
 #include "llvm/Config/SZTargets.def"
 #undef SUBZERO_TARGET
   }
 }
 
-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");
 #define SUBZERO_TARGET(X)                                                      \
   case Target_##X: {                                                           \
     static bool InitGuard##X = false;                                          \
     if (InitGuard##X) {                                                        \
       return;                                                                  \
     }                                                                          \
     InitGuard##X = true;                                                       \
-    ::X::staticInit();                                                         \
-  }
+    ::X::staticInit(Flags);                                                    \
+  } break;
 #include "llvm/Config/SZTargets.def"
 #undef SUBZERO_TARGET
   }
 }
 
 TargetLowering::TargetLowering(Cfg *Func)
     : Func(Func), Ctx(Func->getContext()), Context() {}
 
 void TargetLowering::genTargetHelperCalls() {
   for (CfgNode *Node : Func->getNodes()) {
@@ skipping 362 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();
   switch (Target) {
   default:
     llvm::report_fatal_error("Unsupported target");
 #define SUBZERO_TARGET(X)                                                      \
   case Target_##X:                                                             \
     return ::X::createTargetDataLowering(Ctx);
 #include "llvm/Config/SZTargets.def"
@@ skipping 40 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 59 matching lines @@
   case Target_##X:                                                             \
     return ::X::createTargetHeaderLowering(Ctx);
 #include "llvm/Config/SZTargets.def"
 #undef SUBZERO_TARGET
   }
 }
 
 TargetHeaderLowering::~TargetHeaderLowering() = default;
 
 } // end of namespace Ice