[ARM] Add support for long-call/short-call attribute

[weimingz]

Summary

GNU has long_call/short_call attribute support for ARM: https://gcc.gnu.org/onlinedocs/gcc-6.1.0/gcc/ARM-Function-Attributes.html#ARM-Function-Attributes.

LLVM/clang only supports the global switch/option (-mlong-call -mno-long-call). In some scenarios, we need to turn it on/off for individual functions.

Backend patch: http://reviews.llvm.org/D19609

include/clang/Basic/Attr.td

let Args = [EnumArgument<"Interrupt", "InterruptType",
                            ["IRQ", "FIQ", "SWI", "ABORT", "UNDEF", ""],
                            ["IRQ", "FIQ", "SWI", "ABORT", "UNDEF", "Generic"],
                            1>];
   let ParseKind = "Interrupt";
   let HasCustomParsing = 1;
   let Documentation = [ARMInterruptDocs];
 }
 
+def ARMLongCall : InheritableAttr, TargetSpecificAttr<TargetARM> {
+  let Spellings = [GNU<"long_call">];
+  let Subjects = SubjectList<[Function]>;
+  let Documentation = [ARMLongCallDocs];
+}
+
+def ARMShortCall : InheritableAttr, TargetSpecificAttr<TargetARM> {
+  let Spellings = [GNU<"short_call">];
+  let Subjects = SubjectList<[Function]>;
+  let Documentation = [ARMLongCallDocs];
+}
+
 def AsmLabel : InheritableAttr {
   let Spellings = [Keyword<"asm">, Keyword<"__asm__">];
   let Args = [StringArgument<"Label">];
   let SemaHandler = 0;
   let Documentation = [Undocumented];
 }
 
 def Availability : InheritableAttr {

include/clang/Basic/AttrDocs.td

- If the CPU is not M-class, the return instruction is changed to one of the
 
   Unfortunately the compiler is unable to make this guarantee for an "UNDEF"
   handler, where the offset from "lr" to the preferred return address depends on
   the execution state of the code which generated the exception. In this case
   a sequence equivalent to "movs pc, lr" will be used.
   }];
 }
 
+def ARMLongCallDocs : Documentation {
+  let Category = DocCatFunction;
+  let Content = [{
+Clang supports the GNU style long-call/short-call attribute on ARM targets.
+These attributes overrides the command line options of -mlong-calls/-mno-long-calls
+for individual functions.
+  }];
+}
+
 def MipsInterruptDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
 Clang supports the GNU style ``__attribute__((interrupt("ARGUMENT")))`` attribute on
 MIPS targets. This attribute may be attached to a function definition and instructs
 the backend to generate appropriate function entry/exit code so that it can be used
 directly as an interrupt service routine.
 

lib/CodeGen/CGCall.cpp

static void AddAttributesFromFunctionProtoType(ASTContext &Ctx,
   if (!FPT)
     return;
 
   if (!isUnresolvedExceptionSpec(FPT->getExceptionSpecType()) &&
       FPT->isNothrow(Ctx))
     FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
 }
 
+static bool hasExtraTargetAttr(const FunctionDecl *FD) {
+  return FD->hasAttr<ARMLongCallAttr>() || FD->hasAttr<ARMShortCallAttr>();
+}
+
+static void addExtraTargetAttr(const FunctionDecl *FD,
+                               std::vector<std::string> &FS) {
+  if (FD->hasAttr<ARMLongCallAttr>())
+    FS.push_back("+long-calls");
+  if (FD->hasAttr<ARMShortCallAttr>())
+    FS.push_back("-long-calls");
+}
+
 void CodeGenModule::ConstructAttributeList(
     StringRef Name, const CGFunctionInfo &FI, CGCalleeInfo CalleeInfo,
     AttributeListType &PAL, unsigned &CallingConv, bool AttrOnCallSite) {
   llvm::AttrBuilder FuncAttrs;
   llvm::AttrBuilder RetAttrs;
   bool HasOptnone = false;
 
   CallingConv = FI.getEffectiveCallingConvention();
if (AttrOnCallSite) {
     if (CodeGenOpts.StackRealignment)
       FuncAttrs.addAttribute("stackrealign");
 
     // Add target-cpu and target-features attributes to functions. If
     // we have a decl for the function and it has a target attribute then
     // parse that and add it to the feature set.
     StringRef TargetCPU = getTarget().getTargetOpts().CPU;
     const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(TargetDecl);
-    if (FD && FD->hasAttr<TargetAttr>()) {
+    if (FD && (FD->hasAttr<TargetAttr>() || hasExtraTargetAttr(FD))) {
       llvm::StringMap<bool> FeatureMap;
       getFunctionFeatureMap(FeatureMap, FD);
 
       // Produce the canonical string for this set of features.
       std::vector<std::string> Features;
       for (llvm::StringMap<bool>::const_iterator it = FeatureMap.begin(),
                                                  ie = FeatureMap.end();
            it != ie; ++it)
         Features.push_back((it->second ? "+" : "-") + it->first().str());
-
+      addExtraTargetAttr(FD, Features);
       // Now add the target-cpu and target-features to the function.
       // While we populated the feature map above, we still need to
       // get and parse the target attribute so we can get the cpu for
       // the function.
       const auto *TD = FD->getAttr<TargetAttr>();
+      if (TD) {
         TargetAttr::ParsedTargetAttr ParsedAttr = TD->parse();
         if (ParsedAttr.second != "")
           TargetCPU = ParsedAttr.second;
+      }
       if (TargetCPU != "")
         FuncAttrs.addAttribute("target-cpu", TargetCPU);
       if (!Features.empty()) {
         std::sort(Features.begin(), Features.end());
         FuncAttrs.addAttribute(
             "target-features",
             llvm::join(Features.begin(), Features.end(), ","));
       }

lib/Sema/SemaDeclAttr.cpp

if (!Attr.isStmtAttr()) {
       break;
     }
     S.Diag(Attr.getLoc(), diag::err_stmt_attribute_invalid_on_decl)
         << Attr.getName() << D->getLocation();
     break;
   case AttributeList::AT_Interrupt:
     handleInterruptAttr(S, D, Attr);
     break;
+  case AttributeList::AT_ARMLongCall:
+    handleSimpleAttribute<ARMLongCallAttr>(S, D, Attr);
+    break;
+  case AttributeList::AT_ARMShortCall:
+    handleSimpleAttribute<ARMShortCallAttr>(S, D, Attr);
+    break;
   case AttributeList::AT_X86ForceAlignArgPointer:
     handleX86ForceAlignArgPointerAttr(S, D, Attr);
     break;
   case AttributeList::AT_DLLExport:
   case AttributeList::AT_DLLImport:
     handleDLLAttr(S, D, Attr);
     break;
   case AttributeList::AT_Mips16:

test/CodeGen/arm-longcall-attr.c

+// RUN: %clang -target arm-linux-gnueabi -S -emit-llvm -o - %s | FileCheck %s --check-prefix=NOFLAG --check-prefix=COMMON
+// RUN: %clang -target arm-linux-gnueabi -S -emit-llvm -mlong-calls -o - %s | FileCheck %s --check-prefix=FLAG_LONG --check-prefix=COMMON
+// RUN: %clang -target arm-linux-gnueabi -S -emit-llvm -mno-long-calls -o - %s | FileCheck %s --check-prefix=FLAG_SHORT --check-prefix=COMMON
+
+__attribute__((long_call)) extern void foo_long();
+
+__attribute__((short_call)) extern void foo_short();
+
+extern void foo_default();
+
+void bar() {
+  foo_default();
+  foo_long();
+  foo_short();
+}
+// COMMON: define void @bar() [[CALLER_ATTR:#[0-9]+]] {
+// COMMON: declare void @foo_default(...) [[NOFLAG_ATTR:#[0-9]+]]
+// COMMON: declare void @foo_long(...) [[LONG_ATTR:#[0-9]+]]
+// COMMON: declare void @foo_short(...) [[SHORT_ATTR:#[0-9]+]]
+
+//NOFLAG-NOT: attributes [[CALLER_ATTR]] = { {{.*}} long-calls
+//FLAG_LONG: attributes [[CALLER_ATTR]] = { {{.*}}"target-features"="{{.*}}+long-calls
+//FLAG_SHORT-NOT: attributes [[CALLER_ATTR]] = { {{.*}} long-calls
+
+//NOFLAG-NOT: attributes [[NOFLAG_ATTR]] = { {{.*}} long-calls
+//FLAG_LONG: attributes [[NOFLAG_ATTR]] = { {{.*}} "target-features"="{{.*}}+long-calls
+//FLAG_SHORT-NOT: attributes [[NOFLAG_ATTR]] = { {{.*}} long-calls
+
+//COMMON: attributes [[LONG_ATTR]] = { {{.*}} "target-features"={{.*}}+long-calls
+
+//COMMON: attributes [[SHORT_ATTR]] = { {{.*}} "target-features"={{.*}}-long-calls
+