Run StatepointLowering.{cpp,h} through clang-format.

[pgavlin]

Summary

Just what is says on the tin.

[reames]

LGTM. In general, feel free to submit automated formatting changes for areas you're about to touch without review.

(If you haven't already requested submit access from Chris, do.)

lib/CodeGen/SelectionDAG/StatepointLowering.h

 
 /// This class tracks both per-statepoint and per-selectiondag information.
 /// For each statepoint it tracks locations of it's gc valuess (incoming and
 /// relocated) and list of gcreloc calls scheduled for visiting (this is
 /// used for a debug mode consistency check only).  The spill slot tracking
 /// works in concert with information in FunctionLoweringInfo.
 class StatepointLoweringState {
 public:
-  StatepointLoweringState() : NextSlotToAllocate(0) {
-  }
+  StatepointLoweringState() : NextSlotToAllocate(0) {}
 
   /// Reset all state tracking for a newly encountered safepoint.  Also
   /// performs some consistency checking.
   void startNewStatepoint(SelectionDAGBuilder &Builder);
 
   /// Clear the memory usage of this object.  This is called from
   /// SelectionDAGBuilder::clear.  We require this is never called in the
   /// midst of processing a statepoint sequence.

lib/CodeGen/SelectionDAG/StatepointLowering.cpp

 #define DEBUG_TYPE "statepoint-lowering"
 
 STATISTIC(NumSlotsAllocatedForStatepoints,
           "Number of stack slots allocated for statepoints");
 STATISTIC(NumOfStatepoints, "Number of statepoint nodes encountered");
 STATISTIC(StatepointMaxSlotsRequired,
           "Maximum number of stack slots required for a singe statepoint");
 
-void
-StatepointLoweringState::startNewStatepoint(SelectionDAGBuilder &Builder) {
+void StatepointLoweringState::startNewStatepoint(SelectionDAGBuilder &Builder) {
   // Consistency check
   assert(PendingGCRelocateCalls.empty() &&
          "Trying to visit statepoint before finished processing previous one");
   Locations.clear();
   RelocLocations.clear();
   NextSlotToAllocate = 0;
   // Need to resize this on each safepoint - we need the two to stay in
   // sync and the clear patterns of a SelectionDAGBuilder have no relation
if (CS.isInvoke()) {
       // than the actuall call. It means that standart exporting mechanism will
       // create register of the wrong type. So instead we need to create
       // register with correct type and save value into it manually.
       // TODO: To eliminate this problem we can remove gc.result intrinsics
       //       completelly and make statepoint call to return a tuple.
       unsigned reg = Builder.FuncInfo.CreateRegs(Tmp->getType());
       Builder.CopyValueToVirtualRegister(Tmp, reg);
       Builder.FuncInfo.ValueMap[CS.getInstruction()] = reg;
-    }
-    else {
+    } else {
       // The value of the statepoint itself will be the value of call itself.
       // We'll replace the actually call node shortly.  gc_result will grab
       // this value.
       Builder.setValue(CS.getInstruction(), Builder.getValue(Tmp));
     }
   } else {
     // The token value is never used from here on, just generate a poison value
     Builder.setValue(CS.getInstruction(), Builder.DAG.getIntPtrConstant(-1));
static SDNode *lowerCallFromStatepoint(ImmutableStatepoint StatepointSite,
   // We are expecting DAG to have the following form:
   // ch = eh_label (only in case of invoke statepoint)
   //   ch, glue = callseq_start ch
   //   ch, glue = X86::Call ch, glue
   //   ch, glue = callseq_end ch, glue
   // ch = eh_label ch (only in case of invoke statepoint)
   //
   // DAG root will be either last eh_label or callseq_end.
-    
   SDNode *CallNode = nullptr;
 
   // We just emitted a call, so it should be last thing generated
   SDValue Chain = Builder.DAG.getRoot();
 
   // Find closest CALLSEQ_END walking back through lowered nodes if needed
   SDNode *CallEnd = Chain.getNode();
   int Sanity = 0;

 
 /// Callect all gc pointers coming into statepoint intrinsic, clean them up,
 /// and return two arrays:
 ///   Bases - base pointers incoming to this statepoint
 ///   Ptrs - derived pointers incoming to this statepoint
 ///   Relocs - the gc_relocate corresponding to each base/ptr pair
 /// Elements of this arrays should be in one-to-one correspondence with each
 /// other i.e Bases[i], Ptrs[i] are from the same gcrelocate call
-static void
-getIncomingStatepointGCValues(SmallVectorImpl<const Value *> &Bases,
-                              SmallVectorImpl<const Value *> &Ptrs,
-                              SmallVectorImpl<const Value *> &Relocs,
-                              ImmutableStatepoint StatepointSite,
-                              SelectionDAGBuilder &Builder) {
+static void getIncomingStatepointGCValues(
+    SmallVectorImpl<const Value *> &Bases, SmallVectorImpl<const Value *> &Ptrs,
+    SmallVectorImpl<const Value *> &Relocs, ImmutableStatepoint StatepointSite,
   for (GCRelocateOperands relocateOpers :
-         StatepointSite.getRelocates(StatepointSite)) {
     Relocs.push_back(relocateOpers.getUnderlyingCallSite().getInstruction());
     Bases.push_back(relocateOpers.basePtr());
     Ptrs.push_back(relocateOpers.derivedPtr());
   }
 
   // Remove any redundant llvm::Values which map to the same SDValue as another
   // input.  Also has the effect of removing duplicates in the original
   // llvm::Value input list as well.  This is a useful optimization for
if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Incoming)) {
     // pointers and other constant pointers in GC states
     Ops.push_back(
         Builder.DAG.getTargetConstant(StackMaps::ConstantOp, MVT::i64));
     Ops.push_back(Builder.DAG.getTargetConstant(C->getSExtValue(), MVT::i64));
   } else if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(Incoming)) {
     // This handles allocas as arguments to the statepoint (this is only
     // really meaningful for a deopt value.  For GC, we'd be trying to
     // relocate the address of the alloca itself?)
-    Ops.push_back(Builder.DAG.getTargetFrameIndex(FI->getIndex(), 
+    Ops.push_back(Builder.DAG.getTargetFrameIndex(FI->getIndex(),
                                                   Incoming.getValueType()));
   } else {
     // Otherwise, locate a spill slot and explicitly spill it so it
     // can be found by the runtime later.  We currently do not support
     // tracking values through callee saved registers to their eventual
     // spill location.  This would be a useful optimization, but would
     // need to be optional since it requires a lot of complexity on the
     // runtime side which not all would support.

 static void lowerStatepointMetaArgs(SmallVectorImpl<SDValue> &Ops,
                                     ImmutableStatepoint StatepointSite,
                                     SelectionDAGBuilder &Builder) {
 
   // Lower the deopt and gc arguments for this statepoint.  Layout will
   // be: deopt argument length, deopt arguments.., gc arguments...
 
   SmallVector<const Value *, 64> Bases, Ptrs, Relocations;
-  getIncomingStatepointGCValues(Bases, Ptrs, Relocations,
-                                StatepointSite, Builder);
+  getIncomingStatepointGCValues(Bases, Ptrs, Relocations, StatepointSite,
+                                Builder);
 
 #ifndef NDEBUG
   // Check that each of the gc pointer and bases we've gotten out of the
   // safepoint is something the strategy thinks might be a pointer into the GC
   // heap.  This is basically just here to help catch errors during statepoint
   // insertion. TODO: This should actually be in the Verifier, but we can't get
   // to the GCStrategy from there (yet).
   GCStrategy &S = Builder.GFI->getStrategy();
#ifndef NDEBUG
   for (const Value *V : Relocations) {
     auto Opt = S.isGCManagedPointer(V);
     if (Opt.hasValue()) {
       assert(Opt.getValue() && "non gc managed pointer relocated");
     }
   }
 #endif
 
-
-
   // Before we actually start lowering (and allocating spill slots for values),
   // reserve any stack slots which we judge to be profitable to reuse for a
   // particular value.  This is purely an optimization over the code below and
   // doesn't change semantics at all.  It is important for performance that we
   // reserve slots for both deopt and gc values before lowering either.
   for (auto I = StatepointSite.vm_state_begin() + 1,
             E = StatepointSite.vm_state_end();
        I != E; ++I) {
     Value *V = *I;
     SDValue Incoming = Builder.getValue(V);
     reservePreviousStackSlotForValue(Incoming, Builder);
   }
   for (unsigned i = 0; i < Bases.size() * 2; ++i) {
     // Even elements will contain base, odd elements - derived ptr
     const Value *V = i % 2 ? Bases[i / 2] : Ptrs[i / 2];
     SDValue Incoming = Builder.getValue(V);
     reservePreviousStackSlotForValue(Incoming, Builder);
   }
 
   // First, prefix the list with the number of unique values to be
   // lowered.  Note that this is the number of *Values* not the
   // number of SDValues required to lower them.
   const int NumVMSArgs = StatepointSite.numTotalVMSArgs();
-  Ops.push_back(
-      Builder.DAG.getTargetConstant(StackMaps::ConstantOp, MVT::i64));
+  Ops.push_back(Builder.DAG.getTargetConstant(StackMaps::ConstantOp, MVT::i64));
   Ops.push_back(Builder.DAG.getTargetConstant(NumVMSArgs, MVT::i64));
 
   assert(NumVMSArgs + 1 == std::distance(StatepointSite.vm_state_begin(),
                                          StatepointSite.vm_state_end()));
 
   // The vm state arguments are lowered in an opaque manner.  We do
   // not know what type of values are contained within.  We skip the
   // first one since that happens to be the total number we lowered
#endif
   // (base[0], ptr[0], base[1], ptr[1], ...)
   for (unsigned i = 0; i < Bases.size() * 2; ++i) {
     // Even elements will contain base, odd elements - derived ptr
     const Value *V = i % 2 ? Bases[i / 2] : Ptrs[i / 2];
     SDValue Incoming = Builder.getValue(V);
     lowerIncomingStatepointValue(Incoming, Ops, Builder);
   }
 
-  // If there are any explicit spill slots passed to the statepoint, record 
+  // If there are any explicit spill slots passed to the statepoint, record
   // them, but otherwise do not do anything special.  These are user provided
-  // allocas and give control over placement to the consumer.  In this case, 
+  // allocas and give control over placement to the consumer.  In this case,
   // it is the contents of the slot which may get updated, not the pointer to
   // the alloca
   for (Value *V : StatepointSite.gc_args()) {
     SDValue Incoming = Builder.getValue(V);
     if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(Incoming)) {
       // This handles allocas as arguments to the statepoint
-      Ops.push_back(Builder.DAG.getTargetFrameIndex(FI->getIndex(), 
+      Ops.push_back(Builder.DAG.getTargetFrameIndex(FI->getIndex(),
                                                     Incoming.getValueType()));
-
     }
   }
 }
 
 void SelectionDAGBuilder::visitStatepoint(const CallInst &CI) {
   // Check some preconditions for sanity
   assert(isStatepoint(&CI) &&
          "function called must be the statepoint function");
 
   LowerStatepoint(ImmutableStatepoint(&CI));
 }
 
-void
-SelectionDAGBuilder::LowerStatepoint(ImmutableStatepoint ISP,
-                                     MachineBasicBlock *LandingPad/*=nullptr*/) {
+void SelectionDAGBuilder::LowerStatepoint(
+    ImmutableStatepoint ISP, MachineBasicBlock *LandingPad /*=nullptr*/) {
   // The basic scheme here is that information about both the original call and
   // the safepoint is encoded in the CallInst.  We create a temporary call and
   // lower it, then reverse engineer the calling sequence.
 
   NumOfStatepoints++;
   // Clear state
   StatepointLowering.startNewStatepoint(*this);
 
#endif
   // Same for the glue, but we add it only if original call had it
   if (Glue.getNode())
     Ops.push_back(Glue);
 
   // Compute return values.  Provide a glue output since we consume one as
   // input.  This allows someone else to chain off us as needed.
   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
 
-  SDNode *StatepointMCNode = DAG.getMachineNode(TargetOpcode::STATEPOINT,
-                                                getCurSDLoc(), NodeTys, Ops);
+  SDNode *StatepointMCNode =
+      DAG.getMachineNode(TargetOpcode::STATEPOINT, getCurSDLoc(), NodeTys, Ops);
 
   // Replace original call
   DAG.ReplaceAllUsesWith(CallNode, StatepointMCNode); // This may update Root
   // Remove originall call node
   DAG.DeleteNode(CallNode);
 
   // DON'T set the root - under the assumption that it's already set past the
   // inserted node we created.
 
   // TODO: A better future implementation would be to emit a single variable
   // argument, variable return value STATEPOINT node here and then hookup the
   // return value of each gc.relocate to the respective output of the
   // previously emitted STATEPOINT value.  Unfortunately, this doesn't appear
   // to actually be possible today.
 }
 
 void SelectionDAGBuilder::visitGCResult(const CallInst &CI) {
   // The result value of the gc_result is simply the result of the actual
   // call.  We've already emitted this, so just grab the value.
   Instruction *I = cast<Instruction>(CI.getArgOperand(0));
-  assert(isStatepoint(I) &&
-         "first argument must be a statepoint token");
+  assert(isStatepoint(I) && "first argument must be a statepoint token");
 
   if (isa<InvokeInst>(I)) {
     // For invokes we should have stored call result in a virtual register.
     // We can not use default getValue() functionality to copy value from this
     // register because statepoint and actuall call return types can be
     // different, and getValue() will use CopyFromReg of the wrong type,
     // which is always i32 in our case.
-    PointerType *CalleeType = cast<PointerType>(
-                                ImmutableStatepoint(I).actualCallee()->getType());
-    Type *RetTy = cast<FunctionType>(
-                                CalleeType->getElementType())->getReturnType();
+    PointerType *CalleeType =
+        cast<PointerType>(ImmutableStatepoint(I).actualCallee()->getType());
+    Type *RetTy =
+        cast<FunctionType>(CalleeType->getElementType())->getReturnType();
     SDValue CopyFromReg = getCopyFromRegs(I, RetTy);
 
     assert(CopyFromReg.getNode());
     setValue(&CI, CopyFromReg);
-  }
-  else {
+  } else {
     setValue(&CI, getValue(I));
   }
 }
 
 void SelectionDAGBuilder::visitGCRelocate(const CallInst &CI) {
 #ifndef NDEBUG
   // Consistency check
   StatepointLowering.relocCallVisited(CI);
if (!Loc.getNode()) {
     SDValue SpillSlot = StatepointLowering.getLocation(SD);
     int FI = cast<FrameIndexSDNode>(SpillSlot)->getIndex();
 
     // Be conservative: flush all pending loads
     // TODO: Probably we can be less restrictive on this,
     // it may allow more scheduling opprtunities
     SDValue Chain = getRoot();
 
-    Loc = DAG.getLoad(SpillSlot.getValueType(), getCurSDLoc(), Chain,
-                      SpillSlot, MachinePointerInfo::getFixedStack(FI), false,
-                      false, false, 0);
+    Loc = DAG.getLoad(SpillSlot.getValueType(), getCurSDLoc(), Chain, SpillSlot,
+                      MachinePointerInfo::getFixedStack(FI), false, false,
+                      false, 0);
 
     StatepointLowering.setRelocLocation(SD, Loc);
 
     // Again, be conservative, don't emit pending loads
     DAG.setRoot(Loc.getValue(1));
   }
 
   assert(Loc.getNode());
   setValue(&CI, Loc);
 }