[ARM] Add Thumb Attributes for thumb thunks created in SLSHarding

[dmgreen]

Summary

Without this the function will be use an Arm subtarget, meaning the instructions in it will be invalid for the current subtarget.

[DavidSpickett]

Looks good but where are the tests?

[dmgreen]

In D144733#4154514, @DavidSpickett wrote:

Looks good but where are the tests?

Oh. The test is that we turn on ARM_MC::verifyInstructionPredicates and it doesn't it asserts in the existing tests, especially llvm/test/CodeGen/ARM/speculation-hardening-sls-boththunks.ll. I think this is the last piece that is missing from the llvm-tests. I can try and see if I can make something more specific to this change.

[DavidSpickett]

I see, LGTM then.

llvm/include/llvm/CodeGen/IndirectThunks.h

 protected:
   // A variable used to track whether (and possible which) thunks have been
   // inserted so far. InsertedThunksTy is usually a bool, but can be other types
   // to represent more than one type of thunk. Requires an |= operator to
   // accumulate results.
   InsertedThunksTy InsertedThunks;
   void doInitialization(Module &M) {}
   void createThunkFunction(MachineModuleInfo &MMI, StringRef Name,
-                           bool Comdat = true);
+                           bool Comdat = true, StringRef TargetAttrs = "");
 
 public:
   void init(Module &M) {
     InsertedThunks = InsertedThunksTy{};
     getDerived().doInitialization(M);
   }
   // return `true` if `MMI` or `MF` was modified
   bool run(MachineModuleInfo &MMI, MachineFunction &MF);
 };
 
 template <typename Derived, typename InsertedThunksTy>
 void ThunkInserter<Derived, InsertedThunksTy>::createThunkFunction(
-    MachineModuleInfo &MMI, StringRef Name, bool Comdat) {
+    MachineModuleInfo &MMI, StringRef Name, bool Comdat,
+    StringRef TargetAttrs) {
   assert(Name.startswith(getDerived().getThunkPrefix()) &&
          "Created a thunk with an unexpected prefix!");
 
   Module &M = const_cast<Module &>(*MMI.getModule());
   LLVMContext &Ctx = M.getContext();
   auto Type = FunctionType::get(Type::getVoidTy(Ctx), false);
   Function *F = Function::Create(Type,
                                  Comdat ? GlobalValue::LinkOnceODRLinkage
                                         : GlobalValue::InternalLinkage,
                                  Name, &M);
   if (Comdat) {
     F->setVisibility(GlobalValue::HiddenVisibility);
     F->setComdat(M.getOrInsertComdat(Name));
   }
 
   // Add Attributes so that we don't create a frame, unwind information, or
   // inline.
   AttrBuilder B(Ctx);
   B.addAttribute(llvm::Attribute::NoUnwind);
   B.addAttribute(llvm::Attribute::Naked);
+  if (TargetAttrs != "")
+    B.addAttribute("target-features", TargetAttrs);
   F->addFnAttrs(B);
 
   // Populate our function a bit so that we can verify.
   BasicBlock *Entry = BasicBlock::Create(Ctx, "entry", F);
   IRBuilder<> Builder(Entry);
 
   Builder.CreateRetVoid();
 

llvm/lib/Target/ARM/ARMSLSHardening.cpp

 ArmInsertedThunks SLSBLRThunkInserter::insertThunks(MachineModuleInfo &MMI,
                                                     MachineFunction &MF) {
   // FIXME: It probably would be possible to filter which thunks to produce
   // based on which registers are actually used in indirect calls in this
   // function. But would that be a worthwhile optimization?
   const ARMSubtarget *ST = &MF.getSubtarget<ARMSubtarget>();
   for (auto T : SLSBLRThunks)
     if (ST->isThumb() == T.isThumb)
-      createThunkFunction(MMI, T.Name, ComdatThunks);
+      createThunkFunction(MMI, T.Name, ComdatThunks,
+                          T.isThumb ? "+thumb-mode" : "");
   return ST->isThumb() ? ThumbThunk : ArmThunk;
 }
 
 void SLSBLRThunkInserter::populateThunk(MachineFunction &MF) {
   // FIXME: How to better communicate Register number, rather than through
   // name and lookup table?
   assert(MF.getName().startswith(getThunkPrefix()));
   auto ThunkIt = llvm::find_if(