[GlobalISel] Coding style and whitespace fixes

[qcolombet]

Hi Tom,

Thanks for doing this.

LGTM.

Cheers,
-Quentin

include/llvm/CodeGen/GlobalISel/CallLowering.h

protected:
   /// Getter for target specific TargetLowering class.
   template <class XXXTargetLowering>
     const XXXTargetLowering *getTLI() const {
     return static_cast<const XXXTargetLowering *>(TLI);
   }
  public:
   CallLowering(const TargetLowering *TLI) : TLI(TLI) {}
   virtual ~CallLowering() {}
-  
   /// This hook must be implemented to lower outgoing return values, described
   /// by \p Val, into the specified virtual register \p VReg.
   /// This hook is used by GlobalISel.
   ///
   /// \return True if the lowering succeeds, false otherwise.
-  virtual bool LowerReturn(MachineIRBuilder &MIRBuilder, const Value *Val,
+  virtual bool lowerReturn(MachineIRBuilder &MIRBuilder, const Value *Val,
                            unsigned VReg) const {
     return false;
   }
 
   /// This hook must be implemented to lower the incoming (formal)
   /// arguments, described by \p Args, for GlobalISel. Each argument
   /// must end up in the related virtual register described by VRegs.
   /// In other words, the first argument should end up in VRegs[0],
   /// the second in VRegs[1], and so on.
   /// \p MIRBuilder is set to the proper insertion for the argument
   /// lowering.
   ///
   /// \return True if the lowering succeeded, false otherwise.
   virtual bool
-  LowerFormalArguments(MachineIRBuilder &MIRBuilder,
+  lowerFormalArguments(MachineIRBuilder &MIRBuilder,
                        const Function::ArgumentListType &Args,
                        const SmallVectorImpl<unsigned> &VRegs) const {
     return false;
   }
 };
 } // End namespace llvm.
 
 #endif

lib/CodeGen/GlobalISel/IRTranslator.cpp

 }
 
 bool IRTranslator::translateReturn(const Instruction &Inst) {
   assert(isa<ReturnInst>(Inst) && "Return expected");
   const Value *Ret = cast<ReturnInst>(Inst).getReturnValue();
   // The target may mess up with the insertion point, but
   // this is not important as a return is the last instruction
   // of the block anyway.
-  return CLI->LowerReturn(MIRBuilder, Ret, !Ret ? 0 : getOrCreateVReg(*Ret));
+  return CLI->lowerReturn(MIRBuilder, Ret, !Ret ? 0 : getOrCreateVReg(*Ret));
 }
 
 bool IRTranslator::translateBr(const Instruction &Inst) {
   assert(isa<BranchInst>(Inst) && "Branch expected");
   const BranchInst &BrInst = *cast<BranchInst>(&Inst);
   if (BrInst.isUnconditional()) {
     const BasicBlock &BrTgt = *cast<BasicBlock>(BrInst.getOperand(0));
     MachineBasicBlock &TgtBB = getOrCreateBB(BrTgt);
bool IRTranslator::runOnMachineFunction(MachineFunction &MF) {
   MRI = &MF.getRegInfo();
   // Setup the arguments.
   MachineBasicBlock &MBB = getOrCreateBB(F.front());
   MIRBuilder.setMBB(MBB);
   SmallVector<unsigned, 8> VRegArgs;
   for (const Argument &Arg: F.args())
     VRegArgs.push_back(getOrCreateVReg(Arg));
   bool Succeeded =
-      CLI->LowerFormalArguments(MIRBuilder, F.getArgumentList(), VRegArgs);
+      CLI->lowerFormalArguments(MIRBuilder, F.getArgumentList(), VRegArgs);
   if (!Succeeded)
     report_fatal_error("Unable to lower arguments");
 
   for (const BasicBlock &BB: F) {
     MachineBasicBlock &MBB = getOrCreateBB(BB);
     // Set the insertion point of all the following translations to
     // the end of this basic block.
     MIRBuilder.setMBB(MBB);

lib/Target/AArch64/AArch64CallLowering.h

 #ifndef LLVM_LIB_TARGET_AARCH64_AARCH64CALLLOWERING
 #define LLVM_LIB_TARGET_AARCH64_AARCH64CALLLOWERING
 
 #include "llvm/CodeGen/GlobalISel/CallLowering.h"
 
 namespace llvm {
 
 class AArch64TargetLowering;
-  
 class AArch64CallLowering: public CallLowering {
  public:
   AArch64CallLowering(const AArch64TargetLowering &TLI);
-  
-  bool LowerReturn(MachineIRBuilder &MIRBuiler, const Value *Val,
+  bool lowerReturn(MachineIRBuilder &MIRBuiler, const Value *Val,
                    unsigned VReg) const override;
   bool
-  LowerFormalArguments(MachineIRBuilder &MIRBuilder,
+  lowerFormalArguments(MachineIRBuilder &MIRBuilder,
                        const Function::ArgumentListType &Args,
                        const SmallVectorImpl<unsigned> &VRegs) const override;
 };
 } // End of namespace llvm;
 #endif

lib/Target/AArch64/AArch64CallLowering.cpp

 #ifndef LLVM_BUILD_GLOBAL_ISEL
 #error "This shouldn't be built without GISel"
 #endif
 
 AArch64CallLowering::AArch64CallLowering(const AArch64TargetLowering &TLI)
   : CallLowering(&TLI) {
 }
 
-bool AArch64CallLowering::LowerReturn(MachineIRBuilder &MIRBuilder,
+bool AArch64CallLowering::lowerReturn(MachineIRBuilder &MIRBuilder,
                                         const Value *Val, unsigned VReg) const {
   MachineInstr *Return = MIRBuilder.buildInstr(AArch64::RET_ReallyLR);
   assert(Return && "Unable to build a return instruction?!");
 
   assert(((Val && VReg) || (!Val && !VReg)) && "Return value without a vreg");
   if (VReg) {
     assert(Val->getType()->isIntegerTy() && "Type not supported yet");
     unsigned Size = Val->getType()->getPrimitiveSizeInBits();
     assert((Size == 64 || Size == 32) && "Size not supported yet");
     unsigned ResReg = (Size == 32) ? AArch64::W0 : AArch64::X0;
     // Set the insertion point to be right before Return.
     MIRBuilder.setInstr(*Return, /* Before */ true);
     MachineInstr *Copy =
         MIRBuilder.buildInstr(TargetOpcode::COPY, ResReg, VReg);
     (void)Copy;
     assert(Copy->getNextNode() == Return &&
            "The insertion did not happen where we expected");
     MachineInstrBuilder(MIRBuilder.getMF(), Return)
         .addReg(ResReg, RegState::Implicit);
   }
   return true;
 }
 
-bool AArch64CallLowering::LowerFormalArguments(
+bool AArch64CallLowering::lowerFormalArguments(
     MachineIRBuilder &MIRBuilder, const Function::ArgumentListType &Args,
     const SmallVectorImpl<unsigned> &VRegs) const {
   MachineFunction &MF = MIRBuilder.getMF();
   const Function &F = *MF.getFunction();
 
   SmallVector<CCValAssign, 16> ArgLocs;
   CCState CCInfo(F.getCallingConv(), F.isVarArg(), MF, ArgLocs, F.getContext());