hotspot/src/share/vm/c1/c1_LIR.hpp
Print this page
rev 611 : Merge
*** 1,10 ****
#ifdef USE_PRAGMA_IDENT_HDR
#pragma ident "@(#)c1_LIR.hpp 1.134 07/06/18 14:25:24 JVM"
#endif
/*
! * Copyright 2000-2006 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
--- 1,10 ----
#ifdef USE_PRAGMA_IDENT_HDR
#pragma ident "@(#)c1_LIR.hpp 1.134 07/06/18 14:25:24 JVM"
#endif
/*
! * Copyright 2000-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*** 136,145 ****
--- 136,152 ----
return high(jlong_cast(_value.get_jdouble()));
} else {
return as_jint_hi();
}
}
+ jlong as_jlong_bits() const {
+ if (type() == T_DOUBLE) {
+ return jlong_cast(_value.get_jdouble());
+ } else {
+ return as_jlong();
+ }
+ }
virtual void print_value_on(outputStream* out) const PRODUCT_RETURN;
bool is_zero_float() {
*** 303,312 ****
--- 310,320 ----
return single_size;
break;
default:
ShouldNotReachHere();
+ return single_size;
}
}
void validate_type() const PRODUCT_RETURN;
*** 418,433 ****
}
#endif
return as_register();
}
! #ifdef IA32
XMMRegister as_xmm_float_reg() const;
XMMRegister as_xmm_double_reg() const;
// for compatibility with RInfo
int fpu () const { return lo_reg_half(); }
! #endif
#ifdef SPARC
FloatRegister as_float_reg () const;
FloatRegister as_double_reg () const;
#endif
--- 426,441 ----
}
#endif
return as_register();
}
! #ifdef X86
XMMRegister as_xmm_float_reg() const;
XMMRegister as_xmm_double_reg() const;
// for compatibility with RInfo
int fpu () const { return lo_reg_half(); }
! #endif // X86
#ifdef SPARC
FloatRegister as_float_reg () const;
FloatRegister as_double_reg () const;
#endif
*** 504,521 ****
, _index(LIR_OprDesc::illegalOpr())
, _scale(times_1)
, _type(type)
, _disp(disp) { verify(); }
! #ifdef IA32
LIR_Address(LIR_Opr base, LIR_Opr index, Scale scale, int disp, BasicType type):
_base(base)
, _index(index)
, _scale(scale)
, _type(type)
, _disp(disp) { verify(); }
! #endif
LIR_Opr base() const { return _base; }
LIR_Opr index() const { return _index; }
Scale scale() const { return _scale; }
intx disp() const { return _disp; }
--- 512,529 ----
, _index(LIR_OprDesc::illegalOpr())
, _scale(times_1)
, _type(type)
, _disp(disp) { verify(); }
! #ifdef X86
LIR_Address(LIR_Opr base, LIR_Opr index, Scale scale, int disp, BasicType type):
_base(base)
, _index(index)
, _scale(scale)
, _type(type)
, _disp(disp) { verify(); }
! #endif // X86
LIR_Opr base() const { return _base; }
LIR_Opr index() const { return _index; }
Scale scale() const { return _scale; }
intx disp() const { return _disp; }
*** 536,570 ****
class LIR_OprFact: public AllStatic {
public:
static LIR_Opr illegalOpr;
! static LIR_Opr single_cpu(int reg) { return (LIR_Opr)((reg << LIR_OprDesc::reg1_shift) | LIR_OprDesc::int_type | LIR_OprDesc::cpu_register | LIR_OprDesc::single_size); }
! static LIR_Opr single_cpu_oop(int reg) { return (LIR_Opr)((reg << LIR_OprDesc::reg1_shift) | LIR_OprDesc::object_type | LIR_OprDesc::cpu_register | LIR_OprDesc::single_size); }
! static LIR_Opr double_cpu(int reg1, int reg2) { return (LIR_Opr)((reg1 << LIR_OprDesc::reg1_shift) | (reg2 << LIR_OprDesc::reg2_shift) | LIR_OprDesc::long_type | LIR_OprDesc::cpu_register | LIR_OprDesc::double_size); }
! static LIR_Opr single_fpu(int reg) { return (LIR_Opr)((reg << LIR_OprDesc::reg1_shift) | LIR_OprDesc::float_type | LIR_OprDesc::fpu_register | LIR_OprDesc::single_size); }
#ifdef SPARC
! static LIR_Opr double_fpu(int reg1, int reg2) { return (LIR_Opr)((reg1 << LIR_OprDesc::reg1_shift) | (reg2 << LIR_OprDesc::reg2_shift) | LIR_OprDesc::double_type | LIR_OprDesc::fpu_register | LIR_OprDesc::double_size); }
! #endif
! #ifdef IA32
! static LIR_Opr double_fpu(int reg) { return (LIR_Opr)((reg << LIR_OprDesc::reg1_shift) | (reg << LIR_OprDesc::reg2_shift) | LIR_OprDesc::double_type | LIR_OprDesc::fpu_register | LIR_OprDesc::double_size); }
! static LIR_Opr single_xmm(int reg) { return (LIR_Opr)((reg << LIR_OprDesc::reg1_shift) | LIR_OprDesc::float_type | LIR_OprDesc::fpu_register | LIR_OprDesc::single_size | LIR_OprDesc::is_xmm_mask); }
! static LIR_Opr double_xmm(int reg) { return (LIR_Opr)((reg << LIR_OprDesc::reg1_shift) | (reg << LIR_OprDesc::reg2_shift) | LIR_OprDesc::double_type | LIR_OprDesc::fpu_register | LIR_OprDesc::double_size | LIR_OprDesc::is_xmm_mask); }
! #endif
static LIR_Opr virtual_register(int index, BasicType type) {
LIR_Opr res;
switch (type) {
case T_OBJECT: // fall through
! case T_ARRAY: res = (LIR_Opr)((index << LIR_OprDesc::data_shift) | LIR_OprDesc::object_type | LIR_OprDesc::cpu_register | LIR_OprDesc::single_size | LIR_OprDesc::virtual_mask); break;
! case T_INT: res = (LIR_Opr)((index << LIR_OprDesc::data_shift) | LIR_OprDesc::int_type | LIR_OprDesc::cpu_register | LIR_OprDesc::single_size | LIR_OprDesc::virtual_mask); break;
! case T_LONG: res = (LIR_Opr)((index << LIR_OprDesc::data_shift) | LIR_OprDesc::long_type | LIR_OprDesc::cpu_register | LIR_OprDesc::double_size | LIR_OprDesc::virtual_mask); break;
! case T_FLOAT: res = (LIR_Opr)((index << LIR_OprDesc::data_shift) | LIR_OprDesc::float_type | LIR_OprDesc::fpu_register | LIR_OprDesc::single_size | LIR_OprDesc::virtual_mask); break;
! case T_DOUBLE: res = (LIR_Opr)((index << LIR_OprDesc::data_shift) | LIR_OprDesc::double_type | LIR_OprDesc::fpu_register | LIR_OprDesc::double_size | LIR_OprDesc::virtual_mask); break;
default: ShouldNotReachHere(); res = illegalOpr;
}
#ifdef ASSERT
--- 544,640 ----
class LIR_OprFact: public AllStatic {
public:
static LIR_Opr illegalOpr;
! static LIR_Opr single_cpu(int reg) { return (LIR_Opr)(intptr_t)((reg << LIR_OprDesc::reg1_shift) | LIR_OprDesc::int_type | LIR_OprDesc::cpu_register | LIR_OprDesc::single_size); }
! static LIR_Opr single_cpu_oop(int reg) { return (LIR_Opr)(intptr_t)((reg << LIR_OprDesc::reg1_shift) | LIR_OprDesc::object_type | LIR_OprDesc::cpu_register | LIR_OprDesc::single_size); }
! static LIR_Opr double_cpu(int reg1, int reg2) {
! LP64_ONLY(assert(reg1 == reg2, "must be identical"));
! return (LIR_Opr)(intptr_t)((reg1 << LIR_OprDesc::reg1_shift) |
! (reg2 << LIR_OprDesc::reg2_shift) |
! LIR_OprDesc::long_type |
! LIR_OprDesc::cpu_register |
! LIR_OprDesc::double_size);
! }
! static LIR_Opr single_fpu(int reg) { return (LIR_Opr)(intptr_t)((reg << LIR_OprDesc::reg1_shift) |
! LIR_OprDesc::float_type |
! LIR_OprDesc::fpu_register |
! LIR_OprDesc::single_size); }
#ifdef SPARC
! static LIR_Opr double_fpu(int reg1, int reg2) { return (LIR_Opr)(intptr_t)((reg1 << LIR_OprDesc::reg1_shift) |
! (reg2 << LIR_OprDesc::reg2_shift) |
! LIR_OprDesc::double_type |
! LIR_OprDesc::fpu_register |
! LIR_OprDesc::double_size); }
! #endif
! #ifdef X86
! static LIR_Opr double_fpu(int reg) { return (LIR_Opr)(intptr_t)((reg << LIR_OprDesc::reg1_shift) |
! (reg << LIR_OprDesc::reg2_shift) |
! LIR_OprDesc::double_type |
! LIR_OprDesc::fpu_register |
! LIR_OprDesc::double_size); }
!
! static LIR_Opr single_xmm(int reg) { return (LIR_Opr)(intptr_t)((reg << LIR_OprDesc::reg1_shift) |
! LIR_OprDesc::float_type |
! LIR_OprDesc::fpu_register |
! LIR_OprDesc::single_size |
! LIR_OprDesc::is_xmm_mask); }
! static LIR_Opr double_xmm(int reg) { return (LIR_Opr)(intptr_t)((reg << LIR_OprDesc::reg1_shift) |
! (reg << LIR_OprDesc::reg2_shift) |
! LIR_OprDesc::double_type |
! LIR_OprDesc::fpu_register |
! LIR_OprDesc::double_size |
! LIR_OprDesc::is_xmm_mask); }
! #endif // X86
static LIR_Opr virtual_register(int index, BasicType type) {
LIR_Opr res;
switch (type) {
case T_OBJECT: // fall through
! case T_ARRAY:
! res = (LIR_Opr)(intptr_t)((index << LIR_OprDesc::data_shift) |
! LIR_OprDesc::object_type |
! LIR_OprDesc::cpu_register |
! LIR_OprDesc::single_size |
! LIR_OprDesc::virtual_mask);
! break;
!
! case T_INT:
! res = (LIR_Opr)(intptr_t)((index << LIR_OprDesc::data_shift) |
! LIR_OprDesc::int_type |
! LIR_OprDesc::cpu_register |
! LIR_OprDesc::single_size |
! LIR_OprDesc::virtual_mask);
! break;
!
! case T_LONG:
! res = (LIR_Opr)(intptr_t)((index << LIR_OprDesc::data_shift) |
! LIR_OprDesc::long_type |
! LIR_OprDesc::cpu_register |
! LIR_OprDesc::double_size |
! LIR_OprDesc::virtual_mask);
! break;
!
! case T_FLOAT:
! res = (LIR_Opr)(intptr_t)((index << LIR_OprDesc::data_shift) |
! LIR_OprDesc::float_type |
! LIR_OprDesc::fpu_register |
! LIR_OprDesc::single_size |
! LIR_OprDesc::virtual_mask);
! break;
!
! case
! T_DOUBLE: res = (LIR_Opr)(intptr_t)((index << LIR_OprDesc::data_shift) |
! LIR_OprDesc::double_type |
! LIR_OprDesc::fpu_register |
! LIR_OprDesc::double_size |
! LIR_OprDesc::virtual_mask);
! break;
default: ShouldNotReachHere(); res = illegalOpr;
}
#ifdef ASSERT
*** 573,583 ****
assert(index >= LIR_OprDesc::vreg_base, "must start at vreg_base");
assert(index <= (max_jint >> LIR_OprDesc::data_shift), "index is too big");
// old-style calculation; check if old and new method are equal
LIR_OprDesc::OprType t = as_OprType(type);
! LIR_Opr old_res = (LIR_Opr)((index << LIR_OprDesc::data_shift) | t |
((type == T_FLOAT || type == T_DOUBLE) ? LIR_OprDesc::fpu_register : LIR_OprDesc::cpu_register) |
LIR_OprDesc::size_for(type) | LIR_OprDesc::virtual_mask);
assert(res == old_res, "old and new method not equal");
#endif
--- 643,653 ----
assert(index >= LIR_OprDesc::vreg_base, "must start at vreg_base");
assert(index <= (max_jint >> LIR_OprDesc::data_shift), "index is too big");
// old-style calculation; check if old and new method are equal
LIR_OprDesc::OprType t = as_OprType(type);
! LIR_Opr old_res = (LIR_Opr)(intptr_t)((index << LIR_OprDesc::data_shift) | t |
((type == T_FLOAT || type == T_DOUBLE) ? LIR_OprDesc::fpu_register : LIR_OprDesc::cpu_register) |
LIR_OprDesc::size_for(type) | LIR_OprDesc::virtual_mask);
assert(res == old_res, "old and new method not equal");
#endif
*** 589,612 ****
// index 2.
static LIR_Opr stack(int index, BasicType type) {
LIR_Opr res;
switch (type) {
case T_OBJECT: // fall through
! case T_ARRAY: res = (LIR_Opr)((index << LIR_OprDesc::data_shift) | LIR_OprDesc::object_type | LIR_OprDesc::stack_value | LIR_OprDesc::single_size); break;
! case T_INT: res = (LIR_Opr)((index << LIR_OprDesc::data_shift) | LIR_OprDesc::int_type | LIR_OprDesc::stack_value | LIR_OprDesc::single_size); break;
! case T_LONG: res = (LIR_Opr)((index << LIR_OprDesc::data_shift) | LIR_OprDesc::long_type | LIR_OprDesc::stack_value | LIR_OprDesc::double_size); break;
! case T_FLOAT: res = (LIR_Opr)((index << LIR_OprDesc::data_shift) | LIR_OprDesc::float_type | LIR_OprDesc::stack_value | LIR_OprDesc::single_size); break;
! case T_DOUBLE: res = (LIR_Opr)((index << LIR_OprDesc::data_shift) | LIR_OprDesc::double_type | LIR_OprDesc::stack_value | LIR_OprDesc::double_size); break;
default: ShouldNotReachHere(); res = illegalOpr;
}
#ifdef ASSERT
assert(index >= 0, "index must be positive");
assert(index <= (max_jint >> LIR_OprDesc::data_shift), "index is too big");
! LIR_Opr old_res = (LIR_Opr)((index << LIR_OprDesc::data_shift) | LIR_OprDesc::stack_value | as_OprType(type) | LIR_OprDesc::size_for(type));
assert(res == old_res, "old and new method not equal");
#endif
return res;
}
--- 659,713 ----
// index 2.
static LIR_Opr stack(int index, BasicType type) {
LIR_Opr res;
switch (type) {
case T_OBJECT: // fall through
! case T_ARRAY:
! res = (LIR_Opr)(intptr_t)((index << LIR_OprDesc::data_shift) |
! LIR_OprDesc::object_type |
! LIR_OprDesc::stack_value |
! LIR_OprDesc::single_size);
! break;
!
! case T_INT:
! res = (LIR_Opr)(intptr_t)((index << LIR_OprDesc::data_shift) |
! LIR_OprDesc::int_type |
! LIR_OprDesc::stack_value |
! LIR_OprDesc::single_size);
! break;
!
! case T_LONG:
! res = (LIR_Opr)(intptr_t)((index << LIR_OprDesc::data_shift) |
! LIR_OprDesc::long_type |
! LIR_OprDesc::stack_value |
! LIR_OprDesc::double_size);
! break;
!
! case T_FLOAT:
! res = (LIR_Opr)(intptr_t)((index << LIR_OprDesc::data_shift) |
! LIR_OprDesc::float_type |
! LIR_OprDesc::stack_value |
! LIR_OprDesc::single_size);
! break;
! case T_DOUBLE:
! res = (LIR_Opr)(intptr_t)((index << LIR_OprDesc::data_shift) |
! LIR_OprDesc::double_type |
! LIR_OprDesc::stack_value |
! LIR_OprDesc::double_size);
! break;
default: ShouldNotReachHere(); res = illegalOpr;
}
#ifdef ASSERT
assert(index >= 0, "index must be positive");
assert(index <= (max_jint >> LIR_OprDesc::data_shift), "index is too big");
! LIR_Opr old_res = (LIR_Opr)(intptr_t)((index << LIR_OprDesc::data_shift) |
! LIR_OprDesc::stack_value |
! as_OprType(type) |
! LIR_OprDesc::size_for(type));
assert(res == old_res, "old and new method not equal");
#endif
return res;
}