*** old/src/cpu/x86/vm/x86_64.ad	Mon Dec 19 12:30:05 2011
--- new/src/cpu/x86/vm/x86_64.ad	Mon Dec 19 12:30:05 2011

*** 9871,10270 ****
--- 9871,9880 ----
      emit_cmpfp3(_masm, $dst$$Register);
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct addF_reg(regF dst, regF src)
  %{
    match(Set dst (AddF dst src));
  
    format %{ "addss   $dst, $src" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ addss($dst$$XMMRegister, $src$$XMMRegister);
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct addF_mem(regF dst, memory src)
  %{
    match(Set dst (AddF dst (LoadF src)));
  
    format %{ "addss   $dst, $src" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ addss($dst$$XMMRegister, $src$$Address);
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct addF_imm(regF dst, immF con) %{
    match(Set dst (AddF dst con));
    format %{ "addss   $dst, [$constantaddress]\t# load from constant table: float=$con" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ addss($dst$$XMMRegister, $constantaddress($con));
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct addD_reg(regD dst, regD src)
  %{
    match(Set dst (AddD dst src));
  
    format %{ "addsd   $dst, $src" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ addsd($dst$$XMMRegister, $src$$XMMRegister);
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct addD_mem(regD dst, memory src)
  %{
    match(Set dst (AddD dst (LoadD src)));
  
    format %{ "addsd   $dst, $src" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ addsd($dst$$XMMRegister, $src$$Address);
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct addD_imm(regD dst, immD con) %{
    match(Set dst (AddD dst con));
    format %{ "addsd   $dst, [$constantaddress]\t# load from constant table: double=$con" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ addsd($dst$$XMMRegister, $constantaddress($con));
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct subF_reg(regF dst, regF src)
  %{
    match(Set dst (SubF dst src));
  
    format %{ "subss   $dst, $src" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ subss($dst$$XMMRegister, $src$$XMMRegister);
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct subF_mem(regF dst, memory src)
  %{
    match(Set dst (SubF dst (LoadF src)));
  
    format %{ "subss   $dst, $src" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ subss($dst$$XMMRegister, $src$$Address);
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct subF_imm(regF dst, immF con) %{
    match(Set dst (SubF dst con));
    format %{ "subss   $dst, [$constantaddress]\t# load from constant table: float=$con" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ subss($dst$$XMMRegister, $constantaddress($con));
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct subD_reg(regD dst, regD src)
  %{
    match(Set dst (SubD dst src));
  
    format %{ "subsd   $dst, $src" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ subsd($dst$$XMMRegister, $src$$XMMRegister);
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct subD_mem(regD dst, memory src)
  %{
    match(Set dst (SubD dst (LoadD src)));
  
    format %{ "subsd   $dst, $src" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ subsd($dst$$XMMRegister, $src$$Address);
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct subD_imm(regD dst, immD con) %{
    match(Set dst (SubD dst con));
    format %{ "subsd   $dst, [$constantaddress]\t# load from constant table: double=$con" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ subsd($dst$$XMMRegister, $constantaddress($con));
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct mulF_reg(regF dst, regF src)
  %{
    match(Set dst (MulF dst src));
  
    format %{ "mulss   $dst, $src" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ mulss($dst$$XMMRegister, $src$$XMMRegister);
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct mulF_mem(regF dst, memory src)
  %{
    match(Set dst (MulF dst (LoadF src)));
  
    format %{ "mulss   $dst, $src" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ mulss($dst$$XMMRegister, $src$$Address);
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct mulF_imm(regF dst, immF con) %{
    match(Set dst (MulF dst con));
    format %{ "mulss   $dst, [$constantaddress]\t# load from constant table: float=$con" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ mulss($dst$$XMMRegister, $constantaddress($con));
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct mulD_reg(regD dst, regD src)
  %{
    match(Set dst (MulD dst src));
  
    format %{ "mulsd   $dst, $src" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ mulsd($dst$$XMMRegister, $src$$XMMRegister);
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct mulD_mem(regD dst, memory src)
  %{
    match(Set dst (MulD dst (LoadD src)));
  
    format %{ "mulsd   $dst, $src" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ mulsd($dst$$XMMRegister, $src$$Address);
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct mulD_imm(regD dst, immD con) %{
    match(Set dst (MulD dst con));
    format %{ "mulsd   $dst, [$constantaddress]\t# load from constant table: double=$con" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ mulsd($dst$$XMMRegister, $constantaddress($con));
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct divF_reg(regF dst, regF src)
  %{
    match(Set dst (DivF dst src));
  
    format %{ "divss   $dst, $src" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ divss($dst$$XMMRegister, $src$$XMMRegister);
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct divF_mem(regF dst, memory src)
  %{
    match(Set dst (DivF dst (LoadF src)));
  
    format %{ "divss   $dst, $src" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ divss($dst$$XMMRegister, $src$$Address);
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct divF_imm(regF dst, immF con) %{
    match(Set dst (DivF dst con));
    format %{ "divss   $dst, [$constantaddress]\t# load from constant table: float=$con" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ divss($dst$$XMMRegister, $constantaddress($con));
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct divD_reg(regD dst, regD src)
  %{
    match(Set dst (DivD dst src));
  
    format %{ "divsd   $dst, $src" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ divsd($dst$$XMMRegister, $src$$XMMRegister);
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct divD_mem(regD dst, memory src)
  %{
    match(Set dst (DivD dst (LoadD src)));
  
    format %{ "divsd   $dst, $src" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ divsd($dst$$XMMRegister, $src$$Address);
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct divD_imm(regD dst, immD con) %{
    match(Set dst (DivD dst con));
    format %{ "divsd   $dst, [$constantaddress]\t# load from constant table: double=$con" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ divsd($dst$$XMMRegister, $constantaddress($con));
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct sqrtF_reg(regF dst, regF src)
  %{
    match(Set dst (ConvD2F (SqrtD (ConvF2D src))));
  
    format %{ "sqrtss  $dst, $src" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ sqrtss($dst$$XMMRegister, $src$$XMMRegister);
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct sqrtF_mem(regF dst, memory src)
  %{
    match(Set dst (ConvD2F (SqrtD (ConvF2D (LoadF src)))));
  
    format %{ "sqrtss  $dst, $src" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ sqrtss($dst$$XMMRegister, $src$$Address);
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct sqrtF_imm(regF dst, immF con) %{
    match(Set dst (ConvD2F (SqrtD (ConvF2D con))));
    format %{ "sqrtss  $dst, [$constantaddress]\t# load from constant table: float=$con" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ sqrtss($dst$$XMMRegister, $constantaddress($con));
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct sqrtD_reg(regD dst, regD src)
  %{
    match(Set dst (SqrtD src));
  
    format %{ "sqrtsd  $dst, $src" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ sqrtsd($dst$$XMMRegister, $src$$XMMRegister);
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct sqrtD_mem(regD dst, memory src)
  %{
    match(Set dst (SqrtD (LoadD src)));
  
    format %{ "sqrtsd  $dst, $src" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ sqrtsd($dst$$XMMRegister, $src$$Address);
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct sqrtD_imm(regD dst, immD con) %{
    match(Set dst (SqrtD con));
    format %{ "sqrtsd  $dst, [$constantaddress]\t# load from constant table: double=$con" %}
    ins_cost(150); // XXX
    ins_encode %{
      __ sqrtsd($dst$$XMMRegister, $constantaddress($con));
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct absF_reg(regF dst)
  %{
    match(Set dst (AbsF dst));
    ins_cost(150); // XXX
    format %{ "andps   $dst, [0x7fffffff]\t# abs float by sign masking" %}
    ins_encode %{
      __ andps($dst$$XMMRegister,
               ExternalAddress((address) StubRoutines::x86::float_sign_mask()));
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct absD_reg(regD dst)
  %{
    match(Set dst (AbsD dst));
    ins_cost(150); // XXX
    format %{ "andpd   $dst, [0x7fffffffffffffff]\t"
              "# abs double by sign masking" %}
    ins_encode %{
      __ andpd($dst$$XMMRegister,
               ExternalAddress((address) StubRoutines::x86::double_sign_mask()));
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct negF_reg(regF dst)
  %{
    match(Set dst (NegF dst));
    ins_cost(150); // XXX
    format %{ "xorps   $dst, [0x80000000]\t# neg float by sign flipping" %}
    ins_encode %{
      __ xorps($dst$$XMMRegister,
               ExternalAddress((address) StubRoutines::x86::float_sign_flip()));
    %}
    ins_pipe(pipe_slow);
  %}
  
  instruct negD_reg(regD dst)
  %{
    match(Set dst (NegD dst));
    ins_cost(150); // XXX
    format %{ "xorpd   $dst, [0x8000000000000000]\t"
              "# neg double by sign flipping" %}
    ins_encode %{
      __ xorpd($dst$$XMMRegister,
               ExternalAddress((address) StubRoutines::x86::double_sign_flip()));
    %}
    ins_pipe(pipe_slow);
  %}
  
  // -----------Trig and Trancendental Instructions------------------------------
  instruct cosD_reg(regD dst) %{
    match(Set dst (CosD dst));
  
    format %{ "dcos   $dst\n\t" %}