17 /// the location of a DebugVariable, and continues until that location is
33 /// needed when a DebugVariable has its location re-specified, to invalidate
39 /// the location can be determined, rather than only having DBG_VALUEs in blocks
57 /// thus a DebugVariable's location is the corresponding register), while
66 /// if a DBG_VALUE in the block specifies it; "False" if the location is
71 /// Intuitively, we start by assuming that every expression / variable location
79 /// Within LiveDebugValues: each variable location is represented by a
81 /// machine-locations that currently describe it (a single location for
83 /// specifies the location. Each VarLoc is indexed in the (function-scope) \p
96 /// for each live-in location at the start of blocks, while "Transfers" records
104 /// a block can have an "Unknown" location after being visited. Similarly, we
106 /// function: when a new location is discovered, all blocks previously explored
190 // exactly once at Location=0.
193 // "true" set (i.e. each VarLoc may appear only once), and the range Location=0
197 /// A type-checked pair of {Register Location (or 0), Index}, used to index
202 /// Why encode a location /into/ the VarLocMap index? This makes it possible
209   u32_location_t Location; // Physical registers live in the range [1;2^30) (see  member
214   /// The location that has an entry for every VarLoc in the map.
217   /// The first location that is reserved for VarLocs with locations of kind
221   /// The first location greater than 0 that is not reserved for VarLocs with
225   /// A special location reserved for VarLocs with locations of kind
229   /// A special location reserved for VarLocs of kind EntryValueBackupKind and
234   /// A special location reserved for VarLocs with locations of kind
242   LocIndex(u32_location_t Location, u32_index_t Index)  in LocIndex()
243       : Location(Location), Index(Index) {}  in LocIndex()
246     return (static_cast<uint64_t>(Location) << 32) | Index;  in getAsRawInteger()
263   /// \p Location in \p Set.
265                                     u32_location_t Location) {  in indexRangeForLocation()
266     uint64_t Start = LocIndex(Location, 0).getAsRawInteger();  in indexRangeForLocation()
267     uint64_t End = LocIndex(Location + 1, 0).getAsRawInteger();  in indexRangeForLocation()
272 // Simple Set for storing all the VarLoc Indices at a Location bucket.
274 // Vector of all `LocIndex`s for a given VarLoc; the same Location should not
276 // Location bucket.
296   /// A pair of debug variable and value location.
298     // The location at which a spilled variable resides. It consists of a
326     /// Identity of the variable at this location.
329     /// The expression applied to this location.
332     /// DBG_VALUE to clone var/expr information from if this location
351     /// The value location. Stored separately to avoid repeatedly
364     /// A single machine location; its Kind is either a register, spill
365     /// location, or immediate value.
416     /// Used to map the index of each location in Locs back to the index of its
417     /// original debug operand in MI. Used when multiple location operands are
473     /// Take the variable and machine-location in DBG_VALUE MI, and build an
474     /// entry location using the given expression.
486     /// Take the variable and machine-location from the DBG_VALUE (from the
487     /// function entry), and build an entry value backup location. The backup
488     /// location will turn into the normal location if the backup is valid at
489     /// the time of the primary location clobbering.
500     /// Take the variable and machine-location from the DBG_VALUE (from the
501     /// function entry), and build a copy of an entry value backup location by
502     /// setting the register location to NewReg.
515     /// Copy the register location in DBG_VALUE MI, updating the register to
530     /// locating it in the specified spill location.
564           // An entry value is a register location -- but with an updated  in BuildDbgValue()
565           // expression. The register location of such DBG_VALUE is always the  in BuildDbgValue()
577           // Use the original DBG_VALUEs expression to build the spilt location  in BuildDbgValue()
617     /// Check if the Loc field is an entry backup location.
705     /// Determine whether the lexical scope of this value's debug location
788     /// Map a VarLoc to an index within the vector reserved for its location
792     /// Map a location to a vector which holds VarLocs which live in that
793     /// location.
805       // unique location, while all SpillLocs use a single bucket, and any EV  in insert()
807       // compulsory entry at the universal location index). LocIndices will  in insert()
808       // always have an index at the universal location index as the last index.  in insert()
825       for (LocIndex::u32_location_t Location : Locations) {  in insert()  local
826         auto &Vars = Loc2Vars[Location];  in insert()
828             {Location, static_cast<LocIndex::u32_index_t>(Vars.size())});  in insert()
842       auto LocIt = Loc2Vars.find(ID.Location);  in operator []()
843       assert(LocIt != Loc2Vars.end() && "Location not tracked");  in operator []()
852     LocIndex LocationID;        ///< Location number for the transfer dest.
890   /// location or backup one. In the case the VarLoc is backup location
896     // Map the DebugVariable to recent primary location ID.
898     // Map the DebugVariable to recent backup location ID.
911     // location), but all VarLocs appear exactly once at the universal location
922     /// \c Location by removing them from the set.
924                LocIndex::u32_location_t Location);
982   /// VarLoc correspond to entries in the universal location bucket, which every
1003   /// Tests whether this instruction is a spill to a stack location.
1023   /// If a given instruction is identified as a spill, return the spill location
1029   /// address the spill location in a target independent way.
1113 /// fragments that may overlap it. If the VarLoc is a backup location, erase
1115 /// tracking its backup entry location. Otherwise, if the VarLoc is primary
1116 /// location, erase the variable from the Vars set.
1154                                           LocIndex::u32_location_t Location) {  in erase()  argument
1157     const VarLoc &VL = VarLocIDs[LocIndex(Location, ID)];  in erase()
1189 /// Return the Loc ID of an entry value backup location, if it exists for the
1223       // For now, the back index is always the universal location index.  in collectIDsForRegs()
1224       assert(LI.back().Location == LocIndex::kUniversalLocation &&  in collectIDsForRegs()
1248     uint32_t FoundReg = LocIndex::fromRawInteger(*It).Location;  in getUsedRegs()
1341   // If the parameter's location is not register location, we can not track  in removeEntryValue()
1435     // This must be an undefined location. If it has an open range, erase it.  in transferDebugValue()
1472     // The KillSet IDs are indices for the universal location bucket.  in emitEntryValues()
1501 /// new location will be register location created by the copy like instruction,
1502 /// otherwise it is variable's location on the stack.
1512     // Close this variable's previous location range.  in insertTransferDebugPair()
1515     // Record the new location as an open range, and a postponed transfer  in insertTransferDebugPair()
1516     // inserting a DBG_VALUE for this location.  in insertTransferDebugPair()
1530     // register location.  in insertTransferDebugPair()
1541     // location.  in insertTransferDebugPair()
1555     // DebugInstr refers to the pre-spill location, therefore we can reuse  in insertTransferDebugPair()
1738 /// a variable and create a new one for the spill location.
1756   // written to, then close the variable location. The value in memory  in transferSpillOrRestoreInst()
1766         // This location is overwritten by the current instruction -- terminate  in transferSpillOrRestoreInst()
1788   // variable location.  in transferSpillOrRestoreInst()
1802   // Check if the register or spill location is the location of a debug value.  in transferSpillOrRestoreInst()
1821         // The spill location is not the location of a debug value.  in transferSpillOrRestoreInst()
1866   // soon. It is more likely that previous register location, which is callee  in transferRegisterCopy()
2014 /// source variable in all the predecessors of @MBB reside in the same location.
2031     // potentially valid. If a location guessed to be correct here is  in join()
2110       // The ID location is live-in to MBB -- work out what kind of machine  in flushPendingLocs()
2111       // location it is and create a DBG_VALUE.  in flushPendingLocs()
2194   LLVM_DEBUG(dbgs() << "Creating the backup entry location: "; MI.dump(););  in recordEntryValue()
2196   // Create the entry value and use it as a backup location until it is  in recordEntryValue()
2369   // Add any DBG_VALUE instructions created by location transfers.  in ExtendRanges()
2380   // Add DBG_VALUEs created using Backup Entry Value location.  in ExtendRanges()