70     "use-registers-for-gc-values-in-landing-pad", cl::Hidden, cl::init(false),
71     cl::desc("Allow using registers for gc pointer in landing pad"));
74     "max-registers-for-gc-values", cl::Hidden, cl::init(0),
75     cl::desc("Max number of VRegs allowed to pass GC pointer meta args in"));
168   // Spill location is known for gc relocates  in findPreviousSpillSlot()
299     // TODO: currently we reserve space for gc arguments after doing  in reservePreviousStackSlotForValue()
301     // _all_ deopt and gc arguments, then start allocating.  This  in reservePreviousStackSlotForValue()
303     // but gc state doesn't between two calls.  in reservePreviousStackSlotForValue()
422 /// either a deopt value or a gc value, the handling is the same.  We special
433       // really meaningful for a deopt value.  For GC, we'd be trying to  in lowerIncomingStatepointValue()
460     // pointers and other constant pointers in GC states.  in lowerIncomingStatepointValue()
501 /// Return true if value V represents the GC value. The behavior is conservative
502 /// in case it is not sure that value is not GC the function returns true.
513 /// Lower deopt state and gc pointer arguments of the statepoint.  The actual
527   // Lower the deopt and gc arguments for this statepoint.  Layout will be:  in lowerStatepointMetaArgs()
528   // deopt argument length, deopt arguments.., gc arguments...  in lowerStatepointMetaArgs()
560   LLVM_DEBUG(dbgs() << "Deciding how to lower GC Pointers:\n");  in lowerStatepointMetaArgs()
562   // List of unique lowered GC Pointer values.  in lowerStatepointMetaArgs()
564   // Map lowered GC Pointer value to the index in above vector  in lowerStatepointMetaArgs()
617   // reserve slots for both deopt and gc values before lowering either.  in lowerStatepointMetaArgs()
661   // Finally, go ahead and lower all the gc arguments.  in lowerStatepointMetaArgs()
693   // Now construct GC base/derived map;  in lowerStatepointMetaArgs()
719          "No gc specified, so cannot relocate pointers!");  in LowerAsSTATEPOINT()
733   // Lowered GC pointers (subset of above).  in LowerAsSTATEPOINT()
779     // Add GC transition arguments  in LowerAsSTATEPOINT()
859   assert(NodeTys.size() == LowerAsVReg.size() && "Inconsistent GC Ptr lowering");  in LowerAsSTATEPOINT()
869   // in other blocks. For local gc.relocate record appropriate statepoint  in LowerAsSTATEPOINT()
891     // Handle multiple gc.relocates of the same input efficiently.  in LowerAsSTATEPOINT()
907   // allow later gc.relocates to mirror the lowering chosen.  in LowerAsSTATEPOINT()
931       // additional use of the original value when lowering the gc.relocate.  in LowerAsSTATEPOINT()
954     // Add GC transition arguments  in LowerAsSTATEPOINT()
974   // Statepoint: [gc relocates],ch,glue = STATEPOINT ...  in LowerAsSTATEPOINT()
988   // return value of each gc.relocate to the respective output of the  in LowerAsSTATEPOINT()
995 /// Return two gc.results if present.  First result is a block local
996 /// gc.result, second result is a non-block local gc.result.  Corresponding
1050   // There may be duplication in the gc.relocate list; such as two copies of  in LowerStatepoint()
1053   // reload once per gc.relocate.  (Dedupping gc.relocates is trickier and best  in LowerStatepoint()
1075   // ensure it gets lowered such that gc cycles occurring before the  in LowerStatepoint()
1126   // TODO: To eliminate this problem we can remove gc.result intrinsics  in LowerStatepoint()
1165   // NB! The GC arguments are deliberately left empty.  in LowerCallSiteWithDeoptBundleImpl()
1227   assert(SlotIt != RelocationMap.end() && "Relocating not lowered gc value");  in visitGCRelocate()
1234            "Nonlocal gc.relocate mapped via SDValue");  in visitGCRelocate()