1// Copyright (c) 2007 The Hewlett-Packard Development Company
2// All rights reserved.
3//
4// The license below extends only to copyright in the software and shall
5// not be construed as granting a license to any other intellectual
6// property including but not limited to intellectual property relating
7// to a hardware implementation of the functionality of the software
8// licensed hereunder. You may use the software subject to the license
9// terms below provided that you ensure that this notice is replicated
10// unmodified and in its entirety in all distributions of the software,
11// modified or unmodified, in source code or in binary form.
12//
13// Redistribution and use in source and binary forms, with or without
14// modification, are permitted provided that the following conditions are
15// met: redistributions of source code must retain the above copyright
16// notice, this list of conditions and the following disclaimer;
17// redistributions in binary form must reproduce the above copyright
18// notice, this list of conditions and the following disclaimer in the
19// documentation and/or other materials provided with the distribution;
20// neither the name of the copyright holders nor the names of its
21// contributors may be used to endorse or promote products derived from
22// this software without specific prior written permission.
23//
24// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
27// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
28// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
30// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
34// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35//
36// Authors: Gabe Black
37
38//////////////////////////////////////////////////////////////////////////
39//
40// LIMMOp Microop templates
41//
42//////////////////////////////////////////////////////////////////////////
43
44def template MicroLimmOpExecute {{
45 Fault %(class_name)s::execute(%(CPU_exec_context)s *xc,
46 Trace::InstRecord *traceData) const
47 {
48 %(op_decl)s;
49 %(op_rd)s;
50 %(code)s;
51 %(op_wb)s;
52 return NoFault;
53 }
54}};
55
56def template MicroLimmOpDeclare {{
57 class %(class_name)s : public X86ISA::X86MicroopBase
58 {
59 protected:
60 const RegIndex dest;
61 const uint64_t imm;
62 const uint8_t dataSize;
63 RegIndex foldOBit;
| 1// Copyright (c) 2007 The Hewlett-Packard Development Company
2// All rights reserved.
3//
4// The license below extends only to copyright in the software and shall
5// not be construed as granting a license to any other intellectual
6// property including but not limited to intellectual property relating
7// to a hardware implementation of the functionality of the software
8// licensed hereunder. You may use the software subject to the license
9// terms below provided that you ensure that this notice is replicated
10// unmodified and in its entirety in all distributions of the software,
11// modified or unmodified, in source code or in binary form.
12//
13// Redistribution and use in source and binary forms, with or without
14// modification, are permitted provided that the following conditions are
15// met: redistributions of source code must retain the above copyright
16// notice, this list of conditions and the following disclaimer;
17// redistributions in binary form must reproduce the above copyright
18// notice, this list of conditions and the following disclaimer in the
19// documentation and/or other materials provided with the distribution;
20// neither the name of the copyright holders nor the names of its
21// contributors may be used to endorse or promote products derived from
22// this software without specific prior written permission.
23//
24// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
27// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
28// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
30// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
34// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35//
36// Authors: Gabe Black
37
38//////////////////////////////////////////////////////////////////////////
39//
40// LIMMOp Microop templates
41//
42//////////////////////////////////////////////////////////////////////////
43
44def template MicroLimmOpExecute {{
45 Fault %(class_name)s::execute(%(CPU_exec_context)s *xc,
46 Trace::InstRecord *traceData) const
47 {
48 %(op_decl)s;
49 %(op_rd)s;
50 %(code)s;
51 %(op_wb)s;
52 return NoFault;
53 }
54}};
55
56def template MicroLimmOpDeclare {{
57 class %(class_name)s : public X86ISA::X86MicroopBase
58 {
59 protected:
60 const RegIndex dest;
61 const uint64_t imm;
62 const uint8_t dataSize;
63 RegIndex foldOBit;
|
64 void buildMe();
| |
65
66 std::string generateDisassembly(Addr pc,
67 const SymbolTable *symtab) const;
68
69 public:
70 %(class_name)s(ExtMachInst _machInst,
71 const char * instMnem,
72 uint64_t setFlags, InstRegIndex _dest,
73 uint64_t _imm, uint8_t _dataSize);
74
| 64
65 std::string generateDisassembly(Addr pc,
66 const SymbolTable *symtab) const;
67
68 public:
69 %(class_name)s(ExtMachInst _machInst,
70 const char * instMnem,
71 uint64_t setFlags, InstRegIndex _dest,
72 uint64_t _imm, uint8_t _dataSize);
73
|
75 %(class_name)s(ExtMachInst _machInst,
76 const char * instMnem,
77 InstRegIndex _dest, uint64_t _imm, uint8_t _dataSize);
78
| |
79 %(BasicExecDeclare)s
80 };
81}};
82
83def template MicroLimmOpDisassembly {{
84 std::string %(class_name)s::generateDisassembly(Addr pc,
85 const SymbolTable *symtab) const
86 {
87 std::stringstream response;
88
89 printMnemonic(response, instMnem, mnemonic);
90 printDestReg(response, 0, dataSize);
91 response << ", ";
92 ccprintf(response, "%#x", imm);
93 return response.str();
94 }
95}};
96
97def template MicroLimmOpConstructor {{
| 74 %(BasicExecDeclare)s
75 };
76}};
77
78def template MicroLimmOpDisassembly {{
79 std::string %(class_name)s::generateDisassembly(Addr pc,
80 const SymbolTable *symtab) const
81 {
82 std::stringstream response;
83
84 printMnemonic(response, instMnem, mnemonic);
85 printDestReg(response, 0, dataSize);
86 response << ", ";
87 ccprintf(response, "%#x", imm);
88 return response.str();
89 }
90}};
91
92def template MicroLimmOpConstructor {{
|
98
99 inline void %(class_name)s::buildMe()
100 {
101 foldOBit = (dataSize == 1 && !machInst.rex.present) ? 1 << 6 : 0;
102 %(constructor)s;
103 }
104
| |
105 inline %(class_name)s::%(class_name)s(
| 93 inline %(class_name)s::%(class_name)s(
|
106 ExtMachInst machInst, const char * instMnem,
107 InstRegIndex _dest, uint64_t _imm, uint8_t _dataSize) :
108 %(base_class)s(machInst, "%(mnemonic)s", instMnem, 0, %(op_class)s),
109 dest(_dest.idx), imm(_imm), dataSize(_dataSize)
110 {
111 buildMe();
112 }
113
114 inline %(class_name)s::%(class_name)s(
| |
115 ExtMachInst machInst, const char * instMnem, uint64_t setFlags,
116 InstRegIndex _dest, uint64_t _imm, uint8_t _dataSize) :
117 %(base_class)s(machInst, "%(mnemonic)s", instMnem,
118 setFlags, %(op_class)s),
119 dest(_dest.idx), imm(_imm), dataSize(_dataSize)
120 {
| 94 ExtMachInst machInst, const char * instMnem, uint64_t setFlags,
95 InstRegIndex _dest, uint64_t _imm, uint8_t _dataSize) :
96 %(base_class)s(machInst, "%(mnemonic)s", instMnem,
97 setFlags, %(op_class)s),
98 dest(_dest.idx), imm(_imm), dataSize(_dataSize)
99 {
|
121 buildMe();
| 100 foldOBit = (dataSize == 1 && !machInst.rex.present) ? 1 << 6 : 0;
101 %(constructor)s;
|
122 }
123}};
124
125let {{
126 class LimmOp(X86Microop):
127 def __init__(self, dest, imm, dataSize="env.dataSize"):
128 self.className = "Limm"
129 self.mnemonic = "limm"
130 self.dest = dest
131 if isinstance(imm, (int, long)):
132 imm = "ULL(%d)" % imm
133 self.imm = imm
134 self.dataSize = dataSize
135
136 def getAllocator(self, microFlags):
137 allocator = '''new %(class_name)s(machInst, macrocodeBlock,
138 %(flags)s, %(dest)s, %(imm)s, %(dataSize)s)''' % {
139 "class_name" : self.className,
140 "mnemonic" : self.mnemonic,
141 "flags" : self.microFlagsText(microFlags),
142 "dest" : self.dest, "imm" : self.imm,
143 "dataSize" : self.dataSize}
144 return allocator
145
146 microopClasses["limm"] = LimmOp
147
148 class LfpimmOp(X86Microop):
149 def __init__(self, dest, imm, dataSize="env.dataSize"):
150 self.className = "Lfpimm"
151 self.mnemonic = "lfpimm"
152 self.dest = dest
153 if isinstance(imm, (int, long)):
154 imm = "ULL(%d)" % imm
155 if isinstance(imm, float):
156 imm = "reinterpret_cast<uint64_t>((double)(%d))"
157 self.imm = imm
158 self.dataSize = dataSize
159
160 def getAllocator(self, microFlags):
161 allocator = '''new %(class_name)s(machInst, macrocodeBlock,
162 %(flags)s, %(dest)s, %(imm)s, %(dataSize)s)''' % {
163 "class_name" : self.className,
164 "mnemonic" : self.mnemonic,
165 "flags" : self.microFlagsText(microFlags),
166 "dest" : self.dest, "imm" : self.imm,
167 "dataSize" : self.dataSize}
168 return allocator
169
170 microopClasses["lfpimm"] = LfpimmOp
171}};
172
173let {{
174 # Build up the all register version of this micro op
175 iop = InstObjParams("limm", "Limm", 'X86MicroopBase',
176 {"code" : "DestReg = merge(DestReg, imm, dataSize);"})
177 header_output += MicroLimmOpDeclare.subst(iop)
178 decoder_output += MicroLimmOpConstructor.subst(iop)
179 decoder_output += MicroLimmOpDisassembly.subst(iop)
180 exec_output += MicroLimmOpExecute.subst(iop)
181
182 iop = InstObjParams("lfpimm", "Lfpimm", 'X86MicroopBase',
183 {"code" : "FpDestReg.uqw = imm"})
184 header_output += MicroLimmOpDeclare.subst(iop)
185 decoder_output += MicroLimmOpConstructor.subst(iop)
186 decoder_output += MicroLimmOpDisassembly.subst(iop)
187 exec_output += MicroLimmOpExecute.subst(iop)
188}};
| 102 }
103}};
104
105let {{
106 class LimmOp(X86Microop):
107 def __init__(self, dest, imm, dataSize="env.dataSize"):
108 self.className = "Limm"
109 self.mnemonic = "limm"
110 self.dest = dest
111 if isinstance(imm, (int, long)):
112 imm = "ULL(%d)" % imm
113 self.imm = imm
114 self.dataSize = dataSize
115
116 def getAllocator(self, microFlags):
117 allocator = '''new %(class_name)s(machInst, macrocodeBlock,
118 %(flags)s, %(dest)s, %(imm)s, %(dataSize)s)''' % {
119 "class_name" : self.className,
120 "mnemonic" : self.mnemonic,
121 "flags" : self.microFlagsText(microFlags),
122 "dest" : self.dest, "imm" : self.imm,
123 "dataSize" : self.dataSize}
124 return allocator
125
126 microopClasses["limm"] = LimmOp
127
128 class LfpimmOp(X86Microop):
129 def __init__(self, dest, imm, dataSize="env.dataSize"):
130 self.className = "Lfpimm"
131 self.mnemonic = "lfpimm"
132 self.dest = dest
133 if isinstance(imm, (int, long)):
134 imm = "ULL(%d)" % imm
135 if isinstance(imm, float):
136 imm = "reinterpret_cast<uint64_t>((double)(%d))"
137 self.imm = imm
138 self.dataSize = dataSize
139
140 def getAllocator(self, microFlags):
141 allocator = '''new %(class_name)s(machInst, macrocodeBlock,
142 %(flags)s, %(dest)s, %(imm)s, %(dataSize)s)''' % {
143 "class_name" : self.className,
144 "mnemonic" : self.mnemonic,
145 "flags" : self.microFlagsText(microFlags),
146 "dest" : self.dest, "imm" : self.imm,
147 "dataSize" : self.dataSize}
148 return allocator
149
150 microopClasses["lfpimm"] = LfpimmOp
151}};
152
153let {{
154 # Build up the all register version of this micro op
155 iop = InstObjParams("limm", "Limm", 'X86MicroopBase',
156 {"code" : "DestReg = merge(DestReg, imm, dataSize);"})
157 header_output += MicroLimmOpDeclare.subst(iop)
158 decoder_output += MicroLimmOpConstructor.subst(iop)
159 decoder_output += MicroLimmOpDisassembly.subst(iop)
160 exec_output += MicroLimmOpExecute.subst(iop)
161
162 iop = InstObjParams("lfpimm", "Lfpimm", 'X86MicroopBase',
163 {"code" : "FpDestReg.uqw = imm"})
164 header_output += MicroLimmOpDeclare.subst(iop)
165 decoder_output += MicroLimmOpConstructor.subst(iop)
166 decoder_output += MicroLimmOpDisassembly.subst(iop)
167 exec_output += MicroLimmOpExecute.subst(iop)
168}};
|