lib/Transforms/IPO/ForceFunctionAttrs.cpp

   1 //===- ForceFunctionAttrs.cpp - Force function attrs for debugging --------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/Transforms/IPO/ForceFunctionAttrs.h"
  11 #include "llvm/ADT/StringSwitch.h"
  12 #include "llvm/IR/Function.h"
  13 #include "llvm/IR/LLVMContext.h"
  14 #include "llvm/IR/Module.h"
  15 #include "llvm/Support/Debug.h"
  16 #include "llvm/Support/raw_ostream.h"
  17 using namespace llvm;
  18
  19 #define DEBUG_TYPE "forceattrs"
  20
  21 static cl::list<std::string>
  22     ForceAttributes("force-attribute", cl::Hidden,
  23                     cl::desc("Add an attribute to a function. This should be a "
  24                              "pair of 'function-name:attribute-name', for "
  25                              "example -force-attribute=foo:noinline. This "
  26                              "option can be specified multiple times."));
  27
  28 static Attribute::AttrKind parseAttrKind(StringRef Kind) {
  29   return StringSwitch<Attribute::AttrKind>(Kind)
  30       .Case("alwaysinline", Attribute::AlwaysInline)
  31       .Case("builtin", Attribute::Builtin)
  32       .Case("cold", Attribute::Cold)
  33       .Case("convergent", Attribute::Convergent)
  34       .Case("inlinehint", Attribute::InlineHint)
  35       .Case("jumptable", Attribute::JumpTable)
  36       .Case("minsize", Attribute::MinSize)
  37       .Case("naked", Attribute::Naked)
  38       .Case("nobuiltin", Attribute::NoBuiltin)
  39       .Case("noduplicate", Attribute::NoDuplicate)
  40       .Case("noimplicitfloat", Attribute::NoImplicitFloat)
  41       .Case("noinline", Attribute::NoInline)
  42       .Case("nonlazybind", Attribute::NonLazyBind)
  43       .Case("noredzone", Attribute::NoRedZone)
  44       .Case("noreturn", Attribute::NoReturn)
  45       .Case("norecurse", Attribute::NoRecurse)
  46       .Case("nounwind", Attribute::NoUnwind)
  47       .Case("optnone", Attribute::OptimizeNone)
  48       .Case("optsize", Attribute::OptimizeForSize)
  49       .Case("readnone", Attribute::ReadNone)
  50       .Case("readonly", Attribute::ReadOnly)
  51       .Case("argmemonly", Attribute::ArgMemOnly)
  52       .Case("returns_twice", Attribute::ReturnsTwice)
  53       .Case("safestack", Attribute::SafeStack)
  54       .Case("sanitize_address", Attribute::SanitizeAddress)
  55       .Case("sanitize_memory", Attribute::SanitizeMemory)
  56       .Case("sanitize_thread", Attribute::SanitizeThread)
  57       .Case("ssp", Attribute::StackProtect)
  58       .Case("sspreq", Attribute::StackProtectReq)
  59       .Case("sspstrong", Attribute::StackProtectStrong)
  60       .Case("uwtable", Attribute::UWTable)
  61       .Default(Attribute::None);
  62 }
  63
  64 /// If F has any forced attributes given on the command line, add them.
  65 static void addForcedAttributes(Function &F) {
  66   for (auto &S : ForceAttributes) {
  67     auto KV = StringRef(S).split(':');
  68     if (KV.first != F.getName())
  69       continue;
  70
  71     auto Kind = parseAttrKind(KV.second);
  72     if (Kind == Attribute::None) {
  73       DEBUG(dbgs() << "ForcedAttribute: " << KV.second
  74                    << " unknown or not handled!\n");
  75       continue;
  76     }
  77     if (F.hasFnAttribute(Kind))
  78       continue;
  79     F.addFnAttr(Kind);
  80   }
  81 }
  82
  83 PreservedAnalyses ForceFunctionAttrsPass::run(Module &M) {
  84   if (ForceAttributes.empty())
  85     return PreservedAnalyses::all();
  86
  87   for (Function &F : M.functions())
  88     addForcedAttributes(F);
  89
  90   // Just conservatively invalidate analyses, this isn't likely to be important.
  91   return PreservedAnalyses::none();
  92 }
  93
  94 namespace {
  95 struct ForceFunctionAttrsLegacyPass : public ModulePass {
  96   static char ID; // Pass identification, replacement for typeid
  97   ForceFunctionAttrsLegacyPass() : ModulePass(ID) {
  98     initializeForceFunctionAttrsLegacyPassPass(
  99         *PassRegistry::getPassRegistry());
 100   }
 101
 102   bool runOnModule(Module &M) override {
 103     if (ForceAttributes.empty())
 104       return false;
 105
 106     for (Function &F : M.functions())
 107       addForcedAttributes(F);
 108
 109     // Conservatively assume we changed something.
 110     return true;
 111   }
 112 };
 113 }
 114
 115 char ForceFunctionAttrsLegacyPass::ID = 0;
 116 INITIALIZE_PASS(ForceFunctionAttrsLegacyPass, "forceattrs",
 117                 "Force set function attributes", false, false)
 118
 119 Pass *llvm::createForceFunctionAttrsLegacyPass() {
 120   return new ForceFunctionAttrsLegacyPass();
 121 }