1 /*
   2  * Copyright (c) 2014, Red Hat Inc. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include <stdlib.h>
  26 #include "decode_aarch64.hpp"
  27 #include "immediate_aarch64.hpp"
  28 
  29 // there are at most 2^13 possible logical immediate encodings
  30 // however, some combinations of immr and imms are invalid
  31 static const unsigned  LI_TABLE_SIZE = (1 << 13);
  32 
  33 static int li_table_entry_count;
  34 
  35 // for forward lookup we just use a direct array lookup
  36 // and assume that the cient has supplied a valid encoding
  37 // table[encoding] = immediate
  38 static u_int64_t LITable[LI_TABLE_SIZE];
  39 
  40 // for reverse lookup we need a sparse map so we store a table of
  41 // immediate and encoding pairs sorted by immediate value
  42 
  43 struct li_pair {
  44   u_int64_t immediate;
  45   u_int32_t encoding;
  46 };
  47 
  48 static struct li_pair InverseLITable[LI_TABLE_SIZE];
  49 
  50 // comparator to sort entries in the inverse table
  51 int compare_immediate_pair(const void *i1, const void *i2)
  52 {
  53   struct li_pair *li1 = (struct li_pair *)i1;
  54   struct li_pair *li2 = (struct li_pair *)i2;
  55   if (li1->immediate < li2->immediate) {
  56     return -1;
  57   }
  58   if (li1->immediate > li2->immediate) {
  59     return 1;
  60   }
  61   return 0;
  62 }
  63 
  64 // helper functions used by expandLogicalImmediate
  65 
  66 // for i = 1, ... N result<i-1> = 1 other bits are zero
  67 static inline u_int64_t ones(int N)
  68 {
  69   return (N == 64 ? (u_int64_t)-1UL : ((1UL << N) - 1));
  70 }
  71 
  72 // result<0> to val<N>
  73 static inline u_int64_t pickbit(u_int64_t val, int N)
  74 {
  75   return pickbits64(val, N, N);
  76 }
  77 
  78 
  79 // SPEC bits(M*N) Replicate(bits(M) x, integer N);
  80 // this is just an educated guess
  81 
  82 u_int64_t replicate(u_int64_t bits, int nbits, int count)
  83 {
  84   u_int64_t result = 0;
  85   // nbits may be 64 in which case we want mask to be -1
  86   u_int64_t mask = ones(nbits);
  87   for (int i = 0; i < count ; i++) {
  88     result <<= nbits;
  89     result |= (bits & mask);
  90   }
  91   return result;
  92 }
  93 
  94 // this function writes the supplied bimm reference and returns a
  95 // boolean to indicate success (1) or fail (0) because an illegal
  96 // encoding must be treated as an UNALLOC instruction
  97 
  98 // construct a 32 bit immediate value for a logical immediate operation
  99 int expandLogicalImmediate(u_int32_t immN, u_int32_t immr,
 100                             u_int32_t imms, u_int64_t &bimm)
 101 {
 102   int len;                  // ought to be <= 6
 103   u_int32_t levels;         // 6 bits
 104   u_int32_t tmask_and;      // 6 bits
 105   u_int32_t wmask_and;      // 6 bits
 106   u_int32_t tmask_or;       // 6 bits
 107   u_int32_t wmask_or;       // 6 bits
 108   u_int64_t imm64;          // 64 bits
 109   u_int64_t tmask, wmask;   // 64 bits
 110   u_int32_t S, R, diff;     // 6 bits?
 111 
 112   if (immN == 1) {
 113     len = 6; // looks like 7 given the spec above but this cannot be!
 114   } else {
 115     len = 0;
 116     u_int32_t val = (~imms & 0x3f);
 117     for (int i = 5; i > 0; i--) {
 118       if (val & (1 << i)) {
 119         len = i;
 120         break;
 121       }
 122     }
 123     if (len < 1) {
 124       return 0;
 125     }
 126     // for valid inputs leading 1s in immr must be less than leading
 127     // zeros in imms
 128     int len2 = 0;                   // ought to be < len
 129     u_int32_t val2 = (~immr & 0x3f);
 130     for (int i = 5; i > 0; i--) {
 131       if (!(val2 & (1 << i))) {
 132         len2 = i;
 133         break;
 134       }
 135     }
 136     if (len2 >= len) {
 137       return 0;
 138     }
 139   }
 140 
 141   levels = (1 << len) - 1;
 142 
 143   if ((imms & levels) == levels) {
 144     return 0;
 145   }
 146 
 147   S = imms & levels;
 148   R = immr & levels;
 149 
 150  // 6 bit arithmetic!
 151   diff = S - R;
 152   tmask_and = (diff | ~levels) & 0x3f;
 153   tmask_or = (diff & levels) & 0x3f;
 154   tmask = 0xffffffffffffffffULL;
 155 
 156   for (int i = 0; i < 6; i++) {
 157     int nbits = 1 << i;
 158     u_int64_t and_bit = pickbit(tmask_and, i);
 159     u_int64_t or_bit = pickbit(tmask_or, i);
 160     u_int64_t and_bits_sub = replicate(and_bit, 1, nbits);
 161     u_int64_t or_bits_sub = replicate(or_bit, 1, nbits);
 162     u_int64_t and_bits_top = (and_bits_sub << nbits) | ones(nbits);
 163     u_int64_t or_bits_top = (0 << nbits) | or_bits_sub;
 164 
 165     tmask = ((tmask
 166               & (replicate(and_bits_top, 2 * nbits, 32 / nbits)))
 167              | replicate(or_bits_top, 2 * nbits, 32 / nbits));
 168   }
 169 
 170   wmask_and = (immr | ~levels) & 0x3f;
 171   wmask_or = (immr & levels) & 0x3f;
 172 
 173   wmask = 0;
 174 
 175   for (int i = 0; i < 6; i++) {
 176     int nbits = 1 << i;
 177     u_int64_t and_bit = pickbit(wmask_and, i);
 178     u_int64_t or_bit = pickbit(wmask_or, i);
 179     u_int64_t and_bits_sub = replicate(and_bit, 1, nbits);
 180     u_int64_t or_bits_sub = replicate(or_bit, 1, nbits);
 181     u_int64_t and_bits_top = (ones(nbits) << nbits) | and_bits_sub;
 182     u_int64_t or_bits_top = (or_bits_sub << nbits) | 0;
 183 
 184     wmask = ((wmask
 185               & (replicate(and_bits_top, 2 * nbits, 32 / nbits)))
 186              | replicate(or_bits_top, 2 * nbits, 32 / nbits));
 187   }
 188 
 189   if (diff & (1U << 6)) {
 190     imm64 = tmask & wmask;
 191   } else {
 192     imm64 = tmask | wmask;
 193   }
 194 
 195 
 196   bimm = imm64;
 197   return 1;
 198 }
 199 
 200 // constructor to initialise the lookup tables
 201 
 202 static void initLITables() __attribute__ ((constructor));
 203 static void initLITables()
 204 {
 205   li_table_entry_count = 0;
 206   for (unsigned index = 0; index < LI_TABLE_SIZE; index++) {
 207     u_int32_t N = uimm(index, 12, 12);
 208     u_int32_t immr = uimm(index, 11, 6);
 209     u_int32_t imms = uimm(index, 5, 0);
 210     if (expandLogicalImmediate(N, immr, imms, LITable[index])) {
 211       InverseLITable[li_table_entry_count].immediate = LITable[index];
 212       InverseLITable[li_table_entry_count].encoding = index;
 213       li_table_entry_count++;
 214     }
 215   }
 216   // now sort the inverse table
 217   qsort(InverseLITable, li_table_entry_count,
 218         sizeof(InverseLITable[0]), compare_immediate_pair);
 219 }
 220 
 221 // public APIs provided for logical immediate lookup and reverse lookup
 222 
 223 u_int64_t logical_immediate_for_encoding(u_int32_t encoding)
 224 {
 225   return LITable[encoding];
 226 }
 227 
 228 u_int32_t encoding_for_logical_immediate(u_int64_t immediate)
 229 {
 230   struct li_pair pair;
 231   struct li_pair *result;
 232 
 233   pair.immediate = immediate;
 234 
 235   result = (struct li_pair *)
 236     bsearch(&pair, InverseLITable, li_table_entry_count,
 237             sizeof(InverseLITable[0]), compare_immediate_pair);
 238 
 239   if (result) {
 240     return result->encoding;
 241   }
 242 
 243   return 0xffffffff;
 244 }
 245 
 246 // floating point immediates are encoded in 8 bits
 247 // fpimm[7] = sign bit
 248 // fpimm[6:4] = signed exponent
 249 // fpimm[3:0] = fraction (assuming leading 1)
 250 // i.e. F = s * 1.f * 2^(e - b)
 251 
 252 u_int64_t fp_immediate_for_encoding(u_int32_t imm8, int is_dp)
 253 {
 254   union {
 255     float fpval;
 256     double dpval;
 257     u_int64_t val;
 258   };
 259 
 260   u_int32_t s, e, f;
 261   s = (imm8 >> 7 ) & 0x1;
 262   e = (imm8 >> 4) & 0x7;
 263   f = imm8 & 0xf;
 264   // the fp value is s * n/16 * 2r where n is 16+e
 265   fpval = (16.0 + f) / 16.0;
 266   // n.b. exponent is signed
 267   if (e < 4) {
 268     int epos = e;
 269     for (int i = 0; i <= epos; i++) {
 270       fpval *= 2.0;
 271     }
 272   } else {
 273     int eneg = 7 - e;
 274     for (int i = 0; i < eneg; i++) {
 275       fpval /= 2.0;
 276     }
 277   }
 278 
 279   if (s) {
 280     fpval = -fpval;
 281   }
 282   if (is_dp) {
 283     dpval = (double)fpval;
 284   }
 285   return val;
 286 }
 287 
 288 u_int32_t encoding_for_fp_immediate(float immediate)
 289 {
 290   // given a float which is of the form
 291   //
 292   //     s * n/16 * 2r
 293   //
 294   // where n is 16+f and imm1:s, imm4:f, simm3:r
 295   // return the imm8 result [s:r:f]
 296   //
 297 
 298   union {
 299     float fpval;
 300     u_int32_t val;
 301   };
 302   fpval = immediate;
 303   u_int32_t s, r, f, res;
 304   // sign bit is 31
 305   s = (val >> 31) & 0x1;
 306   // exponent is bits 30-23 but we only want the bottom 3 bits
 307   // strictly we ought to check that the bits bits 30-25 are
 308   // either all 1s or all 0s
 309   r = (val >> 23) & 0x7;
 310   // fraction is bits 22-0
 311   f = (val >> 19) & 0xf;
 312   res = (s << 7) | (r << 4) | f;
 313   return res;
 314 }
 315