< 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:
*** 20,30 ****
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/
! #include <stdlib.h>
#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);
--- 20,30 ----
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/
! #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,49 ****
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];
// 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;
};
static struct li_pair InverseLITable[LI_TABLE_SIZE];
// comparator to sort entries in the inverse table
--- 32,49 ----
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 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 {
! uint64_t immediate;
! uint32_t encoding;
};
static struct li_pair InverseLITable[LI_TABLE_SIZE];
// comparator to sort entries in the inverse table
*** 61,135 ****
}
// 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)
{
! return (N == 64 ? (u_int64_t)-1UL : ((1UL << 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)
{
int nbits = (hi + 1) - lo;
return ((1 << nbits) - 1) << lo;
}
! static inline u_int64_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)
{
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)
{
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)
{
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)
{
return (pick64(val, hi, lo) >> lo);
}
// result<0> to val<N>
! static inline u_int64_t pickbit(u_int64_t val, int N)
{
return pickbits64(val, N, N);
}
! static inline u_int32_t uimm(u_int32_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)
{
! u_int64_t result = 0;
// nbits may be 64 in which case we want mask to be -1
! u_int64_t mask = ones(nbits);
for (int i = 0; i < count ; i++) {
result <<= nbits;
result |= (bits & mask);
}
return result;
--- 61,135 ----
}
// helper functions used by expandLogicalImmediate
// for i = 1, ... N result<i-1> = 1 other bits are zero
! static inline uint64_t ones(int N)
{
! 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 uint32_t mask32(int hi = 31, int lo = 0)
{
int nbits = (hi + 1) - lo;
return ((1 << nbits) - 1) << lo;
}
! 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 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 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 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 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 uint64_t pickbit(uint64_t val, int N)
{
return pickbits64(val, N, N);
}
! 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
! uint64_t replicate(uint64_t bits, int nbits, int count)
{
! uint64_t result = 0;
// nbits may be 64 in which case we want mask to be -1
! uint64_t mask = ones(nbits);
for (int i = 0; i < count ; i++) {
result <<= nbits;
result |= (bits & mask);
}
return result;
*** 138,165 ****
// 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 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?
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);
for (int i = 5; i > 0; i--) {
if (val & (1 << i)) {
len = i;
break;
}
--- 138,165 ----
// 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(uint32_t immN, uint32_t immr,
! uint32_t imms, uint64_t &bimm)
{
int len; // ought to be <= 6
! 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;
! uint32_t val = (~imms & 0x3f);
for (int i = 5; i > 0; i--) {
if (val & (1 << i)) {
len = i;
break;
}
*** 168,178 ****
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);
for (int i = 5; i > 0; i--) {
if (!(val2 & (1 << i))) {
len2 = i;
break;
}
--- 168,178 ----
return 0;
}
// for valid inputs leading 1s in immr must be less than leading
// zeros in imms
int len2 = 0; // ought to be < len
! uint32_t val2 = (~immr & 0x3f);
for (int i = 5; i > 0; i--) {
if (!(val2 & (1 << i))) {
len2 = i;
break;
}
*** 197,212 ****
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;
tmask = ((tmask
& (replicate(and_bits_top, 2 * nbits, 32 / nbits)))
| replicate(or_bits_top, 2 * nbits, 32 / nbits));
}
--- 197,212 ----
tmask_or = (diff & levels) & 0x3f;
tmask = 0xffffffffffffffffULL;
for (int i = 0; i < 6; i++) {
int nbits = 1 << i;
! 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,231 ****
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;
wmask = ((wmask
& (replicate(and_bits_top, 2 * nbits, 32 / nbits)))
| replicate(or_bits_top, 2 * nbits, 32 / nbits));
}
--- 216,231 ----
wmask = 0;
for (int i = 0; i < 6; i++) {
int nbits = 1 << i;
! 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));
}
*** 246,258 ****
static void initLITables() __attribute__ ((constructor));
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);
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++;
}
--- 246,258 ----
static void initLITables() __attribute__ ((constructor));
static void initLITables()
{
li_table_entry_count = 0;
for (unsigned index = 0; index < LI_TABLE_SIZE; index++) {
! 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,277 ****
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)
{
return LITable[encoding];
}
! u_int32_t encoding_for_logical_immediate(u_int64_t immediate)
{
struct li_pair pair;
struct li_pair *result;
pair.immediate = immediate;
--- 262,277 ----
sizeof(InverseLITable[0]), compare_immediate_pair);
}
// public APIs provided for logical immediate lookup and reverse lookup
! uint64_t logical_immediate_for_encoding(uint32_t encoding)
{
return LITable[encoding];
}
! uint32_t encoding_for_logical_immediate(uint64_t immediate)
{
struct li_pair pair;
struct li_pair *result;
pair.immediate = immediate;
*** 291,309 ****
// 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)
{
union {
float fpval;
double dpval;
! u_int64_t val;
};
! u_int32_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;
--- 291,309 ----
// 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)
! uint64_t fp_immediate_for_encoding(uint32_t imm8, int is_dp)
{
union {
float fpval;
double dpval;
! uint64_t val;
};
! 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,337 ****
dpval = (double)fpval;
}
return val;
}
! u_int32_t encoding_for_fp_immediate(float immediate)
{
// given a float which is of the form
//
// s * n/16 * 2r
//
--- 327,337 ----
dpval = (double)fpval;
}
return val;
}
! uint32_t encoding_for_fp_immediate(float immediate)
{
// given a float which is of the form
//
// s * n/16 * 2r
//
*** 339,352 ****
// return the imm8 result [s:r:f]
//
union {
float fpval;
! u_int32_t val;
};
fpval = immediate;
! u_int32_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
--- 339,352 ----
// return the imm8 result [s:r:f]
//
union {
float fpval;
! uint32_t val;
};
fpval = immediate;
! 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 >