hotspot/src/cpu/x86/vm/macroAssembler_x86.cpp
changeset 35540 e001ad24dcdb
parent 35146 9ebfec283f56
child 35546 b75e269c0922
equal deleted inserted replaced
35539:9a687b686976 35540:e001ad24dcdb
   967   if (reachable(src)) {
   967   if (reachable(src)) {
   968     addss(dst, as_Address(src));
   968     addss(dst, as_Address(src));
   969   } else {
   969   } else {
   970     lea(rscratch1, src);
   970     lea(rscratch1, src);
   971     addss(dst, Address(rscratch1, 0));
   971     addss(dst, Address(rscratch1, 0));
       
   972   }
       
   973 }
       
   974 
       
   975 void MacroAssembler::addpd(XMMRegister dst, AddressLiteral src) {
       
   976   if (reachable(src)) {
       
   977     Assembler::addpd(dst, as_Address(src));
       
   978   } else {
       
   979     lea(rscratch1, src);
       
   980     Assembler::addpd(dst, Address(rscratch1, 0));
   972   }
   981   }
   973 }
   982 }
   974 
   983 
   975 void MacroAssembler::align(int modulus) {
   984 void MacroAssembler::align(int modulus) {
   976   align(modulus, offset());
   985   align(modulus, offset());
  5730     tmp = rbx;
  5739     tmp = rbx;
  5731     push(tmp);
  5740     push(tmp);
  5732   }
  5741   }
  5733 
  5742 
  5734   Label slow_case, done;
  5743   Label slow_case, done;
  5735 
  5744   if (trig == 't') {
  5736   ExternalAddress pi4_adr = (address)&pi_4;
  5745     ExternalAddress pi4_adr = (address)&pi_4;
  5737   if (reachable(pi4_adr)) {
  5746     if (reachable(pi4_adr)) {
  5738     // x ?<= pi/4
  5747       // x ?<= pi/4
  5739     fld_d(pi4_adr);
  5748       fld_d(pi4_adr);
  5740     fld_s(1);                // Stack:  X  PI/4  X
  5749       fld_s(1);                // Stack:  X  PI/4  X
  5741     fabs();                  // Stack: |X| PI/4  X
  5750       fabs();                  // Stack: |X| PI/4  X
  5742     fcmp(tmp);
  5751       fcmp(tmp);
  5743     jcc(Assembler::above, slow_case);
  5752       jcc(Assembler::above, slow_case);
  5744 
  5753 
  5745     // fastest case: -pi/4 <= x <= pi/4
  5754       // fastest case: -pi/4 <= x <= pi/4
  5746     switch(trig) {
       
  5747     case 's':
       
  5748       fsin();
       
  5749       break;
       
  5750     case 'c':
       
  5751       fcos();
       
  5752       break;
       
  5753     case 't':
       
  5754       ftan();
  5755       ftan();
  5755       break;
  5756 
  5756     default:
  5757       jmp(done);
  5757       assert(false, "bad intrinsic");
  5758     }
  5758       break;
  5759   }
  5759     }
       
  5760     jmp(done);
       
  5761   }
       
  5762 
       
  5763   // slow case: runtime call
  5760   // slow case: runtime call
  5764   bind(slow_case);
  5761   bind(slow_case);
  5765 
  5762 
  5766   switch(trig) {
  5763   switch(trig) {
  5767   case 's':
  5764   case 's':
  5789 
  5786 
  5790   if (tmp != noreg) {
  5787   if (tmp != noreg) {
  5791     pop(tmp);
  5788     pop(tmp);
  5792   }
  5789   }
  5793 }
  5790 }
  5794 
       
  5795 
  5791 
  5796 // Look up the method for a megamorphic invokeinterface call.
  5792 // Look up the method for a megamorphic invokeinterface call.
  5797 // The target method is determined by <intf_klass, itable_index>.
  5793 // The target method is determined by <intf_klass, itable_index>.
  5798 // The receiver klass is in recv_klass.
  5794 // The receiver klass is in recv_klass.
  5799 // On success, the result will be in method_result, and execution falls through.
  5795 // On success, the result will be in method_result, and execution falls through.