include/llvm/MC/MachineLocation.h

   1 //===-- llvm/MC/MachineLocation.h -------------------------------*- C++ -*-===//
   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 // The MachineLocation class is used to represent a simple location in a machine
  10 // frame.  Locations will be one of two forms; a register or an address formed
  11 // from a base address plus an offset.  Register indirection can be specified by
  12 // explicitly passing an offset to the constructor.
  13 //===----------------------------------------------------------------------===//
  14
  15
  16 #ifndef LLVM_MC_MACHINELOCATION_H
  17 #define LLVM_MC_MACHINELOCATION_H
  18
  19 #include "llvm/Support/Compiler.h"
  20 #include "llvm/Support/DataTypes.h"
  21
  22 namespace llvm {
  23   class MCSymbol;
  24
  25 class MachineLocation {
  26 private:
  27   bool IsRegister;                      // True if location is a register.
  28   unsigned Register;                    // gcc/gdb register number.
  29   int Offset;                           // Displacement if not register.
  30 public:
  31   enum : uint32_t {
  32     // The target register number for an abstract frame pointer. The value is
  33     // an arbitrary value that doesn't collide with any real target register.
  34     VirtualFP = ~0U
  35   };
  36   MachineLocation()
  37     : IsRegister(false), Register(0), Offset(0) {}
  38   /// Create a direct register location.
  39   explicit MachineLocation(unsigned R)
  40     : IsRegister(true), Register(R), Offset(0) {}
  41   /// Create a register-indirect location with an offset.
  42   MachineLocation(unsigned R, int O)
  43     : IsRegister(false), Register(R), Offset(O) {}
  44
  45   bool operator==(const MachineLocation &Other) const {
  46       return IsRegister == Other.IsRegister && Register == Other.Register &&
  47         Offset == Other.Offset;
  48   }
  49
  50   // Accessors.
  51   /// \return true iff this is a register-indirect location.
  52   bool isIndirect()      const { return !IsRegister; }
  53   bool isReg()           const { return IsRegister; }
  54   unsigned getReg()      const { return Register; }
  55   int getOffset()        const { return Offset; }
  56   void setIsRegister(bool Is)  { IsRegister = Is; }
  57   void setRegister(unsigned R) { Register = R; }
  58   void setOffset(int O)        { Offset = O; }
  59   /// Make this location a direct register location.
  60   void set(unsigned R) {
  61     IsRegister = true;
  62     Register = R;
  63     Offset = 0;
  64   }
  65   /// Make this location a register-indirect+offset location.
  66   void set(unsigned R, int O) {
  67     IsRegister = false;
  68     Register = R;
  69     Offset = O;
  70   }
  71
  72 #ifndef NDEBUG
  73   void dump();
  74 #endif
  75 };
  76
  77 inline bool operator!=(const MachineLocation &LHS, const MachineLocation &RHS) {
  78   return !(LHS == RHS);
  79 }
  80
  81 } // End llvm namespace
  82
  83 #endif