2 * Copyright (c) 2009 The University of Edinburgh
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;
9 * redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution;
12 * neither the name of the copyright holders nor the names of its
13 * contributors may be used to endorse or promote products derived from
14 * this software without specific prior written permission.
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 #ifndef __ARCH_POWER_INSTS_INTEGER_HH__
30 #define __ARCH_POWER_INSTS_INTEGER_HH__
32 #include "arch/power/insts/static_inst.hh"
33 #include "base/bitfield.hh"
34 #include "base/cprintf.hh"
40 * We provide a base class for integer operations and then inherit for
41 * several other classes. These specialise for instructions using immediate
42 * values and also rotate instructions. We also need to have versions that
43 * consider the Rc and OE bits.
47 * Base class for integer operations.
49 class IntOp : public PowerStaticInst
56 // Needed for srawi only
60 IntOp(const char *mnem, MachInst _machInst, OpClass __opClass)
61 : PowerStaticInst(mnem, _machInst, __opClass),
62 rcSet(false), oeSet(false)
66 /* Compute the CR (condition register) field using signed comparison */
68 makeCRField(int64_t a, int64_t b, uint32_t xerSO) const
72 /* We've pre-shifted the immediate values here */
73 if (a < b) { c += 0x8; }
74 else if (a > b) { c += 0x4; }
80 makeCRField(int64_t a, int32_t b, uint32_t xerSO) const
82 return makeCRField(a, (int64_t)b, xerSO);
86 makeCRField(int32_t a, int32_t b, uint32_t xerSO) const
88 return makeCRField((int64_t)a, (int64_t)b, xerSO);
91 /* Compute the CR (condition register) field using unsigned comparison */
93 makeCRField(uint64_t a, uint64_t b, uint32_t xerSO) const
97 /* We've pre-shifted the immediate values here */
98 if (a < b) { c += 0x8; }
99 else if (a > b) { c += 0x4; }
105 makeCRField(uint64_t a, uint32_t b, uint32_t xerSO) const
107 return makeCRField(a, (uint64_t)b, xerSO);
111 makeCRField(uint32_t a, uint32_t b, uint32_t xerSO) const
113 return makeCRField((uint64_t)a, (uint64_t)b, xerSO);
116 std::string generateDisassembly(
117 Addr pc, const Loader::SymbolTable *symtab) const override;
122 * Class for integer immediate (signed and unsigned) operations.
124 class IntImmOp : public IntOp
132 IntImmOp(const char *mnem, MachInst _machInst, OpClass __opClass)
133 : IntOp(mnem, _machInst, __opClass),
134 imm(sext<16>(machInst.si)),
139 std::string generateDisassembly(
140 Addr pc, const Loader::SymbolTable *symtab) const override;
145 * Class for integer arithmetic operations.
147 class IntArithOp : public IntOp
152 IntArithOp(const char *mnem, MachInst _machInst, OpClass __opClass)
153 : IntOp(mnem, _machInst, __opClass)
158 * Compute 128-bit product of 64-bit unsigned integer multiplication
159 * based on https://stackoverflow.com/a/28904636
161 inline std::tuple<uint64_t, uint64_t>
162 multiply(uint64_t ra, uint64_t rb) const
165 #if defined(__SIZEOF_INT128__)
166 __uint128_t prod = (__uint128_t)ra * rb;
170 uint64_t ralo = (uint32_t)ra, rahi = ra >> 32;
171 uint64_t rblo = (uint32_t)rb, rbhi = rb >> 32;
172 uint64_t pp0 = ralo * rblo;
173 uint64_t pp1 = rahi * rblo;
174 uint64_t pp2 = ralo * rbhi;
175 uint64_t pp3 = rahi * rbhi;
176 uint64_t c = ((uint32_t)pp1) + ((uint32_t)pp2) + (pp0 >> 32);
177 phi = pp3 + (pp2 >> 32) + (pp1 >> 32) + (c >> 32);
178 plo = (c << 32) | ((uint32_t)pp0);
180 return std::make_tuple(plo, phi);
183 /* Compute 128-bit product of 64-bit signed integer multiplication */
184 inline std::tuple<uint64_t, int64_t>
185 multiply(int64_t ra, int64_t rb) const
188 #if defined(__SIZEOF_INT128__)
189 __int128_t prod = (__int128_t)ra * rb;
193 std::tie(plo, phi) = multiply((uint64_t)ra, (uint64_t)rb);
194 if (rb < 0) phi -= (uint64_t)ra;
195 if (ra < 0) phi -= (uint64_t)rb;
197 return std::make_tuple(plo, (int64_t)phi);
200 std::string generateDisassembly(
201 Addr pc, const Loader::SymbolTable *symtab) const override;
206 * Class for integer immediate arithmetic operations.
208 class IntImmArithOp : public IntArithOp
215 IntImmArithOp(const char *mnem, MachInst _machInst, OpClass __opClass)
216 : IntArithOp(mnem, _machInst, __opClass),
217 simm((int16_t)machInst.si)
221 std::string generateDisassembly(
222 Addr pc, const Loader::SymbolTable *symtab) const override;
227 * Class for integer arithmetic operations with displacement.
229 class IntDispArithOp : public IntArithOp
236 IntDispArithOp(const char *mnem, MachInst _machInst, OpClass __opClass)
237 : IntArithOp(mnem, _machInst, __opClass),
238 disp((int16_t)((machInst.d0 << 6) | (machInst.d1 << 1) | machInst.d2))
242 std::string generateDisassembly(
243 Addr pc, const Loader::SymbolTable *symtab) const override;
248 * Class for integer operations with a shift.
250 class IntShiftOp : public IntOp
257 IntShiftOp(const char *mnem, MachInst _machInst, OpClass __opClass)
258 : IntOp(mnem, _machInst, __opClass),
263 std::string generateDisassembly(
264 Addr pc, const Loader::SymbolTable *symtab) const override;
269 * Class for integer rotate operations.
271 class IntRotateOp : public IntShiftOp
280 IntRotateOp(const char *mnem, MachInst _machInst, OpClass __opClass)
281 : IntShiftOp(mnem, _machInst, __opClass),
286 fullMask = mask(31 - mb, 31 - me);
288 fullMask = ~mask(31 - (me + 1), 31 - (mb - 1));
293 rotateValue(uint32_t rs, uint32_t shift) const
295 uint32_t n = shift & 31;
296 return (rs << n) | (rs >> (32 - n));
299 std::string generateDisassembly(
300 Addr pc, const Loader::SymbolTable *symtab) const override;
303 } // namespace PowerISA
305 #endif //__ARCH_POWER_INSTS_INTEGER_HH__