[WinEH] Fix problem where CodeGenPrepare incorrectly sinks a bitcast into an EH pad.
[oota-llvm.git] / lib / CodeGen / SelectionDAG / StatepointLowering.cpp
1 //===-- StatepointLowering.cpp - SDAGBuilder's statepoint code -----------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file includes support code use by SelectionDAGBuilder when lowering a
11 // statepoint sequence in SelectionDAG IR.
12 //
13 //===----------------------------------------------------------------------===//
14
15 #include "StatepointLowering.h"
16 #include "SelectionDAGBuilder.h"
17 #include "llvm/ADT/SmallSet.h"
18 #include "llvm/ADT/Statistic.h"
19 #include "llvm/CodeGen/FunctionLoweringInfo.h"
20 #include "llvm/CodeGen/GCMetadata.h"
21 #include "llvm/CodeGen/GCStrategy.h"
22 #include "llvm/CodeGen/SelectionDAG.h"
23 #include "llvm/CodeGen/StackMaps.h"
24 #include "llvm/IR/CallingConv.h"
25 #include "llvm/IR/Instructions.h"
26 #include "llvm/IR/IntrinsicInst.h"
27 #include "llvm/IR/Intrinsics.h"
28 #include "llvm/IR/Statepoint.h"
29 #include "llvm/Target/TargetLowering.h"
30 #include <algorithm>
31 using namespace llvm;
32
33 #define DEBUG_TYPE "statepoint-lowering"
34
35 STATISTIC(NumSlotsAllocatedForStatepoints,
36           "Number of stack slots allocated for statepoints");
37 STATISTIC(NumOfStatepoints, "Number of statepoint nodes encountered");
38 STATISTIC(StatepointMaxSlotsRequired,
39           "Maximum number of stack slots required for a singe statepoint");
40
41 static void pushStackMapConstant(SmallVectorImpl<SDValue>& Ops,
42                                  SelectionDAGBuilder &Builder, uint64_t Value) {
43   SDLoc L = Builder.getCurSDLoc();
44   Ops.push_back(Builder.DAG.getTargetConstant(StackMaps::ConstantOp, L,
45                                               MVT::i64));
46   Ops.push_back(Builder.DAG.getTargetConstant(Value, L, MVT::i64));
47 }
48
49 void StatepointLoweringState::startNewStatepoint(SelectionDAGBuilder &Builder) {
50   // Consistency check
51   assert(PendingGCRelocateCalls.empty() &&
52          "Trying to visit statepoint before finished processing previous one");
53   Locations.clear();
54   NextSlotToAllocate = 0;
55   // Need to resize this on each safepoint - we need the two to stay in
56   // sync and the clear patterns of a SelectionDAGBuilder have no relation
57   // to FunctionLoweringInfo.
58   AllocatedStackSlots.resize(Builder.FuncInfo.StatepointStackSlots.size());
59   for (size_t i = 0; i < AllocatedStackSlots.size(); i++) {
60     AllocatedStackSlots[i] = false;
61   }
62 }
63
64 void StatepointLoweringState::clear() {
65   Locations.clear();
66   AllocatedStackSlots.clear();
67   assert(PendingGCRelocateCalls.empty() &&
68          "cleared before statepoint sequence completed");
69 }
70
71 SDValue
72 StatepointLoweringState::allocateStackSlot(EVT ValueType,
73                                            SelectionDAGBuilder &Builder) {
74
75   NumSlotsAllocatedForStatepoints++;
76
77   // The basic scheme here is to first look for a previously created stack slot
78   // which is not in use (accounting for the fact arbitrary slots may already
79   // be reserved), or to create a new stack slot and use it.
80
81   // If this doesn't succeed in 40000 iterations, something is seriously wrong
82   for (int i = 0; i < 40000; i++) {
83     assert(Builder.FuncInfo.StatepointStackSlots.size() ==
84                AllocatedStackSlots.size() &&
85            "broken invariant");
86     const size_t NumSlots = AllocatedStackSlots.size();
87     assert(NextSlotToAllocate <= NumSlots && "broken invariant");
88
89     if (NextSlotToAllocate >= NumSlots) {
90       assert(NextSlotToAllocate == NumSlots);
91       // record stats
92       if (NumSlots + 1 > StatepointMaxSlotsRequired) {
93         StatepointMaxSlotsRequired = NumSlots + 1;
94       }
95
96       SDValue SpillSlot = Builder.DAG.CreateStackTemporary(ValueType);
97       const unsigned FI = cast<FrameIndexSDNode>(SpillSlot)->getIndex();
98       Builder.FuncInfo.StatepointStackSlots.push_back(FI);
99       AllocatedStackSlots.push_back(true);
100       return SpillSlot;
101     }
102     if (!AllocatedStackSlots[NextSlotToAllocate]) {
103       const int FI = Builder.FuncInfo.StatepointStackSlots[NextSlotToAllocate];
104       AllocatedStackSlots[NextSlotToAllocate] = true;
105       return Builder.DAG.getFrameIndex(FI, ValueType);
106     }
107     // Note: We deliberately choose to advance this only on the failing path.
108     // Doing so on the succeeding path involves a bit of complexity that caused
109     // a minor bug previously.  Unless performance shows this matters, please
110     // keep this code as simple as possible.
111     NextSlotToAllocate++;
112   }
113   llvm_unreachable("infinite loop?");
114 }
115
116 /// Utility function for reservePreviousStackSlotForValue. Tries to find
117 /// stack slot index to which we have spilled value for previous statepoints.
118 /// LookUpDepth specifies maximum DFS depth this function is allowed to look.
119 static Optional<int> findPreviousSpillSlot(const Value *Val,
120                                            SelectionDAGBuilder &Builder,
121                                            int LookUpDepth) {
122   // Can not look any further - give up now
123   if (LookUpDepth <= 0)
124     return Optional<int>();
125
126   // Spill location is known for gc relocates
127   if (isGCRelocate(Val)) {
128     GCRelocateOperands RelocOps(cast<Instruction>(Val));
129
130     FunctionLoweringInfo::StatepointSpilledValueMapTy &SpillMap =
131         Builder.FuncInfo.StatepointRelocatedValues[RelocOps.getStatepoint()];
132
133     auto It = SpillMap.find(RelocOps.getDerivedPtr());
134     if (It == SpillMap.end())
135       return Optional<int>();
136
137     return It->second;
138   }
139
140   // Look through bitcast instructions.
141   if (const BitCastInst *Cast = dyn_cast<BitCastInst>(Val)) {
142     return findPreviousSpillSlot(Cast->getOperand(0), Builder, LookUpDepth - 1);
143   }
144
145   // Look through phi nodes
146   // All incoming values should have same known stack slot, otherwise result
147   // is unknown.
148   if (const PHINode *Phi = dyn_cast<PHINode>(Val)) {
149     Optional<int> MergedResult = None;
150
151     for (auto &IncomingValue : Phi->incoming_values()) {
152       Optional<int> SpillSlot =
153           findPreviousSpillSlot(IncomingValue, Builder, LookUpDepth - 1);
154       if (!SpillSlot.hasValue())
155         return Optional<int>();
156
157       if (MergedResult.hasValue() && *MergedResult != *SpillSlot)
158         return Optional<int>();
159
160       MergedResult = SpillSlot;
161     }
162     return MergedResult;
163   }
164
165   // TODO: We can do better for PHI nodes. In cases like this:
166   //   ptr = phi(relocated_pointer, not_relocated_pointer)
167   //   statepoint(ptr)
168   // We will return that stack slot for ptr is unknown. And later we might
169   // assign different stack slots for ptr and relocated_pointer. This limits
170   // llvm's ability to remove redundant stores.
171   // Unfortunately it's hard to accomplish in current infrastructure.
172   // We use this function to eliminate spill store completely, while
173   // in example we still need to emit store, but instead of any location
174   // we need to use special "preferred" location.
175
176   // TODO: handle simple updates.  If a value is modified and the original
177   // value is no longer live, it would be nice to put the modified value in the
178   // same slot.  This allows folding of the memory accesses for some
179   // instructions types (like an increment).
180   //   statepoint (i)
181   //   i1 = i+1
182   //   statepoint (i1)
183   // However we need to be careful for cases like this:
184   //   statepoint(i)
185   //   i1 = i+1
186   //   statepoint(i, i1)
187   // Here we want to reserve spill slot for 'i', but not for 'i+1'. If we just
188   // put handling of simple modifications in this function like it's done
189   // for bitcasts we might end up reserving i's slot for 'i+1' because order in
190   // which we visit values is unspecified.
191
192   // Don't know any information about this instruction
193   return Optional<int>();
194 }
195
196 /// Try to find existing copies of the incoming values in stack slots used for
197 /// statepoint spilling.  If we can find a spill slot for the incoming value,
198 /// mark that slot as allocated, and reuse the same slot for this safepoint.
199 /// This helps to avoid series of loads and stores that only serve to reshuffle
200 /// values on the stack between calls.
201 static void reservePreviousStackSlotForValue(const Value *IncomingValue,
202                                              SelectionDAGBuilder &Builder) {
203
204   SDValue Incoming = Builder.getValue(IncomingValue);
205
206   if (isa<ConstantSDNode>(Incoming) || isa<FrameIndexSDNode>(Incoming)) {
207     // We won't need to spill this, so no need to check for previously
208     // allocated stack slots
209     return;
210   }
211
212   SDValue OldLocation = Builder.StatepointLowering.getLocation(Incoming);
213   if (OldLocation.getNode())
214     // duplicates in input
215     return;
216
217   const int LookUpDepth = 6;
218   Optional<int> Index =
219       findPreviousSpillSlot(IncomingValue, Builder, LookUpDepth);
220   if (!Index.hasValue())
221     return;
222
223   auto Itr = std::find(Builder.FuncInfo.StatepointStackSlots.begin(),
224                        Builder.FuncInfo.StatepointStackSlots.end(), *Index);
225   assert(Itr != Builder.FuncInfo.StatepointStackSlots.end() &&
226          "value spilled to the unknown stack slot");
227
228   // This is one of our dedicated lowering slots
229   const int Offset =
230       std::distance(Builder.FuncInfo.StatepointStackSlots.begin(), Itr);
231   if (Builder.StatepointLowering.isStackSlotAllocated(Offset)) {
232     // stack slot already assigned to someone else, can't use it!
233     // TODO: currently we reserve space for gc arguments after doing
234     // normal allocation for deopt arguments.  We should reserve for
235     // _all_ deopt and gc arguments, then start allocating.  This
236     // will prevent some moves being inserted when vm state changes,
237     // but gc state doesn't between two calls.
238     return;
239   }
240   // Reserve this stack slot
241   Builder.StatepointLowering.reserveStackSlot(Offset);
242
243   // Cache this slot so we find it when going through the normal
244   // assignment loop.
245   SDValue Loc = Builder.DAG.getTargetFrameIndex(*Index, Incoming.getValueType());
246   Builder.StatepointLowering.setLocation(Incoming, Loc);
247 }
248
249 /// Remove any duplicate (as SDValues) from the derived pointer pairs.  This
250 /// is not required for correctness.  It's purpose is to reduce the size of
251 /// StackMap section.  It has no effect on the number of spill slots required
252 /// or the actual lowering.
253 static void removeDuplicatesGCPtrs(SmallVectorImpl<const Value *> &Bases,
254                                    SmallVectorImpl<const Value *> &Ptrs,
255                                    SmallVectorImpl<const Value *> &Relocs,
256                                    SelectionDAGBuilder &Builder) {
257
258   // This is horribly inefficient, but I don't care right now
259   SmallSet<SDValue, 64> Seen;
260
261   SmallVector<const Value *, 64> NewBases, NewPtrs, NewRelocs;
262   for (size_t i = 0; i < Ptrs.size(); i++) {
263     SDValue SD = Builder.getValue(Ptrs[i]);
264     // Only add non-duplicates
265     if (Seen.count(SD) == 0) {
266       NewBases.push_back(Bases[i]);
267       NewPtrs.push_back(Ptrs[i]);
268       NewRelocs.push_back(Relocs[i]);
269     }
270     Seen.insert(SD);
271   }
272   assert(Bases.size() >= NewBases.size());
273   assert(Ptrs.size() >= NewPtrs.size());
274   assert(Relocs.size() >= NewRelocs.size());
275   Bases = NewBases;
276   Ptrs = NewPtrs;
277   Relocs = NewRelocs;
278   assert(Ptrs.size() == Bases.size());
279   assert(Ptrs.size() == Relocs.size());
280 }
281
282 /// Extract call from statepoint, lower it and return pointer to the
283 /// call node. Also update NodeMap so that getValue(statepoint) will
284 /// reference lowered call result
285 static SDNode *
286 lowerCallFromStatepoint(ImmutableStatepoint ISP, const BasicBlock *EHPadBB,
287                         SelectionDAGBuilder &Builder,
288                         SmallVectorImpl<SDValue> &PendingExports) {
289
290   ImmutableCallSite CS(ISP.getCallSite());
291
292   SDValue ActualCallee;
293
294   if (ISP.getNumPatchBytes() > 0) {
295     // If we've been asked to emit a nop sequence instead of a call instruction
296     // for this statepoint then don't lower the call target, but use a constant
297     // `null` instead.  Not lowering the call target lets statepoint clients get
298     // away without providing a physical address for the symbolic call target at
299     // link time.
300
301     const auto &TLI = Builder.DAG.getTargetLoweringInfo();
302     const auto &DL = Builder.DAG.getDataLayout();
303
304     unsigned AS = ISP.getCalledValue()->getType()->getPointerAddressSpace();
305     ActualCallee = Builder.DAG.getConstant(0, Builder.getCurSDLoc(),
306                                            TLI.getPointerTy(DL, AS));
307   } else
308     ActualCallee = Builder.getValue(ISP.getCalledValue());
309
310   assert(CS.getCallingConv() != CallingConv::AnyReg &&
311          "anyregcc is not supported on statepoints!");
312
313   Type *DefTy = ISP.getActualReturnType();
314   bool HasDef = !DefTy->isVoidTy();
315
316   SDValue ReturnValue, CallEndVal;
317   std::tie(ReturnValue, CallEndVal) = Builder.lowerCallOperands(
318       ISP.getCallSite(), ImmutableStatepoint::CallArgsBeginPos,
319       ISP.getNumCallArgs(), ActualCallee, DefTy, EHPadBB,
320       false /* IsPatchPoint */);
321
322   SDNode *CallEnd = CallEndVal.getNode();
323
324   // Get a call instruction from the call sequence chain.  Tail calls are not
325   // allowed.  The following code is essentially reverse engineering X86's
326   // LowerCallTo.
327   //
328   // We are expecting DAG to have the following form:
329   //
330   // ch = eh_label (only in case of invoke statepoint)
331   //   ch, glue = callseq_start ch
332   //   ch, glue = X86::Call ch, glue
333   //   ch, glue = callseq_end ch, glue
334   //   get_return_value ch, glue
335   //
336   // get_return_value can either be a sequence of CopyFromReg instructions
337   // to grab the return value from the return register(s), or it can be a LOAD
338   // to load a value returned by reference via a stack slot.
339
340   if (HasDef) {
341     if (CallEnd->getOpcode() == ISD::LOAD)
342       CallEnd = CallEnd->getOperand(0).getNode();
343     else
344       while (CallEnd->getOpcode() == ISD::CopyFromReg)
345         CallEnd = CallEnd->getOperand(0).getNode();
346   }
347
348   assert(CallEnd->getOpcode() == ISD::CALLSEQ_END && "expected!");
349
350   // Export the result value if needed
351   const Instruction *GCResult = ISP.getGCResult();
352   if (HasDef && GCResult) {
353     if (GCResult->getParent() != CS.getParent()) {
354       // Result value will be used in a different basic block so we need to
355       // export it now.
356       // Default exporting mechanism will not work here because statepoint call
357       // has a different type than the actual call. It means that by default
358       // llvm will create export register of the wrong type (always i32 in our
359       // case). So instead we need to create export register with correct type
360       // manually.
361       // TODO: To eliminate this problem we can remove gc.result intrinsics
362       //       completely and make statepoint call to return a tuple.
363       unsigned Reg = Builder.FuncInfo.CreateRegs(ISP.getActualReturnType());
364       RegsForValue RFV(
365           *Builder.DAG.getContext(), Builder.DAG.getTargetLoweringInfo(),
366           Builder.DAG.getDataLayout(), Reg, ISP.getActualReturnType());
367       SDValue Chain = Builder.DAG.getEntryNode();
368
369       RFV.getCopyToRegs(ReturnValue, Builder.DAG, Builder.getCurSDLoc(), Chain,
370                         nullptr);
371       PendingExports.push_back(Chain);
372       Builder.FuncInfo.ValueMap[CS.getInstruction()] = Reg;
373     } else {
374       // Result value will be used in a same basic block. Don't export it or
375       // perform any explicit register copies.
376       // We'll replace the actuall call node shortly. gc_result will grab
377       // this value.
378       Builder.setValue(CS.getInstruction(), ReturnValue);
379     }
380   } else {
381     // The token value is never used from here on, just generate a poison value
382     Builder.setValue(CS.getInstruction(),
383                      Builder.DAG.getIntPtrConstant(-1, Builder.getCurSDLoc()));
384   }
385
386   return CallEnd->getOperand(0).getNode();
387 }
388
389 /// Callect all gc pointers coming into statepoint intrinsic, clean them up,
390 /// and return two arrays:
391 ///   Bases - base pointers incoming to this statepoint
392 ///   Ptrs - derived pointers incoming to this statepoint
393 ///   Relocs - the gc_relocate corresponding to each base/ptr pair
394 /// Elements of this arrays should be in one-to-one correspondence with each
395 /// other i.e Bases[i], Ptrs[i] are from the same gcrelocate call
396 static void getIncomingStatepointGCValues(
397     SmallVectorImpl<const Value *> &Bases, SmallVectorImpl<const Value *> &Ptrs,
398     SmallVectorImpl<const Value *> &Relocs, ImmutableStatepoint StatepointSite,
399     SelectionDAGBuilder &Builder) {
400   for (GCRelocateOperands relocateOpers : StatepointSite.getRelocates()) {
401     Relocs.push_back(relocateOpers.getUnderlyingCallSite().getInstruction());
402     Bases.push_back(relocateOpers.getBasePtr());
403     Ptrs.push_back(relocateOpers.getDerivedPtr());
404   }
405
406   // Remove any redundant llvm::Values which map to the same SDValue as another
407   // input.  Also has the effect of removing duplicates in the original
408   // llvm::Value input list as well.  This is a useful optimization for
409   // reducing the size of the StackMap section.  It has no other impact.
410   removeDuplicatesGCPtrs(Bases, Ptrs, Relocs, Builder);
411
412   assert(Bases.size() == Ptrs.size() && Ptrs.size() == Relocs.size());
413 }
414
415 /// Spill a value incoming to the statepoint. It might be either part of
416 /// vmstate
417 /// or gcstate. In both cases unconditionally spill it on the stack unless it
418 /// is a null constant. Return pair with first element being frame index
419 /// containing saved value and second element with outgoing chain from the
420 /// emitted store
421 static std::pair<SDValue, SDValue>
422 spillIncomingStatepointValue(SDValue Incoming, SDValue Chain,
423                              SelectionDAGBuilder &Builder) {
424   SDValue Loc = Builder.StatepointLowering.getLocation(Incoming);
425
426   // Emit new store if we didn't do it for this ptr before
427   if (!Loc.getNode()) {
428     Loc = Builder.StatepointLowering.allocateStackSlot(Incoming.getValueType(),
429                                                        Builder);
430     assert(isa<FrameIndexSDNode>(Loc));
431     int Index = cast<FrameIndexSDNode>(Loc)->getIndex();
432     // We use TargetFrameIndex so that isel will not select it into LEA
433     Loc = Builder.DAG.getTargetFrameIndex(Index, Incoming.getValueType());
434
435     // TODO: We can create TokenFactor node instead of
436     //       chaining stores one after another, this may allow
437     //       a bit more optimal scheduling for them
438     Chain = Builder.DAG.getStore(Chain, Builder.getCurSDLoc(), Incoming, Loc,
439                                  MachinePointerInfo::getFixedStack(
440                                      Builder.DAG.getMachineFunction(), Index),
441                                  false, false, 0);
442
443     Builder.StatepointLowering.setLocation(Incoming, Loc);
444   }
445
446   assert(Loc.getNode());
447   return std::make_pair(Loc, Chain);
448 }
449
450 /// Lower a single value incoming to a statepoint node.  This value can be
451 /// either a deopt value or a gc value, the handling is the same.  We special
452 /// case constants and allocas, then fall back to spilling if required.
453 static void lowerIncomingStatepointValue(SDValue Incoming,
454                                          SmallVectorImpl<SDValue> &Ops,
455                                          SelectionDAGBuilder &Builder) {
456   SDValue Chain = Builder.getRoot();
457
458   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Incoming)) {
459     // If the original value was a constant, make sure it gets recorded as
460     // such in the stackmap.  This is required so that the consumer can
461     // parse any internal format to the deopt state.  It also handles null
462     // pointers and other constant pointers in GC states
463     pushStackMapConstant(Ops, Builder, C->getSExtValue());
464   } else if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(Incoming)) {
465     // This handles allocas as arguments to the statepoint (this is only
466     // really meaningful for a deopt value.  For GC, we'd be trying to
467     // relocate the address of the alloca itself?)
468     Ops.push_back(Builder.DAG.getTargetFrameIndex(FI->getIndex(),
469                                                   Incoming.getValueType()));
470   } else {
471     // Otherwise, locate a spill slot and explicitly spill it so it
472     // can be found by the runtime later.  We currently do not support
473     // tracking values through callee saved registers to their eventual
474     // spill location.  This would be a useful optimization, but would
475     // need to be optional since it requires a lot of complexity on the
476     // runtime side which not all would support.
477     std::pair<SDValue, SDValue> Res =
478         spillIncomingStatepointValue(Incoming, Chain, Builder);
479     Ops.push_back(Res.first);
480     Chain = Res.second;
481   }
482
483   Builder.DAG.setRoot(Chain);
484 }
485
486 /// Lower deopt state and gc pointer arguments of the statepoint.  The actual
487 /// lowering is described in lowerIncomingStatepointValue.  This function is
488 /// responsible for lowering everything in the right position and playing some
489 /// tricks to avoid redundant stack manipulation where possible.  On
490 /// completion, 'Ops' will contain ready to use operands for machine code
491 /// statepoint. The chain nodes will have already been created and the DAG root
492 /// will be set to the last value spilled (if any were).
493 static void lowerStatepointMetaArgs(SmallVectorImpl<SDValue> &Ops,
494                                     ImmutableStatepoint StatepointSite,
495                                     SelectionDAGBuilder &Builder) {
496
497   // Lower the deopt and gc arguments for this statepoint.  Layout will
498   // be: deopt argument length, deopt arguments.., gc arguments...
499
500   SmallVector<const Value *, 64> Bases, Ptrs, Relocations;
501   getIncomingStatepointGCValues(Bases, Ptrs, Relocations, StatepointSite,
502                                 Builder);
503
504 #ifndef NDEBUG
505   // Check that each of the gc pointer and bases we've gotten out of the
506   // safepoint is something the strategy thinks might be a pointer into the GC
507   // heap.  This is basically just here to help catch errors during statepoint
508   // insertion. TODO: This should actually be in the Verifier, but we can't get
509   // to the GCStrategy from there (yet).
510   GCStrategy &S = Builder.GFI->getStrategy();
511   for (const Value *V : Bases) {
512     auto Opt = S.isGCManagedPointer(V);
513     if (Opt.hasValue()) {
514       assert(Opt.getValue() &&
515              "non gc managed base pointer found in statepoint");
516     }
517   }
518   for (const Value *V : Ptrs) {
519     auto Opt = S.isGCManagedPointer(V);
520     if (Opt.hasValue()) {
521       assert(Opt.getValue() &&
522              "non gc managed derived pointer found in statepoint");
523     }
524   }
525   for (const Value *V : Relocations) {
526     auto Opt = S.isGCManagedPointer(V);
527     if (Opt.hasValue()) {
528       assert(Opt.getValue() && "non gc managed pointer relocated");
529     }
530   }
531 #endif
532
533   // Before we actually start lowering (and allocating spill slots for values),
534   // reserve any stack slots which we judge to be profitable to reuse for a
535   // particular value.  This is purely an optimization over the code below and
536   // doesn't change semantics at all.  It is important for performance that we
537   // reserve slots for both deopt and gc values before lowering either.
538   for (const Value *V : StatepointSite.vm_state_args()) {
539     reservePreviousStackSlotForValue(V, Builder);
540   }
541   for (unsigned i = 0; i < Bases.size(); ++i) {
542     reservePreviousStackSlotForValue(Bases[i], Builder);
543     reservePreviousStackSlotForValue(Ptrs[i], Builder);
544   }
545
546   // First, prefix the list with the number of unique values to be
547   // lowered.  Note that this is the number of *Values* not the
548   // number of SDValues required to lower them.
549   const int NumVMSArgs = StatepointSite.getNumTotalVMSArgs();
550   pushStackMapConstant(Ops, Builder, NumVMSArgs);
551
552   assert(NumVMSArgs == std::distance(StatepointSite.vm_state_begin(),
553                                      StatepointSite.vm_state_end()));
554
555   // The vm state arguments are lowered in an opaque manner.  We do
556   // not know what type of values are contained within.  We skip the
557   // first one since that happens to be the total number we lowered
558   // explicitly just above.  We could have left it in the loop and
559   // not done it explicitly, but it's far easier to understand this
560   // way.
561   for (const Value *V : StatepointSite.vm_state_args()) {
562     SDValue Incoming = Builder.getValue(V);
563     lowerIncomingStatepointValue(Incoming, Ops, Builder);
564   }
565
566   // Finally, go ahead and lower all the gc arguments.  There's no prefixed
567   // length for this one.  After lowering, we'll have the base and pointer
568   // arrays interwoven with each (lowered) base pointer immediately followed by
569   // it's (lowered) derived pointer.  i.e
570   // (base[0], ptr[0], base[1], ptr[1], ...)
571   for (unsigned i = 0; i < Bases.size(); ++i) {
572     const Value *Base = Bases[i];
573     lowerIncomingStatepointValue(Builder.getValue(Base), Ops, Builder);
574
575     const Value *Ptr = Ptrs[i];
576     lowerIncomingStatepointValue(Builder.getValue(Ptr), Ops, Builder);
577   }
578
579   // If there are any explicit spill slots passed to the statepoint, record
580   // them, but otherwise do not do anything special.  These are user provided
581   // allocas and give control over placement to the consumer.  In this case,
582   // it is the contents of the slot which may get updated, not the pointer to
583   // the alloca
584   for (Value *V : StatepointSite.gc_args()) {
585     SDValue Incoming = Builder.getValue(V);
586     if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(Incoming)) {
587       // This handles allocas as arguments to the statepoint
588       Ops.push_back(Builder.DAG.getTargetFrameIndex(FI->getIndex(),
589                                                     Incoming.getValueType()));
590     }
591   }
592
593   // Record computed locations for all lowered values.
594   // This can not be embedded in lowering loops as we need to record *all*
595   // values, while previous loops account only values with unique SDValues.
596   const Instruction *StatepointInstr =
597     StatepointSite.getCallSite().getInstruction();
598   FunctionLoweringInfo::StatepointSpilledValueMapTy &SpillMap =
599     Builder.FuncInfo.StatepointRelocatedValues[StatepointInstr];
600
601   for (GCRelocateOperands RelocateOpers : StatepointSite.getRelocates()) {
602     const Value *V = RelocateOpers.getDerivedPtr();
603     SDValue SDV = Builder.getValue(V);
604     SDValue Loc = Builder.StatepointLowering.getLocation(SDV);
605
606     if (Loc.getNode()) {
607       SpillMap[V] = cast<FrameIndexSDNode>(Loc)->getIndex();
608     } else {
609       // Record value as visited, but not spilled. This is case for allocas
610       // and constants. For this values we can avoid emitting spill load while
611       // visiting corresponding gc_relocate.
612       // Actually we do not need to record them in this map at all.
613       // We do this only to check that we are not relocating any unvisited
614       // value.
615       SpillMap[V] = None;
616
617       // Default llvm mechanisms for exporting values which are used in
618       // different basic blocks does not work for gc relocates.
619       // Note that it would be incorrect to teach llvm that all relocates are
620       // uses of the corresponding values so that it would automatically
621       // export them. Relocates of the spilled values does not use original
622       // value.
623       if (RelocateOpers.getUnderlyingCallSite().getParent() !=
624           StatepointInstr->getParent())
625         Builder.ExportFromCurrentBlock(V);
626     }
627   }
628 }
629
630 void SelectionDAGBuilder::visitStatepoint(const CallInst &CI) {
631   // Check some preconditions for sanity
632   assert(isStatepoint(&CI) &&
633          "function called must be the statepoint function");
634
635   LowerStatepoint(ImmutableStatepoint(&CI));
636 }
637
638 void SelectionDAGBuilder::LowerStatepoint(
639     ImmutableStatepoint ISP, const BasicBlock *EHPadBB /*= nullptr*/) {
640   // The basic scheme here is that information about both the original call and
641   // the safepoint is encoded in the CallInst.  We create a temporary call and
642   // lower it, then reverse engineer the calling sequence.
643
644   NumOfStatepoints++;
645   // Clear state
646   StatepointLowering.startNewStatepoint(*this);
647
648   ImmutableCallSite CS(ISP.getCallSite());
649
650 #ifndef NDEBUG
651   // Consistency check. Check only relocates in the same basic block as thier
652   // statepoint.
653   for (const User *U : CS->users()) {
654     const CallInst *Call = cast<CallInst>(U);
655     if (isGCRelocate(Call) && Call->getParent() == CS.getParent())
656       StatepointLowering.scheduleRelocCall(*Call);
657   }
658 #endif
659
660 #ifndef NDEBUG
661   // If this is a malformed statepoint, report it early to simplify debugging.
662   // This should catch any IR level mistake that's made when constructing or
663   // transforming statepoints.
664   ISP.verify();
665
666   // Check that the associated GCStrategy expects to encounter statepoints.
667   assert(GFI->getStrategy().useStatepoints() &&
668          "GCStrategy does not expect to encounter statepoints");
669 #endif
670
671   // Lower statepoint vmstate and gcstate arguments
672   SmallVector<SDValue, 10> LoweredMetaArgs;
673   lowerStatepointMetaArgs(LoweredMetaArgs, ISP, *this);
674
675   // Get call node, we will replace it later with statepoint
676   SDNode *CallNode =
677       lowerCallFromStatepoint(ISP, EHPadBB, *this, PendingExports);
678
679   // Construct the actual GC_TRANSITION_START, STATEPOINT, and GC_TRANSITION_END
680   // nodes with all the appropriate arguments and return values.
681
682   // Call Node: Chain, Target, {Args}, RegMask, [Glue]
683   SDValue Chain = CallNode->getOperand(0);
684
685   SDValue Glue;
686   bool CallHasIncomingGlue = CallNode->getGluedNode();
687   if (CallHasIncomingGlue) {
688     // Glue is always last operand
689     Glue = CallNode->getOperand(CallNode->getNumOperands() - 1);
690   }
691
692   // Build the GC_TRANSITION_START node if necessary.
693   //
694   // The operands to the GC_TRANSITION_{START,END} nodes are laid out in the
695   // order in which they appear in the call to the statepoint intrinsic. If
696   // any of the operands is a pointer-typed, that operand is immediately
697   // followed by a SRCVALUE for the pointer that may be used during lowering
698   // (e.g. to form MachinePointerInfo values for loads/stores).
699   const bool IsGCTransition =
700       (ISP.getFlags() & (uint64_t)StatepointFlags::GCTransition) ==
701           (uint64_t)StatepointFlags::GCTransition;
702   if (IsGCTransition) {
703     SmallVector<SDValue, 8> TSOps;
704
705     // Add chain
706     TSOps.push_back(Chain);
707
708     // Add GC transition arguments
709     for (const Value *V : ISP.gc_transition_args()) {
710       TSOps.push_back(getValue(V));
711       if (V->getType()->isPointerTy())
712         TSOps.push_back(DAG.getSrcValue(V));
713     }
714
715     // Add glue if necessary
716     if (CallHasIncomingGlue)
717       TSOps.push_back(Glue);
718
719     SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
720
721     SDValue GCTransitionStart =
722         DAG.getNode(ISD::GC_TRANSITION_START, getCurSDLoc(), NodeTys, TSOps);
723
724     Chain = GCTransitionStart.getValue(0);
725     Glue = GCTransitionStart.getValue(1);
726   }
727
728   // TODO: Currently, all of these operands are being marked as read/write in
729   // PrologEpilougeInserter.cpp, we should special case the VMState arguments
730   // and flags to be read-only.
731   SmallVector<SDValue, 40> Ops;
732
733   // Add the <id> and <numBytes> constants.
734   Ops.push_back(DAG.getTargetConstant(ISP.getID(), getCurSDLoc(), MVT::i64));
735   Ops.push_back(
736       DAG.getTargetConstant(ISP.getNumPatchBytes(), getCurSDLoc(), MVT::i32));
737
738   // Calculate and push starting position of vmstate arguments
739   // Get number of arguments incoming directly into call node
740   unsigned NumCallRegArgs =
741       CallNode->getNumOperands() - (CallHasIncomingGlue ? 4 : 3);
742   Ops.push_back(DAG.getTargetConstant(NumCallRegArgs, getCurSDLoc(), MVT::i32));
743
744   // Add call target
745   SDValue CallTarget = SDValue(CallNode->getOperand(1).getNode(), 0);
746   Ops.push_back(CallTarget);
747
748   // Add call arguments
749   // Get position of register mask in the call
750   SDNode::op_iterator RegMaskIt;
751   if (CallHasIncomingGlue)
752     RegMaskIt = CallNode->op_end() - 2;
753   else
754     RegMaskIt = CallNode->op_end() - 1;
755   Ops.insert(Ops.end(), CallNode->op_begin() + 2, RegMaskIt);
756
757   // Add a constant argument for the calling convention
758   pushStackMapConstant(Ops, *this, CS.getCallingConv());
759
760   // Add a constant argument for the flags
761   uint64_t Flags = ISP.getFlags();
762   assert(
763       ((Flags & ~(uint64_t)StatepointFlags::MaskAll) == 0)
764           && "unknown flag used");
765   pushStackMapConstant(Ops, *this, Flags);
766
767   // Insert all vmstate and gcstate arguments
768   Ops.insert(Ops.end(), LoweredMetaArgs.begin(), LoweredMetaArgs.end());
769
770   // Add register mask from call node
771   Ops.push_back(*RegMaskIt);
772
773   // Add chain
774   Ops.push_back(Chain);
775
776   // Same for the glue, but we add it only if original call had it
777   if (Glue.getNode())
778     Ops.push_back(Glue);
779
780   // Compute return values.  Provide a glue output since we consume one as
781   // input.  This allows someone else to chain off us as needed.
782   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
783
784   SDNode *StatepointMCNode =
785       DAG.getMachineNode(TargetOpcode::STATEPOINT, getCurSDLoc(), NodeTys, Ops);
786
787   SDNode *SinkNode = StatepointMCNode;
788
789   // Build the GC_TRANSITION_END node if necessary.
790   //
791   // See the comment above regarding GC_TRANSITION_START for the layout of
792   // the operands to the GC_TRANSITION_END node.
793   if (IsGCTransition) {
794     SmallVector<SDValue, 8> TEOps;
795
796     // Add chain
797     TEOps.push_back(SDValue(StatepointMCNode, 0));
798
799     // Add GC transition arguments
800     for (const Value *V : ISP.gc_transition_args()) {
801       TEOps.push_back(getValue(V));
802       if (V->getType()->isPointerTy())
803         TEOps.push_back(DAG.getSrcValue(V));
804     }
805
806     // Add glue
807     TEOps.push_back(SDValue(StatepointMCNode, 1));
808
809     SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
810
811     SDValue GCTransitionStart =
812         DAG.getNode(ISD::GC_TRANSITION_END, getCurSDLoc(), NodeTys, TEOps);
813
814     SinkNode = GCTransitionStart.getNode();
815   }
816
817   // Replace original call
818   DAG.ReplaceAllUsesWith(CallNode, SinkNode); // This may update Root
819   // Remove original call node
820   DAG.DeleteNode(CallNode);
821
822   // DON'T set the root - under the assumption that it's already set past the
823   // inserted node we created.
824
825   // TODO: A better future implementation would be to emit a single variable
826   // argument, variable return value STATEPOINT node here and then hookup the
827   // return value of each gc.relocate to the respective output of the
828   // previously emitted STATEPOINT value.  Unfortunately, this doesn't appear
829   // to actually be possible today.
830 }
831
832 void SelectionDAGBuilder::visitGCResult(const CallInst &CI) {
833   // The result value of the gc_result is simply the result of the actual
834   // call.  We've already emitted this, so just grab the value.
835   Instruction *I = cast<Instruction>(CI.getArgOperand(0));
836   assert(isStatepoint(I) && "first argument must be a statepoint token");
837
838   if (I->getParent() != CI.getParent()) {
839     // Statepoint is in different basic block so we should have stored call
840     // result in a virtual register.
841     // We can not use default getValue() functionality to copy value from this
842     // register because statepoint and actuall call return types can be
843     // different, and getValue() will use CopyFromReg of the wrong type,
844     // which is always i32 in our case.
845     PointerType *CalleeType = cast<PointerType>(
846         ImmutableStatepoint(I).getCalledValue()->getType());
847     Type *RetTy =
848         cast<FunctionType>(CalleeType->getElementType())->getReturnType();
849     SDValue CopyFromReg = getCopyFromRegs(I, RetTy);
850
851     assert(CopyFromReg.getNode());
852     setValue(&CI, CopyFromReg);
853   } else {
854     setValue(&CI, getValue(I));
855   }
856 }
857
858 void SelectionDAGBuilder::visitGCRelocate(const CallInst &CI) {
859   GCRelocateOperands RelocateOpers(&CI);
860
861 #ifndef NDEBUG
862   // Consistency check
863   // We skip this check for relocates not in the same basic block as thier
864   // statepoint. It would be too expensive to preserve validation info through
865   // different basic blocks.
866   if (RelocateOpers.getStatepoint()->getParent() == CI.getParent()) {
867     StatepointLowering.relocCallVisited(CI);
868   }
869 #endif
870
871   const Value *DerivedPtr = RelocateOpers.getDerivedPtr();
872   SDValue SD = getValue(DerivedPtr);
873
874   FunctionLoweringInfo::StatepointSpilledValueMapTy &SpillMap =
875     FuncInfo.StatepointRelocatedValues[RelocateOpers.getStatepoint()];
876
877   // We should have recorded location for this pointer
878   assert(SpillMap.count(DerivedPtr) && "Relocating not lowered gc value");
879   Optional<int> DerivedPtrLocation = SpillMap[DerivedPtr];
880
881   // We didn't need to spill these special cases (constants and allocas).
882   // See the handling in spillIncomingValueForStatepoint for detail.
883   if (!DerivedPtrLocation) {
884     setValue(&CI, SD);
885     return;
886   }
887
888   SDValue SpillSlot = DAG.getTargetFrameIndex(*DerivedPtrLocation,
889                                               SD.getValueType());
890
891   // Be conservative: flush all pending loads
892   // TODO: Probably we can be less restrictive on this,
893   // it may allow more scheduling opportunities.
894   SDValue Chain = getRoot();
895
896   SDValue SpillLoad =
897       DAG.getLoad(SpillSlot.getValueType(), getCurSDLoc(), Chain, SpillSlot,
898                   MachinePointerInfo::getFixedStack(DAG.getMachineFunction(),
899                                                     *DerivedPtrLocation),
900                   false, false, false, 0);
901
902   // Again, be conservative, don't emit pending loads
903   DAG.setRoot(SpillLoad.getValue(1));
904
905   assert(SpillLoad.getNode());
906   setValue(&CI, SpillLoad);
907 }