*** old/src/cpu/x86/vm/x86_64.ad	Fri Oct 18 10:43:02 2013
--- new/src/cpu/x86/vm/x86_64.ad	Fri Oct 18 10:43:02 2013

*** 1651,1660 ****
--- 1651,1664 ----
  
  const RegMask Matcher::mathExactI_result_proj_mask() {
    return INT_RAX_REG_mask();
  }
  
+ const RegMask Matcher::mathExactL_result_proj_mask() {
+   return LONG_RAX_REG_mask();
+ }
+ 
  const RegMask Matcher::mathExactI_flags_proj_mask() {
    return INT_FLAGS_mask();
  }
  
  %}

*** 6960,6969 ****
--- 6964,7025 ----
      __ addl($dst$$Register, $src$$constant);
    %}
    ins_pipe(ialu_reg_reg);
  %}
  
+ instruct addExactI_rReg_mem(rax_RegI dst, memory src, rFlagsReg cr)
+ %{
+   match(AddExactI dst (LoadI src));
+   effect(DEF cr);
+ 
+   ins_cost(125); // XXX
+   format %{ "addl    $dst, $src\t# addExact int" %}
+   ins_encode %{
+     __ addl($dst$$Register, $src$$Address);
+   %}
+ 
+   ins_pipe(ialu_reg_mem);
+ %}
+ 
+ instruct addExactL_rReg(rax_RegL dst, rRegL src, rFlagsReg cr)
+ %{
+   match(AddExactL dst src);
+   effect(DEF cr);
+ 
+   format %{ "addq    $dst, $src\t# addExact long" %}
+   ins_encode %{
+     __ addq($dst$$Register, $src$$Register);
+   %}
+   ins_pipe(ialu_reg_reg);
+ %}
+ 
+ instruct addExactL_rReg_imm(rax_RegL dst, immL32 src, rFlagsReg cr)
+ %{
+   match(AddExactL dst src);
+   effect(DEF cr);
+ 
+   format %{ "addq    $dst, $src\t# addExact long" %}
+   ins_encode %{
+     __ addq($dst$$Register, $src$$constant);
+   %}
+   ins_pipe(ialu_reg_reg);
+ %}
+ 
+ instruct addExactL_rReg_mem(rax_RegL dst, memory src, rFlagsReg cr)
+ %{
+   match(AddExactL dst (LoadL src));
+   effect(DEF cr);
+ 
+   ins_cost(125); // XXX
+   format %{ "addq    $dst, $src\t# addExact long" %}
+   ins_encode %{
+     __ addq($dst$$Register, $src$$Address);
+   %}
+ 
+   ins_pipe(ialu_reg_mem);
+ %}
+ 
  instruct addI_rReg(rRegI dst, rRegI src, rFlagsReg cr)
  %{
    match(Set dst (AddI dst src));
    effect(KILL cr);
  

*** 7572,7581 ****
--- 7628,7711 ----
    opcode(0x81); /* Opcode 81 /5 id */
    ins_encode(REX_mem(dst), OpcSE(src), RM_opc_mem(0x05, dst), Con8or32(src));
    ins_pipe(ialu_mem_imm);
  %}
  
+ instruct subExactI_rReg(rax_RegI dst, rRegI src, rFlagsReg cr)
+ %{
+   match(SubExactI dst src);
+   effect(DEF cr);
+ 
+   format %{ "subl    $dst, $src\t# subExact int" %}
+   ins_encode %{
+     __ subl($dst$$Register, $src$$Register);
+   %}
+   ins_pipe(ialu_reg_reg);
+ %}
+ 
+ instruct subExactI_rReg_imm(rax_RegI dst, immI src, rFlagsReg cr)
+ %{
+   match(SubExactI dst src);
+   effect(DEF cr);
+ 
+   format %{ "subl    $dst, $src\t# subExact int" %}
+   ins_encode %{
+     __ subl($dst$$Register, $src$$constant);
+   %}
+   ins_pipe(ialu_reg_reg);
+ %}
+ 
+ instruct subExactI_rReg_mem(rax_RegI dst, memory src, rFlagsReg cr)
+ %{
+   match(SubExactI dst (LoadI src));
+   effect(DEF cr);
+ 
+   ins_cost(125);
+   format %{ "subl    $dst, $src\t# subExact int" %}
+   ins_encode %{
+     __ subl($dst$$Register, $src$$Address);
+   %}
+   ins_pipe(ialu_reg_mem);
+ %}
+ 
+ instruct subExactL_rReg(rax_RegL dst, rRegL src, rFlagsReg cr)
+ %{
+   match(SubExactL dst src);
+   effect(DEF cr);
+ 
+   format %{ "subq    $dst, $src\t# subExact long" %}
+   ins_encode %{
+     __ subq($dst$$Register, $src$$Register);
+   %}
+   ins_pipe(ialu_reg_reg);
+ %}
+ 
+ instruct subExactL_rReg_imm(rax_RegL dst, immL32 src, rFlagsReg cr)
+ %{
+   match(SubExactL dst (LoadL src));
+   effect(DEF cr);
+ 
+   format %{ "subq    $dst, $src\t# subExact long" %}
+   ins_encode %{
+     __ subq($dst$$Register, $src$$constant);
+   %}
+   ins_pipe(ialu_reg_reg);
+ %}
+ 
+ instruct subExactL_rReg_mem(rax_RegI dst, memory src, rFlagsReg cr)
+ %{
+   match(SubExactI dst src);
+   effect(DEF cr);
+ 
+   ins_cost(125);
+   format %{ "subq    $dst, $src\t# subExact long" %}
+   ins_encode %{
+     __ subq($dst$$Register, $src$$Address);
+   %}
+   ins_pipe(ialu_reg_mem);
+ %}
+ 
  instruct subL_rReg(rRegL dst, rRegL src, rFlagsReg cr)
  %{
    match(Set dst (SubL dst src));
    effect(KILL cr);
  

*** 7688,7697 ****
--- 7818,7851 ----
    opcode(0xF7, 0x03);  // Opcode F7 /3
    ins_encode(REX_mem_wide(dst), OpcP, RM_opc_mem(secondary, dst));
    ins_pipe(ialu_reg);
  %}
  
+ instruct negExactI_rReg(rax_RegI dst, rFlagsReg cr)
+ %{
+   match(NegExactI dst);
+   effect(KILL cr);
+ 
+   format %{ "negl    $dst\t# negExact int" %}
+   ins_encode %{
+     __ negl($dst$$Register);
+   %}
+   ins_pipe(ialu_reg);
+ %}
+ 
+ instruct negExactL_rReg(rax_RegL dst, rFlagsReg cr)
+ %{
+   match(NegExactL dst);
+   effect(KILL cr);
+ 
+   format %{ "negq    $dst\t# negExact long" %}
+   ins_encode %{
+     __ negq($dst$$Register);
+   %}
+   ins_pipe(ialu_reg);
+ %}
+ 
  
  //----------Multiplication/Division Instructions-------------------------------
  // Integer Multiplication Instructions
  // Multiply Register
  

*** 7805,7814 ****
--- 7959,8020 ----
    opcode(0xF7, 0x5); /* Opcode F7 /5 */
    ins_encode(REX_reg_wide(src), OpcP, reg_opc(src));
    ins_pipe(ialu_reg_reg_alu0);
  %}
  
+ instruct mulExactI_rReg(rax_RegI dst, rRegI src, rFlagsReg cr)
+ %{
+   match(MulExactI dst src);
+   effect(DEF cr);
+ 
+   ins_cost(300);
+   format %{ "imull   $dst, $src\t# mulExact int" %}
+   ins_encode %{
+     __ imull($dst$$Register, $src$$Register);
+   %}
+   ins_pipe(ialu_reg_reg_alu0);
+ %}
+ 
+ instruct mulExactI_rReg_imm(rax_RegI dst, rRegI src, immI imm, rFlagsReg cr)
+ %{
+   match(MulExactI src imm);
+   effect(DEF cr);
+ 
+   ins_cost(300);
+   format %{ "imull   $dst, $src, $imm\t# mulExact int" %}
+   ins_encode %{
+     __ imull($dst$$Register, $src$$Register, $imm$$constant);
+   %}
+   ins_pipe(ialu_reg_reg_alu0);
+ %}
+ 
+ instruct mulExactL_rReg(rax_RegL dst, rRegL src, rFlagsReg cr)
+ %{
+   match(MulExactL dst src);
+   effect(KILL cr);
+ 
+   ins_cost(300);
+   format %{ "imulq   $dst, $src\t# mulExact long" %}
+   ins_encode %{
+     __ imulq($dst$$Register, $src$$Register);
+   %}
+   ins_pipe(ialu_reg_reg_alu0);
+ %}
+ 
+ instruct mulExactL_rReg_imm(rax_RegL dst, rRegL src, immL32 imm, rFlagsReg cr)
+ %{
+   match(MulExactL src imm);
+   effect(KILL cr);
+ 
+   ins_cost(300);
+   format %{ "imulq   $dst, $src, $imm\t# mulExact long" %}
+   ins_encode %{
+     __ imulq($dst$$Register, $src$$Register, $imm$$constant);
+   %}
+   ins_pipe(ialu_reg_reg_alu0);
+ %}
+ 
  instruct divI_rReg(rax_RegI rax, rdx_RegI rdx, no_rax_rdx_RegI div,
                     rFlagsReg cr)
  %{
    match(Set rax (DivI rax div));
    effect(KILL rdx, KILL cr);