VirtRegMap.h revision 5f37502bfbadfa65de087627bd67fd58bb03725c 
1//===-- llvm/CodeGen/VirtRegMap.h - Virtual Register Map -*- C++ -*--------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file was developed by the LLVM research group and is distributed under
6// the University of Illinois Open Source License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements a virtual register map. This maps virtual
11// registers to physical registers and virtual registers to stack
12// slots. It is created and updated by a register allocator and then
13// used by a machine code rewriter that adds spill code and rewrites
14// virtual into physical register references.
15//
16//===----------------------------------------------------------------------===//
17
18#ifndef LLVM_CODEGEN_VIRTREGMAP_H
19#define LLVM_CODEGEN_VIRTREGMAP_H
20
21#include "llvm/CodeGen/MachineFunction.h"
22#include "llvm/CodeGen/SSARegMap.h"
23#include "Support/DenseMap.h"
24#include <climits>
25#include <map>
26
27namespace llvm {
28
29    class MachineInstr;
30
31    class VirtRegMap {
32    public:
33        typedef DenseMap<unsigned, VirtReg2IndexFunctor> Virt2PhysMap;
34        typedef DenseMap<int, VirtReg2IndexFunctor> Virt2StackSlotMap;
35        typedef std::multimap<MachineInstr*, unsigned> MI2VirtMap;
36
37    private:
38        MachineFunction* mf_;
39        Virt2PhysMap v2pMap_;
40        Virt2StackSlotMap v2ssMap_;
41        MI2VirtMap mi2vMap_;
42
43        // do not implement
44        VirtRegMap(const VirtRegMap& rhs);
45        const VirtRegMap& operator=(const VirtRegMap& rhs);
46
47        enum {
48            NO_PHYS_REG   = 0,
49            NO_STACK_SLOT = INT_MAX
50        };
51
52    public:
53        VirtRegMap(MachineFunction& mf)
54            : mf_(&mf),
55              v2pMap_(NO_PHYS_REG),
56              v2ssMap_(NO_STACK_SLOT) {
57            v2pMap_.grow(mf.getSSARegMap()->getLastVirtReg());
58            v2ssMap_.grow(mf.getSSARegMap()->getLastVirtReg());
59        }
60
61        bool hasPhys(unsigned virtReg) const {
62            return getPhys(virtReg) != NO_PHYS_REG;
63        }
64
65        unsigned getPhys(unsigned virtReg) const {
66            assert(MRegisterInfo::isVirtualRegister(virtReg));
67            return v2pMap_[virtReg];
68        }
69
70        void assignVirt2Phys(unsigned virtReg, unsigned physReg) {
71            assert(MRegisterInfo::isVirtualRegister(virtReg) &&
72                   MRegisterInfo::isPhysicalRegister(physReg));
73            assert(v2pMap_[virtReg] == NO_PHYS_REG &&
74                   "attempt to assign physical register to already mapped "
75                   "virtual register");
76            v2pMap_[virtReg] = physReg;
77        }
78
79        void clearVirt(unsigned virtReg) {
80            assert(MRegisterInfo::isVirtualRegister(virtReg));
81            assert(v2pMap_[virtReg] != NO_PHYS_REG &&
82                   "attempt to clear a not assigned virtual register");
83            v2pMap_[virtReg] = NO_PHYS_REG;
84        }
85
86        bool hasStackSlot(unsigned virtReg) const {
87            return getStackSlot(virtReg) != NO_STACK_SLOT;
88        }
89
90        int getStackSlot(unsigned virtReg) const {
91            assert(MRegisterInfo::isVirtualRegister(virtReg));
92            return v2ssMap_[virtReg];
93        }
94
95        int assignVirt2StackSlot(unsigned virtReg);
96
97        void virtFolded(unsigned virtReg,
98                        MachineInstr* oldMI,
99                        MachineInstr* newMI);
100
101        std::pair<MI2VirtMap::const_iterator, MI2VirtMap::const_iterator>
102        getFoldedVirts(MachineInstr* MI) const {
103            return mi2vMap_.equal_range(MI);
104        }
105
106        friend std::ostream& operator<<(std::ostream& os, const VirtRegMap& li);
107    };
108
109    std::ostream& operator<<(std::ostream& os, const VirtRegMap& li);
110
111    void eliminateVirtRegs(MachineFunction& mf, const VirtRegMap& vrm);
112
113} // End llvm namespace
114
115#endif
116