[GlobalISel][CallLowering] NFC: Unify flag-setting from CallBase + AttributeList

[paquette]

Summary

It's annoying to have to maintain multiple, nearly identical chains of if statements which all set the same attributes.

Add a helper function, addFlagsUsingAttrFn which performs the attribute setting.

Then, use wrappers for that function in lowerCall and setArgFlags.

(Note that the flag-setting code in setArgFlags was missing the returned attribute. There's no selection for this yet, so no test. It's an example of the kind of thing this lets us avoid, though.)

llvm/include/llvm/CodeGen/GlobalISel/CallLowering.h

template <class XXXTargetLowering>
     return static_cast<const XXXTargetLowering *>(TLI);
   }
 
   /// \returns Flags corresponding to the attributes on the \p ArgIdx-th
   /// parameter of \p Call.
   ISD::ArgFlagsTy getAttributesForArgIdx(const CallBase &Call,
                                          unsigned ArgIdx) const;
 
+  /// Adds flags to \p Flags based off of the attributes in \p Attrs.
+  /// \p OpIdx is the index in \p Attrs to add flags from.
+  void addArgFlagsFromAttributes(ISD::ArgFlagsTy &Flags,
+                                 const AttributeList &Attrs,
+                                 unsigned OpIdx) const;
+
   template <typename FuncInfoTy>
   void setArgFlags(ArgInfo &Arg, unsigned OpIdx, const DataLayout &DL,
                    const FuncInfoTy &FuncInfo) const;
 
   /// Generate instructions for packing \p SrcRegs into one big register
   /// corresponding to the aggregate type \p PackedTy.
   ///
   /// \param SrcRegs should contain one virtual register for each base type in

llvm/lib/CodeGen/GlobalISel/CallLowering.cpp

 #include "llvm/Target/TargetMachine.h"
 
 #define DEBUG_TYPE "call-lowering"
 
 using namespace llvm;
 
 void CallLowering::anchor() {}
 
-ISD::ArgFlagsTy CallLowering::getAttributesForArgIdx(const CallBase &Call,
-                                                     unsigned ArgIdx) const {
-  ISD::ArgFlagsTy Flags;
-  if (Call.paramHasAttr(ArgIdx, Attribute::SExt))
+/// Helper function which updates \p Flags when \p AttrFn returns true.
+static void
+addFlagsUsingAttrFn(ISD::ArgFlagsTy &Flags,
+                    const std::function<bool(Attribute::AttrKind)> &AttrFn) {
+  if (AttrFn(Attribute::SExt))
     Flags.setSExt();
-  if (Call.paramHasAttr(ArgIdx, Attribute::ZExt))
+  if (AttrFn(Attribute::ZExt))
     Flags.setZExt();
-  if (Call.paramHasAttr(ArgIdx, Attribute::InReg))
+  if (AttrFn(Attribute::InReg))
     Flags.setInReg();
-  if (Call.paramHasAttr(ArgIdx, Attribute::StructRet))
+  if (AttrFn(Attribute::StructRet))
     Flags.setSRet();
-  if (Call.paramHasAttr(ArgIdx, Attribute::Nest))
+  if (AttrFn(Attribute::Nest))
     Flags.setNest();
-  if (Call.paramHasAttr(ArgIdx, Attribute::ByVal))
+  if (AttrFn(Attribute::ByVal))
     Flags.setByVal();
-  if (Call.paramHasAttr(ArgIdx, Attribute::Preallocated))
+  if (AttrFn(Attribute::Preallocated))
     Flags.setPreallocated();
-  if (Call.paramHasAttr(ArgIdx, Attribute::InAlloca))
+  if (AttrFn(Attribute::InAlloca))
     Flags.setInAlloca();
-  if (Call.paramHasAttr(ArgIdx, Attribute::Returned))
+  if (AttrFn(Attribute::Returned))
     Flags.setReturned();
-  if (Call.paramHasAttr(ArgIdx, Attribute::SwiftSelf))
+  if (AttrFn(Attribute::SwiftSelf))
     Flags.setSwiftSelf();
-  if (Call.paramHasAttr(ArgIdx, Attribute::SwiftError))
+  if (AttrFn(Attribute::SwiftError))
     Flags.setSwiftError();
+}
+
+ISD::ArgFlagsTy CallLowering::getAttributesForArgIdx(const CallBase &Call,
+                                                     unsigned ArgIdx) const {
+  ISD::ArgFlagsTy Flags;
+  addFlagsUsingAttrFn(Flags, [&Call, &ArgIdx](Attribute::AttrKind Attr) {
+    return Call.paramHasAttr(ArgIdx, Attr);
+  });
   return Flags;
 }
 
+void CallLowering::addArgFlagsFromAttributes(ISD::ArgFlagsTy &Flags,
+                                             const AttributeList &Attrs,
+                                             unsigned OpIdx) const {
+  addFlagsUsingAttrFn(Flags, [&Attrs, &OpIdx](Attribute::AttrKind Attr) {
+    return Attrs.hasAttribute(OpIdx, Attr);
+  });
+}
+
 bool CallLowering::lowerCall(MachineIRBuilder &MIRBuilder, const CallBase &CB,
                              ArrayRef<Register> ResRegs,
                              ArrayRef<ArrayRef<Register>> ArgRegs,
                              Register SwiftErrorVReg,
                              std::function<unsigned()> GetCalleeReg) const {
   CallLoweringInfo Info;
   const DataLayout &DL = MIRBuilder.getDataLayout();
   MachineFunction &MF = MIRBuilder.getMF();

 }
 
 template <typename FuncInfoTy>
 void CallLowering::setArgFlags(CallLowering::ArgInfo &Arg, unsigned OpIdx,
                                const DataLayout &DL,
                                const FuncInfoTy &FuncInfo) const {
   auto &Flags = Arg.Flags[0];
   const AttributeList &Attrs = FuncInfo.getAttributes();
-  if (Attrs.hasAttribute(OpIdx, Attribute::ZExt))
-    Flags.setZExt();
-  if (Attrs.hasAttribute(OpIdx, Attribute::SExt))
-    Flags.setSExt();
-  if (Attrs.hasAttribute(OpIdx, Attribute::InReg))
-    Flags.setInReg();
-  if (Attrs.hasAttribute(OpIdx, Attribute::StructRet))
-    Flags.setSRet();
-  if (Attrs.hasAttribute(OpIdx, Attribute::SwiftSelf))
-    Flags.setSwiftSelf();
-  if (Attrs.hasAttribute(OpIdx, Attribute::SwiftError))
-    Flags.setSwiftError();
-  if (Attrs.hasAttribute(OpIdx, Attribute::ByVal))
-    Flags.setByVal();
-  if (Attrs.hasAttribute(OpIdx, Attribute::Preallocated))
-    Flags.setPreallocated();
-  if (Attrs.hasAttribute(OpIdx, Attribute::InAlloca))
-    Flags.setInAlloca();
+  addArgFlagsFromAttributes(Flags, Attrs, OpIdx);
 
   if (Flags.isByVal() || Flags.isInAlloca() || Flags.isPreallocated()) {
     Type *ElementTy = cast<PointerType>(Arg.Ty)->getElementType();
 
     auto Ty = Attrs.getAttribute(OpIdx, Attribute::ByVal).getValueAsType();
     Flags.setByValSize(DL.getTypeAllocSize(Ty ? Ty : ElementTy));
 
     // For ByVal, alignment should be passed from FE.  BE will guess if
     // this info is not there but there are cases it cannot get right.
     Align FrameAlign;
     if (auto ParamAlign = FuncInfo.getParamAlign(OpIdx - 2))
       FrameAlign = *ParamAlign;
     else
       FrameAlign = Align(getTLI()->getByValTypeAlignment(ElementTy, DL));
     Flags.setByValAlign(FrameAlign);
   }
-  if (Attrs.hasAttribute(OpIdx, Attribute::Nest))
-    Flags.setNest();
   Flags.setOrigAlign(DL.getABITypeAlign(Arg.Ty));
 }
 
 template void
 CallLowering::setArgFlags<Function>(CallLowering::ArgInfo &Arg, unsigned OpIdx,
                                     const DataLayout &DL,
                                     const Function &FuncInfo) const;