< prev index next >
src/hotspot/cpu/aarch64/immediate_aarch64.cpp
Print this page
8248238: Adding Windows support to OpenJDK on AArch64
Summary: LP64 vs LLP64 changes to add Windows support
Contributed-by: Monica Beckwith <monica.beckwith@microsoft.com>, Ludovic Henry <luhenry@microsoft.com>
Reviewed-by:
8248238: Adding Windows support to OpenJDK on AArch64
Summary: Adding Windows support for AArch64
Contributed-by: Ludovic Henry <luhenry@microsoft.com>, Monica Beckwith <monica.beckwith@microsoft.com>
Reviewed-by:
@@ -20,11 +20,12 @@
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/
-#include <stdlib.h>
+#include "precompiled.hpp"
+#include "utilities/globalDefinitions.hpp"
#include "immediate_aarch64.hpp"
// there are at most 2^13 possible logical immediate encodings
// however, some combinations of immr and imms are invalid
static const unsigned LI_TABLE_SIZE = (1 << 13);
@@ -32,18 +33,18 @@
static int li_table_entry_count;
// for forward lookup we just use a direct array lookup
// and assume that the cient has supplied a valid encoding
// table[encoding] = immediate
-static u_int64_t LITable[LI_TABLE_SIZE];
+static uint64_t LITable[LI_TABLE_SIZE];
// for reverse lookup we need a sparse map so we store a table of
// immediate and encoding pairs sorted by immediate value
struct li_pair {
- u_int64_t immediate;
- u_int32_t encoding;
+ uint64_t immediate;
+ uint32_t encoding;
};
static struct li_pair InverseLITable[LI_TABLE_SIZE];
// comparator to sort entries in the inverse table
@@ -61,75 +62,75 @@
}
// helper functions used by expandLogicalImmediate
// for i = 1, ... N result<i-1> = 1 other bits are zero
-static inline u_int64_t ones(int N)
+static inline uint64_t ones(int N)
{
- return (N == 64 ? (u_int64_t)-1UL : ((1UL << N) - 1));
+ return (N == 64 ? (uint64_t)-1ULL : ((1ULL << N) - 1));
}
/*
* bit twiddling helpers for instruction decode
*/
// 32 bit mask with bits [hi,...,lo] set
-static inline u_int32_t mask32(int hi = 31, int lo = 0)
+static inline uint32_t mask32(int hi = 31, int lo = 0)
{
int nbits = (hi + 1) - lo;
return ((1 << nbits) - 1) << lo;
}
-static inline u_int64_t mask64(int hi = 63, int lo = 0)
+static inline uint64_t mask64(int hi = 63, int lo = 0)
{
int nbits = (hi + 1) - lo;
return ((1L << nbits) - 1) << lo;
}
// pick bits [hi,...,lo] from val
-static inline u_int32_t pick32(u_int32_t val, int hi = 31, int lo = 0)
+static inline uint32_t pick32(uint32_t val, int hi = 31, int lo = 0)
{
return (val & mask32(hi, lo));
}
// pick bits [hi,...,lo] from val
-static inline u_int64_t pick64(u_int64_t val, int hi = 31, int lo = 0)
+static inline uint64_t pick64(uint64_t val, int hi = 31, int lo = 0)
{
return (val & mask64(hi, lo));
}
// mask [hi,lo] and shift down to start at bit 0
-static inline u_int32_t pickbits32(u_int32_t val, int hi = 31, int lo = 0)
+static inline uint32_t pickbits32(uint32_t val, int hi = 31, int lo = 0)
{
return (pick32(val, hi, lo) >> lo);
}
// mask [hi,lo] and shift down to start at bit 0
-static inline u_int64_t pickbits64(u_int64_t val, int hi = 63, int lo = 0)
+static inline uint64_t pickbits64(uint64_t val, int hi = 63, int lo = 0)
{
return (pick64(val, hi, lo) >> lo);
}
// result<0> to val<N>
-static inline u_int64_t pickbit(u_int64_t val, int N)
+static inline uint64_t pickbit(uint64_t val, int N)
{
return pickbits64(val, N, N);
}
-static inline u_int32_t uimm(u_int32_t val, int hi, int lo)
+static inline uint32_t uimm(uint32_t val, int hi, int lo)
{
return pickbits32(val, hi, lo);
}
// SPEC bits(M*N) Replicate(bits(M) x, integer N);
// this is just an educated guess
-u_int64_t replicate(u_int64_t bits, int nbits, int count)
+uint64_t replicate(uint64_t bits, int nbits, int count)
{
- u_int64_t result = 0;
+ uint64_t result = 0;
// nbits may be 64 in which case we want mask to be -1
- u_int64_t mask = ones(nbits);
+ uint64_t mask = ones(nbits);
for (int i = 0; i < count ; i++) {
result <<= nbits;
result |= (bits & mask);
}
return result;
@@ -138,28 +139,28 @@
// this function writes the supplied bimm reference and returns a
// boolean to indicate success (1) or fail (0) because an illegal
// encoding must be treated as an UNALLOC instruction
// construct a 32 bit immediate value for a logical immediate operation
-int expandLogicalImmediate(u_int32_t immN, u_int32_t immr,
- u_int32_t imms, u_int64_t &bimm)
+int expandLogicalImmediate(uint32_t immN, uint32_t immr,
+ uint32_t imms, uint64_t &bimm)
{
int len; // ought to be <= 6
- u_int32_t levels; // 6 bits
- u_int32_t tmask_and; // 6 bits
- u_int32_t wmask_and; // 6 bits
- u_int32_t tmask_or; // 6 bits
- u_int32_t wmask_or; // 6 bits
- u_int64_t imm64; // 64 bits
- u_int64_t tmask, wmask; // 64 bits
- u_int32_t S, R, diff; // 6 bits?
+ uint32_t levels; // 6 bits
+ uint32_t tmask_and; // 6 bits
+ uint32_t wmask_and; // 6 bits
+ uint32_t tmask_or; // 6 bits
+ uint32_t wmask_or; // 6 bits
+ uint64_t imm64; // 64 bits
+ uint64_t tmask, wmask; // 64 bits
+ uint32_t S, R, diff; // 6 bits?
if (immN == 1) {
len = 6; // looks like 7 given the spec above but this cannot be!
} else {
len = 0;
- u_int32_t val = (~imms & 0x3f);
+ uint32_t val = (~imms & 0x3f);
for (int i = 5; i > 0; i--) {
if (val & (1 << i)) {
len = i;
break;
}
@@ -168,11 +169,11 @@
return 0;
}
// for valid inputs leading 1s in immr must be less than leading
// zeros in imms
int len2 = 0; // ought to be < len
- u_int32_t val2 = (~immr & 0x3f);
+ uint32_t val2 = (~immr & 0x3f);
for (int i = 5; i > 0; i--) {
if (!(val2 & (1 << i))) {
len2 = i;
break;
}
@@ -197,16 +198,16 @@
tmask_or = (diff & levels) & 0x3f;
tmask = 0xffffffffffffffffULL;
for (int i = 0; i < 6; i++) {
int nbits = 1 << i;
- u_int64_t and_bit = pickbit(tmask_and, i);
- u_int64_t or_bit = pickbit(tmask_or, i);
- u_int64_t and_bits_sub = replicate(and_bit, 1, nbits);
- u_int64_t or_bits_sub = replicate(or_bit, 1, nbits);
- u_int64_t and_bits_top = (and_bits_sub << nbits) | ones(nbits);
- u_int64_t or_bits_top = (0 << nbits) | or_bits_sub;
+ uint64_t and_bit = pickbit(tmask_and, i);
+ uint64_t or_bit = pickbit(tmask_or, i);
+ uint64_t and_bits_sub = replicate(and_bit, 1, nbits);
+ uint64_t or_bits_sub = replicate(or_bit, 1, nbits);
+ uint64_t and_bits_top = (and_bits_sub << nbits) | ones(nbits);
+ uint64_t or_bits_top = (0 << nbits) | or_bits_sub;
tmask = ((tmask
& (replicate(and_bits_top, 2 * nbits, 32 / nbits)))
| replicate(or_bits_top, 2 * nbits, 32 / nbits));
}
@@ -216,16 +217,16 @@
wmask = 0;
for (int i = 0; i < 6; i++) {
int nbits = 1 << i;
- u_int64_t and_bit = pickbit(wmask_and, i);
- u_int64_t or_bit = pickbit(wmask_or, i);
- u_int64_t and_bits_sub = replicate(and_bit, 1, nbits);
- u_int64_t or_bits_sub = replicate(or_bit, 1, nbits);
- u_int64_t and_bits_top = (ones(nbits) << nbits) | and_bits_sub;
- u_int64_t or_bits_top = (or_bits_sub << nbits) | 0;
+ uint64_t and_bit = pickbit(wmask_and, i);
+ uint64_t or_bit = pickbit(wmask_or, i);
+ uint64_t and_bits_sub = replicate(and_bit, 1, nbits);
+ uint64_t or_bits_sub = replicate(or_bit, 1, nbits);
+ uint64_t and_bits_top = (ones(nbits) << nbits) | and_bits_sub;
+ uint64_t or_bits_top = (or_bits_sub << nbits) | 0;
wmask = ((wmask
& (replicate(and_bits_top, 2 * nbits, 32 / nbits)))
| replicate(or_bits_top, 2 * nbits, 32 / nbits));
}
@@ -241,18 +242,23 @@
return 1;
}
// constructor to initialise the lookup tables
-static void initLITables() __attribute__ ((constructor));
+// Use a hack with MSVC as it doesn't support `__attribute__ ((constructor))`
+// See https://stackoverflow.com/questions/1113409/attribute-constructor-equivalent-in-vc
+static void initLITables() NOT_WIN64(__attribute__ ((constructor)));
+#ifdef _WIN64
+static struct initLITables_t { initLITables_t(void) { initLITables(); } } _initLITables;
+#endif
static void initLITables()
{
li_table_entry_count = 0;
for (unsigned index = 0; index < LI_TABLE_SIZE; index++) {
- u_int32_t N = uimm(index, 12, 12);
- u_int32_t immr = uimm(index, 11, 6);
- u_int32_t imms = uimm(index, 5, 0);
+ uint32_t N = uimm(index, 12, 12);
+ uint32_t immr = uimm(index, 11, 6);
+ uint32_t imms = uimm(index, 5, 0);
if (expandLogicalImmediate(N, immr, imms, LITable[index])) {
InverseLITable[li_table_entry_count].immediate = LITable[index];
InverseLITable[li_table_entry_count].encoding = index;
li_table_entry_count++;
}
@@ -262,16 +268,16 @@
sizeof(InverseLITable[0]), compare_immediate_pair);
}
// public APIs provided for logical immediate lookup and reverse lookup
-u_int64_t logical_immediate_for_encoding(u_int32_t encoding)
+uint64_t logical_immediate_for_encoding(uint32_t encoding)
{
return LITable[encoding];
}
-u_int32_t encoding_for_logical_immediate(u_int64_t immediate)
+uint32_t encoding_for_logical_immediate(uint64_t immediate)
{
struct li_pair pair;
struct li_pair *result;
pair.immediate = immediate;
@@ -291,19 +297,19 @@
// fpimm[7] = sign bit
// fpimm[6:4] = signed exponent
// fpimm[3:0] = fraction (assuming leading 1)
// i.e. F = s * 1.f * 2^(e - b)
-u_int64_t fp_immediate_for_encoding(u_int32_t imm8, int is_dp)
+uint64_t fp_immediate_for_encoding(uint32_t imm8, int is_dp)
{
union {
float fpval;
double dpval;
- u_int64_t val;
+ uint64_t val;
};
- u_int32_t s, e, f;
+ uint32_t s, e, f;
s = (imm8 >> 7 ) & 0x1;
e = (imm8 >> 4) & 0x7;
f = imm8 & 0xf;
// the fp value is s * n/16 * 2r where n is 16+e
fpval = (16.0 + f) / 16.0;
@@ -327,11 +333,11 @@
dpval = (double)fpval;
}
return val;
}
-u_int32_t encoding_for_fp_immediate(float immediate)
+uint32_t encoding_for_fp_immediate(float immediate)
{
// given a float which is of the form
//
// s * n/16 * 2r
//
@@ -339,14 +345,14 @@
// return the imm8 result [s:r:f]
//
union {
float fpval;
- u_int32_t val;
+ uint32_t val;
};
fpval = immediate;
- u_int32_t s, r, f, res;
+ uint32_t s, r, f, res;
// sign bit is 31
s = (val >> 31) & 0x1;
// exponent is bits 30-23 but we only want the bottom 3 bits
// strictly we ought to check that the bits bits 30-25 are
// either all 1s or all 0s
< prev index next >