Implement the flatten attribute.

[pcc]

Summary

This is a GNU attribute that causes functions called by a function with the
attribute to be inlined where possible. It is implemented by giving calls
in such functions the alwaysinline attribute.

[pcc]

Add tests, docs

[pcc]

Closed by commit rL209217 (authored by @pcc).

include/clang/Basic/Attr.td

 }
 
 def MinSize : InheritableAttr {
   let Spellings = [GNU<"minsize">];
   let Subjects = SubjectList<[Function, ObjCMethod], ErrorDiag>;
   let Documentation = [Undocumented];
 }
 
+def Flatten : InheritableAttr {
+  let Spellings = [GNU<"flatten">];
+  let Subjects = SubjectList<[Function]>;
+  let Documentation = [Undocumented];
+}
+
 def Format : InheritableAttr {
   let Spellings = [GCC<"format">];
   let Args = [IdentifierArgument<"Type">, IntArgument<"FormatIdx">,
               IntArgument<"FirstArg">];
   let Subjects = SubjectList<[ObjCMethod, Block, HasFunctionProto], WarnDiag,
                              "ExpectedFunction">;
   let Documentation = [FormatDocs];
 }

lib/CodeGen/CGCall.cpp

llvm::Type *CodeGenTypes::GetFunctionTypeForVTable(GlobalDecl GD) {
   if (isa<CXXDestructorDecl>(MD))
     Info = &arrangeCXXDestructor(cast<CXXDestructorDecl>(MD), GD.getDtorType());
   else
     Info = &arrangeCXXMethodDeclaration(MD);
   return GetFunctionType(*Info);
 }
 
 void CodeGenModule::ConstructAttributeList(const CGFunctionInfo &FI,
+                                           const Decl *CallerDecl,
                                            const Decl *TargetDecl,
                                            AttributeListType &PAL,
                                            unsigned &CallingConv,
                                            bool AttrOnCallSite) {
   llvm::AttrBuilder FuncAttrs;
   llvm::AttrBuilder RetAttrs;
 
   CallingConv = FI.getEffectiveCallingConvention();
 
   if (FI.isNoReturn())
     FuncAttrs.addAttribute(llvm::Attribute::NoReturn);
 
+  if (CallerDecl) {
+    if (CallerDecl->hasAttr<FlattenAttr>())
+      FuncAttrs.addAttribute(llvm::Attribute::AlwaysInline);
+  }
+
   // FIXME: handle sseregparm someday...
   if (TargetDecl) {
     if (TargetDecl->hasAttr<ReturnsTwiceAttr>())
       FuncAttrs.addAttribute(llvm::Attribute::ReturnsTwice);
     if (TargetDecl->hasAttr<NoThrowAttr>())
       FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
     if (TargetDecl->hasAttr<NoReturnAttr>())
       FuncAttrs.addAttribute(llvm::Attribute::NoReturn);
if (llvm::Function *CalleeF = dyn_cast<llvm::Function>(CE->getOperand(0))) {
         // always_inline.
         if (ArgsMatch)
           Callee = CalleeF;
       }
     }
 
   unsigned CallingConv;
   CodeGen::AttributeListType AttributeList;
-  CGM.ConstructAttributeList(CallInfo, TargetDecl, AttributeList,
+  CGM.ConstructAttributeList(CallInfo, CurCodeDecl, TargetDecl, AttributeList,
                              CallingConv, true);
   llvm::AttributeSet Attrs = llvm::AttributeSet::get(getLLVMContext(),
                                                      AttributeList);
 
   llvm::BasicBlock *InvokeDest = 0;
   if (!Attrs.hasAttribute(llvm::AttributeSet::FunctionIndex,
                           llvm::Attribute::NoUnwind))
     InvokeDest = getInvokeDest();

lib/CodeGen/CodeGenModule.h

public:
 
   /// Return true iff the given type uses 'fp2ret' when used as a return type.
   bool ReturnTypeUsesFP2Ret(QualType ResultType);
 
   /// Get the LLVM attributes and calling convention to use for a particular
   /// function type.
   ///
   /// \param Info - The function type information.
+  /// \param CallerDecl - The decl of the caller, if available
   /// \param TargetDecl - The decl these attributes are being constructed
   /// for. If supplied the attributes applied to this decl may contribute to the
   /// function attributes and calling convention.
   /// \param PAL [out] - On return, the attribute list to use.
   /// \param CallingConv [out] - On return, the LLVM calling convention to use.
   void ConstructAttributeList(const CGFunctionInfo &Info,
+                              const Decl *CallerDecl,
                               const Decl *TargetDecl,
                               AttributeListType &PAL,
                               unsigned &CallingConv,
                               bool AttrOnCallSite);
 
   StringRef getMangledName(GlobalDecl GD);
   void getBlockMangledName(GlobalDecl GD, MangleBuffer &Buffer,
                            const BlockDecl *BD);

lib/CodeGen/CodeGenModule.cpp

void CodeGenModule::setFunctionDefinitionAttributes(const FunctionDecl *D,
   setNonAliasAttributes(D, F);
 }
 
 void CodeGenModule::SetLLVMFunctionAttributes(const Decl *D,
                                               const CGFunctionInfo &Info,
                                               llvm::Function *F) {
   unsigned CallingConv;
   AttributeListType AttributeList;
-  ConstructAttributeList(Info, D, AttributeList, CallingConv, false);
+  ConstructAttributeList(Info, 0, D, AttributeList, CallingConv, false);
   F->setAttributes(llvm::AttributeSet::get(getLLVMContext(), AttributeList));
   F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
 }
 
 /// Determines whether the language options require us to model
 /// unwind exceptions.  We treat -fexceptions as mandating this
 /// except under the fragile ObjC ABI with only ObjC exceptions
 /// enabled.  This means, for example, that C with -fexceptions

lib/CodeGen/MicrosoftCXXABI.cpp

llvm::Function *MicrosoftCXXABI::EmitVirtualMemPtrThunk(
   llvm::Value *VTable =
       CGF.GetVTablePtr(This, ThunkTy->getPointerTo()->getPointerTo());
   llvm::Value *VFuncPtr =
       CGF.Builder.CreateConstInBoundsGEP1_64(VTable, ML.Index, "vfn");
   llvm::Value *Callee = CGF.Builder.CreateLoad(VFuncPtr);
 
   unsigned CallingConv;
   CodeGen::AttributeListType AttributeList;
-  CGM.ConstructAttributeList(FnInfo, MD, AttributeList, CallingConv, true);
+  CGM.ConstructAttributeList(FnInfo, 0, MD, AttributeList, CallingConv, true);
   llvm::AttributeSet Attrs =
       llvm::AttributeSet::get(CGF.getLLVMContext(), AttributeList);
 
   // Do a musttail call with perfect argument forwarding.  Any inalloca argument
   // will be forwarded in place without any copy.
   SmallVector<llvm::Value *, 8> Args;
   for (llvm::Argument &A : ThunkFn->args())
     Args.push_back(&A);

lib/Sema/SemaDeclAttr.cpp

case AttributeList::AT_ExtVectorType:
     handleExtVectorTypeAttr(S, scope, D, Attr);
     break;
   case AttributeList::AT_MinSize:
     handleSimpleAttribute<MinSizeAttr>(S, D, Attr);
     break;
   case AttributeList::AT_OptimizeNone:
     handleOptimizeNoneAttr(S, D, Attr);
     break;
+  case AttributeList::AT_Flatten:
+    handleSimpleAttribute<FlattenAttr>(S, D, Attr);
+    break;
   case AttributeList::AT_Format:
     handleFormatAttr(S, D, Attr);
     break;
   case AttributeList::AT_FormatArg:
     handleFormatArgAttr(S, D, Attr);
     break;
   case AttributeList::AT_CUDAGlobal:
     handleGlobalAttr(S, D, Attr);

test/CodeGen/flatten.c

+// RUN: %clang -target x86_64-linux-gnu -S %s -emit-llvm -o - | FileCheck %s
+
+void f(void) {}
+
+__attribute__((flatten))
+// CHECK: define void @g()
+void g(void) {
+  // CHECK-NOT: call {{.*}} @f
+  f();
+}