truffle: src/cpu/x86/vm/x86

comparison src/cpu/x86/vm/x86_64.ad @ 12355:cefad50507d8

Merge with hs25-b53

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Fri, 11 Oct 2013 10:38:03 +0200
parents	268e7a2178d7
children	59e8ad757e19

comparison

equal deleted inserted replaced

-:ccb4f2af2319
+:cefad50507d8
 void emit_d32_reloc(CodeBuffer& cbuf, int d32, RelocationHolder const& rspec, int format) {
 #ifdef ASSERT
 if (rspec.reloc()->type() == relocInfo::oop_type &&
 d32 != 0 && d32 != (intptr_t) Universe::non_oop_word()) {
 assert(Universe::heap()->is_in_reserved((address)(intptr_t)d32), "should be real oop");
-assert(oop((intptr_t)d32)->is_oop() && (ScavengeRootsInCode || !oop((intptr_t)d32)->is_scavengable()), "cannot embed scavengable oops in code");
+assert(cast_to_oop((intptr_t)d32)->is_oop() && (ScavengeRootsInCode || !cast_to_oop((intptr_t)d32)->is_scavengable()), "cannot embed scavengable oops in code");
 }
 #endif
 cbuf.relocate(cbuf.insts_mark(), rspec, format);
 cbuf.insts()->emit_int32(d32);
 }
 void emit_d64_reloc(CodeBuffer& cbuf, int64_t d64, RelocationHolder const& rspec, int format) {
 #ifdef ASSERT
 if (rspec.reloc()->type() == relocInfo::oop_type &&
 d64 != 0 && d64 != (int64_t) Universe::non_oop_word()) {
 assert(Universe::heap()->is_in_reserved((address)d64), "should be real oop");
-assert(oop(d64)->is_oop() && (ScavengeRootsInCode || !oop(d64)->is_scavengable()),
+assert(cast_to_oop(d64)->is_oop() && (ScavengeRootsInCode || !cast_to_oop(d64)->is_scavengable()),
 "cannot embed scavengable oops in code");
 }
 #endif
 cbuf.relocate(cbuf.insts_mark(), rspec, format);
 cbuf.insts()->emit_int64(d64);
 //=============================================================================
 #ifndef PRODUCT
 void MachUEPNode::format(PhaseRegAlloc* ra_, outputStream* st) const
 {
-if (UseCompressedKlassPointers) {
+if (UseCompressedClassPointers) {
 st->print_cr("movl    rscratch1, [j_rarg0 + oopDesc::klass_offset_in_bytes()]\t# compressed klass");
 st->print_cr("\tdecode_klass_not_null rscratch1, rscratch1");
 st->print_cr("\tcmpq    rax, rscratch1\t # Inline cache check");
 } else {
 st->print_cr("\tcmpq    rax, [j_rarg0 + oopDesc::klass_offset_in_bytes()]\t"
 void MachUEPNode::emit(CodeBuffer& cbuf, PhaseRegAlloc* ra_) const
 {
 MacroAssembler masm(&cbuf);
 uint insts_size = cbuf.insts_size();
-if (UseCompressedKlassPointers) {
+if (UseCompressedClassPointers) {
 masm.load_klass(rscratch1, j_rarg0);
 masm.cmpptr(rax, rscratch1);
 } else {
 masm.cmpptr(rax, Address(j_rarg0, oopDesc::klass_offset_in_bytes()));
 }
 assert(UseCompressedOops, "only for compressed oops code");
 return (LogMinObjAlignmentInBytes <= 3);
 }
 bool Matcher::narrow_klass_use_complex_address() {
-assert(UseCompressedKlassPointers, "only for compressed klass code");
+assert(UseCompressedClassPointers, "only for compressed klass code");
 return (LogKlassAlignmentInBytes <= 3);
 }
 // Is it better to copy float constants, or load them directly from
 // memory?  Intel can load a float constant from a direct address,
 return LONG_RDX_REG_mask();
 }
 const RegMask Matcher::method_handle_invoke_SP_save_mask() {
 return PTR_RBP_REG_mask();
+}
+const RegMask Matcher::mathExactI_result_proj_mask() {
+return INT_RAX_REG_mask();
+}
+const RegMask Matcher::mathExactI_flags_proj_mask() {
+return INT_FLAGS_mask();
 }
 %}
 //----------ENCODING BLOCK-----------------------------------------------------
 not_equal(0x5, "ne");
 less(0xC, "l");
 greater_equal(0xD, "ge");
 less_equal(0xE, "le");
 greater(0xF, "g");
+overflow(0x0, "o");
+no_overflow(0x1, "no");
 %}
 %}
 // Comparison Code, unsigned compare.  Used by FP also, with
 // C2 (unordered) turned into GT or LT already.  The other bits
 not_equal(0x5, "ne");
 less(0x2, "b");
 greater_equal(0x3, "nb");
 less_equal(0x6, "be");
 greater(0x7, "nbe");
+overflow(0x0, "o");
+no_overflow(0x1, "no");
 %}
 %}
 // Floating comparisons that don't require any fixup for the unordered case
 not_equal(0x5, "ne");
 less(0x2, "b");
 greater_equal(0x3, "nb");
 less_equal(0x6, "be");
 greater(0x7, "nbe");
+overflow(0x0, "o");
+no_overflow(0x1, "no");
 %}
 %}
 // Floating comparisons that can be fixed up with extra conditional jumps
 not_equal(0x5, "ne");
 less(0x2, "b");
 greater_equal(0x3, "nb");
 less_equal(0x6, "be");
 greater(0x7, "nbe");
+overflow(0x0, "o");
+no_overflow(0x1, "no");
 %}
 %}
 //----------OPERAND CLASSES----------------------------------------------------
 %}
 %}
 //----------Arithmetic Instructions--------------------------------------------
 //----------Addition Instructions----------------------------------------------
+instruct addExactI_rReg(rax_RegI dst, rRegI src, rFlagsReg cr)
+%{
+match(AddExactI dst src);
+effect(DEF cr);
+format %{ "addl    $dst, $src\t# addExact int" %}
+ins_encode %{
+__ addl($dst$$Register, $src$$Register);
+%}
+ins_pipe(ialu_reg_reg);
+%}
+instruct addExactI_rReg_imm(rax_RegI dst, immI src, rFlagsReg cr)
+%{
+match(AddExactI dst src);
+effect(DEF cr);
+format %{ "addl    $dst, $src\t# addExact int" %}
+ins_encode %{
+__ addl($dst$$Register, $src$$constant);
+%}
+ins_pipe(ialu_reg_reg);
+%}
 instruct addI_rReg(rRegI dst, rRegI src, rFlagsReg cr)
 %{
 match(Set dst (AddI dst src));
 effect(KILL cr);

Mercurial > hg > truffle

comparison src/cpu/x86/vm/x86_64.ad @ 12355:cefad50507d8