9 * The software must be used only for Non-Commercial Use which means any
10 * use which is NOT directed to receiving any direct monetary
11 * compensation for, or commercial advantage from such use. Illustrative
12 * examples of non-commercial use are academic research, personal study,
13 * teaching, education and corporate research & development.
14 * Illustrative examples of commercial use are distributing products for
15 * commercial advantage and providing services using the software for
16 * commercial advantage.
17 *
18 * If you wish to use this software or functionality therein that may be
19 * covered by patents for commercial use, please contact:
20 * Director of Intellectual Property Licensing
21 * Office of Strategy and Technology
22 * Hewlett-Packard Company
23 * 1501 Page Mill Road
24 * Palo Alto, California 94304
25 *
26 * Redistributions of source code must retain the above copyright notice,
27 * this list of conditions and the following disclaimer. Redistributions
28 * in binary form must reproduce the above copyright notice, this list of
29 * conditions and the following disclaimer in the documentation and/or
30 * other materials provided with the distribution. Neither the name of
31 * the COPYRIGHT HOLDER(s), HEWLETT-PACKARD COMPANY, nor the names of its
| 14 * Redistribution and use in source and binary forms, with or without
15 * modification, are permitted provided that the following conditions are
16 * met: redistributions of source code must retain the above copyright
17 * notice, this list of conditions and the following disclaimer;
18 * redistributions in binary form must reproduce the above copyright
19 * notice, this list of conditions and the following disclaimer in the
20 * documentation and/or other materials provided with the distribution;
21 * neither the name of the copyright holders nor the names of its
|
42 *
43 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
44 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
45 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
46 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
47 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
48 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
49 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
50 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
51 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
52 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
53 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
54 *
55 * Authors: Gabe Black
56 */
57
58#ifndef __ARCH_X86_INSTS_STATICINST_HH__
59#define __ARCH_X86_INSTS_STATICINST_HH__
60
61#include "base/trace.hh"
62#include "cpu/static_inst.hh"
63
64namespace X86ISA
65{
66 /**
67 * Class for register indices passed to instruction constructors. Using a
68 * wrapper struct for these lets take advantage of the compiler's type
69 * checking.
70 */
71 struct InstRegIndex
72 {
73 RegIndex idx;
74 explicit InstRegIndex(RegIndex _idx) : idx(_idx)
75 {}
76 };
77
78 /**
79 * Base class for all X86 static instructions.
80 */
81
82 class X86StaticInst : public StaticInst
83 {
84 protected:
85 // Constructor.
86 X86StaticInst(const char *mnem,
87 ExtMachInst _machInst, OpClass __opClass)
88 : StaticInst(mnem, _machInst, __opClass)
89 {
90 }
91
92 std::string generateDisassembly(Addr pc,
93 const SymbolTable *symtab) const;
94
95 void printMnemonic(std::ostream &os, const char * mnemonic) const;
96 void printMnemonic(std::ostream &os, const char * instMnemonic,
97 const char * mnemonic) const;
98
99 void printSegment(std::ostream &os, int segment) const;
100
101 void printReg(std::ostream &os, int reg, int size) const;
102 void printSrcReg(std::ostream &os, int reg, int size) const;
103 void printDestReg(std::ostream &os, int reg, int size) const;
104 void printMem(std::ostream &os, uint8_t segment,
105 uint8_t scale, RegIndex index, RegIndex base,
106 uint64_t disp, uint8_t addressSize, bool rip) const;
107
108 inline uint64_t merge(uint64_t into, uint64_t val, int size) const
109 {
110 X86IntReg reg = into;
111 if(_destRegIdx[0] & IntFoldBit)
112 {
113 reg.H = val;
114 return reg;
115 }
116 switch(size)
117 {
118 case 1:
119 reg.L = val;
120 break;
121 case 2:
122 reg.X = val;
123 break;
124 case 4:
125 //XXX Check if this should be zeroed or sign extended
126 reg = 0;
127 reg.E = val;
128 break;
129 case 8:
130 reg.R = val;
131 break;
132 default:
133 panic("Tried to merge with unrecognized size %d.\n", size);
134 }
135 return reg;
136 }
137
138 inline uint64_t pick(uint64_t from, int idx, int size) const
139 {
140 X86IntReg reg = from;
141 DPRINTF(X86, "Picking with size %d\n", size);
142 if(_srcRegIdx[idx] & IntFoldBit)
143 return reg.H;
144 switch(size)
145 {
146 case 1:
147 return reg.L;
148 case 2:
149 return reg.X;
150 case 4:
151 return reg.E;
152 case 8:
153 return reg.R;
154 default:
155 panic("Tried to pick with unrecognized size %d.\n", size);
156 }
157 }
158
159 inline int64_t signedPick(uint64_t from, int idx, int size) const
160 {
161 X86IntReg reg = from;
162 DPRINTF(X86, "Picking with size %d\n", size);
163 if(_srcRegIdx[idx] & IntFoldBit)
164 return reg.SH;
165 switch(size)
166 {
167 case 1:
168 return reg.SL;
169 case 2:
170 return reg.SX;
171 case 4:
172 return reg.SE;
173 case 8:
174 return reg.SR;
175 default:
176 panic("Tried to pick with unrecognized size %d.\n", size);
177 }
178 }
179 };
180}
181
182#endif //__ARCH_X86_INSTS_STATICINST_HH__
| 24 *
25 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
26 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
27 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
28 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
29 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
30 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
31 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
32 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
33 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
35 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 *
37 * Authors: Gabe Black
38 */
39
40#ifndef __ARCH_X86_INSTS_STATICINST_HH__
41#define __ARCH_X86_INSTS_STATICINST_HH__
42
43#include "base/trace.hh"
44#include "cpu/static_inst.hh"
45
46namespace X86ISA
47{
48 /**
49 * Class for register indices passed to instruction constructors. Using a
50 * wrapper struct for these lets take advantage of the compiler's type
51 * checking.
52 */
53 struct InstRegIndex
54 {
55 RegIndex idx;
56 explicit InstRegIndex(RegIndex _idx) : idx(_idx)
57 {}
58 };
59
60 /**
61 * Base class for all X86 static instructions.
62 */
63
64 class X86StaticInst : public StaticInst
65 {
66 protected:
67 // Constructor.
68 X86StaticInst(const char *mnem,
69 ExtMachInst _machInst, OpClass __opClass)
70 : StaticInst(mnem, _machInst, __opClass)
71 {
72 }
73
74 std::string generateDisassembly(Addr pc,
75 const SymbolTable *symtab) const;
76
77 void printMnemonic(std::ostream &os, const char * mnemonic) const;
78 void printMnemonic(std::ostream &os, const char * instMnemonic,
79 const char * mnemonic) const;
80
81 void printSegment(std::ostream &os, int segment) const;
82
83 void printReg(std::ostream &os, int reg, int size) const;
84 void printSrcReg(std::ostream &os, int reg, int size) const;
85 void printDestReg(std::ostream &os, int reg, int size) const;
86 void printMem(std::ostream &os, uint8_t segment,
87 uint8_t scale, RegIndex index, RegIndex base,
88 uint64_t disp, uint8_t addressSize, bool rip) const;
89
90 inline uint64_t merge(uint64_t into, uint64_t val, int size) const
91 {
92 X86IntReg reg = into;
93 if(_destRegIdx[0] & IntFoldBit)
94 {
95 reg.H = val;
96 return reg;
97 }
98 switch(size)
99 {
100 case 1:
101 reg.L = val;
102 break;
103 case 2:
104 reg.X = val;
105 break;
106 case 4:
107 //XXX Check if this should be zeroed or sign extended
108 reg = 0;
109 reg.E = val;
110 break;
111 case 8:
112 reg.R = val;
113 break;
114 default:
115 panic("Tried to merge with unrecognized size %d.\n", size);
116 }
117 return reg;
118 }
119
120 inline uint64_t pick(uint64_t from, int idx, int size) const
121 {
122 X86IntReg reg = from;
123 DPRINTF(X86, "Picking with size %d\n", size);
124 if(_srcRegIdx[idx] & IntFoldBit)
125 return reg.H;
126 switch(size)
127 {
128 case 1:
129 return reg.L;
130 case 2:
131 return reg.X;
132 case 4:
133 return reg.E;
134 case 8:
135 return reg.R;
136 default:
137 panic("Tried to pick with unrecognized size %d.\n", size);
138 }
139 }
140
141 inline int64_t signedPick(uint64_t from, int idx, int size) const
142 {
143 X86IntReg reg = from;
144 DPRINTF(X86, "Picking with size %d\n", size);
145 if(_srcRegIdx[idx] & IntFoldBit)
146 return reg.SH;
147 switch(size)
148 {
149 case 1:
150 return reg.SL;
151 case 2:
152 return reg.SX;
153 case 4:
154 return reg.SE;
155 case 8:
156 return reg.SR;
157 default:
158 panic("Tried to pick with unrecognized size %d.\n", size);
159 }
160 }
161 };
162}
163
164#endif //__ARCH_X86_INSTS_STATICINST_HH__
|