Mercurial Mercurial > jdk-sandbox / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
hotspot/src/cpu/sparc/vm/sparc.ad
changeset 2150 0d91d17158cc
parent 2131 98f9cef66a34
child 2254 f13dda645a4b
child 2154 72a9b7284ccf
equal deleted inserted replaced
2149:3d362637b307 2150:0d91d17158cc 
     1 //
 
     1 //
 
     2 // Copyright 1998-2008 Sun Microsystems, Inc.  All Rights Reserved.
 
     2 // Copyright 1998-2009 Sun Microsystems, Inc.  All Rights Reserved.
 
     3 // DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 
     3 // DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 
     4 //
 
     4 //
 
     5 // This code is free software; you can redistribute it and/or modify it
 
     5 // This code is free software; you can redistribute it and/or modify it
 
     6 // under the terms of the GNU General Public License version 2 only, as
 
     6 // under the terms of the GNU General Public License version 2 only, as
 
     7 // published by the Free Software Foundation.
 
     7 // published by the Free Software Foundation.
 
  5284 instruct loadB(iRegI dst, memory mem) %{
 
  5284 instruct loadB(iRegI dst, memory mem) %{
 
  5285   match(Set dst (LoadB mem));
 
  5285   match(Set dst (LoadB mem));
 
  5286   ins_cost(MEMORY_REF_COST);
 
  5286   ins_cost(MEMORY_REF_COST);
 
  5287 
  5287 
  5288   size(4);
 
  5288   size(4);
 
  5289   format %{ "LDSB   $mem,$dst" %}
 
  5289   format %{ "LDSB   $mem,$dst\t! byte" %}
 
  5290   opcode(Assembler::ldsb_op3);
 
  5290   opcode(Assembler::ldsb_op3);
 
  5291   ins_encode(simple_form3_mem_reg( mem, dst ) );
 
  5291   ins_encode(simple_form3_mem_reg( mem, dst ) );
 
  5292   ins_pipe(iload_mask_mem);
 
  5292   ins_pipe(iload_mask_mem);
 
  5293 %}
 
  5293 %}
 
  5294 
  5294 
  5295 // Load Byte (8bit UNsigned) into an int reg
 
  5295 // Load Byte (8bit signed) into a Long Register
 
  5296 instruct loadUB(iRegI dst, memory mem, immI_255 bytemask) %{
 
  5296 instruct loadB2L(iRegL dst, memory mem) %{
 
  5297   match(Set dst (AndI (LoadB mem) bytemask));
 
  5297   match(Set dst (ConvI2L (LoadB mem)));
 
  5298   ins_cost(MEMORY_REF_COST);
 
  5298   ins_cost(MEMORY_REF_COST);
 
  5299 
  5299 
  5300   size(4);
 
  5300   size(4);
 
  5301   format %{ "LDUB   $mem,$dst" %}
 
  5301   format %{ "LDSB   $mem,$dst\t! byte -> long" %}
 
       
  5302   opcode(Assembler::ldsb_op3);
 
       
  5303   ins_encode(simple_form3_mem_reg( mem, dst ) );
 
       
  5304   ins_pipe(iload_mask_mem);
 
       
  5305 %}
 
       
  5306 
       
  5307 // Load Unsigned Byte (8bit UNsigned) into an int reg
 
       
  5308 instruct loadUB(iRegI dst, memory mem) %{
 
       
  5309   match(Set dst (LoadUB mem));
 
       
  5310   ins_cost(MEMORY_REF_COST);
 
       
  5311 
       
  5312   size(4);
 
       
  5313   format %{ "LDUB   $mem,$dst\t! ubyte" %}
 
  5302   opcode(Assembler::ldub_op3);
 
  5314   opcode(Assembler::ldub_op3);
 
  5303   ins_encode(simple_form3_mem_reg( mem, dst ) );
 
  5315   ins_encode(simple_form3_mem_reg( mem, dst ) );
 
  5304   ins_pipe(iload_mask_mem);
 
  5316   ins_pipe(iload_mask_mem);
 
  5305 %}
 
  5317 %}
 
  5306 
  5318 
  5307 // Load Byte (8bit UNsigned) into a Long Register
 
  5319 // Load Unsigned Byte (8bit UNsigned) into a Long Register
 
  5308 instruct loadUBL(iRegL dst, memory mem, immL_FF bytemask) %{
 
  5320 instruct loadUB2L(iRegL dst, memory mem) %{
 
  5309   match(Set dst (AndL (ConvI2L (LoadB mem)) bytemask));
 
  5321   match(Set dst (ConvI2L (LoadUB mem)));
 
  5310   ins_cost(MEMORY_REF_COST);
 
  5322   ins_cost(MEMORY_REF_COST);
 
  5311 
  5323 
  5312   size(4);
 
  5324   size(4);
 
  5313   format %{ "LDUB   $mem,$dst" %}
 
  5325   format %{ "LDUB   $mem,$dst\t! ubyte -> long" %}
 
  5314   opcode(Assembler::ldub_op3);
 
  5326   opcode(Assembler::ldub_op3);
 
  5315   ins_encode(simple_form3_mem_reg( mem, dst ) );
 
  5327   ins_encode(simple_form3_mem_reg( mem, dst ) );
 
  5316   ins_pipe(iload_mask_mem);
 
  5328   ins_pipe(iload_mask_mem);
 
  5317 %}
 
  5329 %}
 
  5318 
  5330 
  5319 // Load Unsigned Short/Char (16bit UNsigned) into a Long Register
 
  5331 // Load Short (16bit signed)
 
  5320 instruct loadUS2L(iRegL dst, memory mem, immL_FFFF bytemask) %{
 
  5332 instruct loadS(iRegI dst, memory mem) %{
 
  5321   match(Set dst (AndL (ConvI2L (LoadUS mem)) bytemask));
 
  5333   match(Set dst (LoadS mem));
 
  5322   ins_cost(MEMORY_REF_COST);
 
  5334   ins_cost(MEMORY_REF_COST);
 
  5323 
  5335 
  5324   size(4);
 
  5336   size(4);
 
  5325   format %{ "LDUH   $mem,$dst" %}
 
  5337   format %{ "LDSH   $mem,$dst\t! short" %}
 
       
  5338   opcode(Assembler::ldsh_op3);
 
       
  5339   ins_encode(simple_form3_mem_reg( mem, dst ) );
 
       
  5340   ins_pipe(iload_mask_mem);
 
       
  5341 %}
 
       
  5342 
       
  5343 // Load Short (16bit signed) into a Long Register
 
       
  5344 instruct loadS2L(iRegL dst, memory mem) %{
 
       
  5345   match(Set dst (ConvI2L (LoadS mem)));
 
       
  5346   ins_cost(MEMORY_REF_COST);
 
       
  5347 
       
  5348   size(4);
 
       
  5349   format %{ "LDSH   $mem,$dst\t! short -> long" %}
 
       
  5350   opcode(Assembler::ldsh_op3);
 
       
  5351   ins_encode(simple_form3_mem_reg( mem, dst ) );
 
       
  5352   ins_pipe(iload_mask_mem);
 
       
  5353 %}
 
       
  5354 
       
  5355 // Load Unsigned Short/Char (16bit UNsigned)
 
       
  5356 instruct loadUS(iRegI dst, memory mem) %{
 
       
  5357   match(Set dst (LoadUS mem));
 
       
  5358   ins_cost(MEMORY_REF_COST);
 
       
  5359 
       
  5360   size(4);
 
       
  5361   format %{ "LDUH   $mem,$dst\t! ushort/char" %}
 
  5326   opcode(Assembler::lduh_op3);
 
  5362   opcode(Assembler::lduh_op3);
 
  5327   ins_encode(simple_form3_mem_reg( mem, dst ) );
 
  5363   ins_encode(simple_form3_mem_reg( mem, dst ) );
 
  5328   ins_pipe(iload_mask_mem);
 
  5364   ins_pipe(iload_mask_mem);
 
  5329 %}
 
  5365 %}
 
  5330 
  5366 
  5331 // Load Unsigned Short/Char (16bit unsigned)
 
  5367 // Load Unsigned Short/Char (16bit UNsigned) into a Long Register
 
  5332 instruct loadUS(iRegI dst, memory mem) %{
 
  5368 instruct loadUS2L(iRegL dst, memory mem) %{
 
  5333   match(Set dst (LoadUS mem));
 
  5369   match(Set dst (ConvI2L (LoadUS mem)));
 
  5334   ins_cost(MEMORY_REF_COST);
 
  5370   ins_cost(MEMORY_REF_COST);
 
  5335 
  5371 
  5336   size(4);
 
  5372   size(4);
 
  5337   format %{ "LDUH   $mem,$dst" %}
 
  5373   format %{ "LDUH   $mem,$dst\t! ushort/char -> long" %}
 
  5338   opcode(Assembler::lduh_op3);
 
  5374   opcode(Assembler::lduh_op3);
 
  5339   ins_encode(simple_form3_mem_reg( mem, dst ) );
 
  5375   ins_encode(simple_form3_mem_reg( mem, dst ) );
 
  5340   ins_pipe(iload_mask_mem);
 
  5376   ins_pipe(iload_mask_mem);
 
  5341 %}
 
  5377 %}
 
  5342 
  5378 
  5343 // Load Integer
 
  5379 // Load Integer
 
  5344 instruct loadI(iRegI dst, memory mem) %{
 
  5380 instruct loadI(iRegI dst, memory mem) %{
 
  5345   match(Set dst (LoadI mem));
 
  5381   match(Set dst (LoadI mem));
 
  5346   ins_cost(MEMORY_REF_COST);
 
  5382   ins_cost(MEMORY_REF_COST);
 
  5347   size(4);
 
  5383 
  5348 
  5384   size(4);
 
  5349   format %{ "LDUW   $mem,$dst" %}
 
  5385   format %{ "LDUW   $mem,$dst\t! int" %}
 
       
  5386   opcode(Assembler::lduw_op3);
 
       
  5387   ins_encode(simple_form3_mem_reg( mem, dst ) );
 
       
  5388   ins_pipe(iload_mem);
 
       
  5389 %}
 
       
  5390 
       
  5391 // Load Integer into a Long Register
 
       
  5392 instruct loadI2L(iRegL dst, memory mem) %{
 
       
  5393   match(Set dst (ConvI2L (LoadI mem)));
 
       
  5394   ins_cost(MEMORY_REF_COST);
 
       
  5395 
       
  5396   size(4);
 
       
  5397   format %{ "LDSW   $mem,$dst\t! int -> long" %}
 
       
  5398   opcode(Assembler::ldsw_op3);
 
       
  5399   ins_encode(simple_form3_mem_reg( mem, dst ) );
 
       
  5400   ins_pipe(iload_mem);
 
       
  5401 %}
 
       
  5402 
       
  5403 // Load Unsigned Integer into a Long Register
 
       
  5404 instruct loadUI2L(iRegL dst, memory mem) %{
 
       
  5405   match(Set dst (LoadUI2L mem));
 
       
  5406   ins_cost(MEMORY_REF_COST);
 
       
  5407 
       
  5408   size(4);
 
       
  5409   format %{ "LDUW   $mem,$dst\t! uint -> long" %}
 
  5350   opcode(Assembler::lduw_op3);
 
  5410   opcode(Assembler::lduw_op3);
 
  5351   ins_encode(simple_form3_mem_reg( mem, dst ) );
 
  5411   ins_encode(simple_form3_mem_reg( mem, dst ) );
 
  5352   ins_pipe(iload_mem);
 
  5412   ins_pipe(iload_mem);
 
  5353 %}
 
  5413 %}
 
  5354 
  5414 
  5355 // Load Long - aligned
 
  5415 // Load Long - aligned
 
  5356 instruct loadL(iRegL dst, memory mem ) %{
 
  5416 instruct loadL(iRegL dst, memory mem ) %{
 
  5357   match(Set dst (LoadL mem));
 
  5417   match(Set dst (LoadL mem));
 
  5358   ins_cost(MEMORY_REF_COST);
 
  5418   ins_cost(MEMORY_REF_COST);
 
       
  5419 
  5359   size(4);
 
  5420   size(4);
 
  5360   format %{ "LDX    $mem,$dst\t! long" %}
 
  5421   format %{ "LDX    $mem,$dst\t! long" %}
 
  5361   opcode(Assembler::ldx_op3);
 
  5422   opcode(Assembler::ldx_op3);
 
  5362   ins_encode(simple_form3_mem_reg( mem, dst ) );
 
  5423   ins_encode(simple_form3_mem_reg( mem, dst ) );
 
  5363   ins_pipe(iload_mem);
 
  5424   ins_pipe(iload_mem);
 
  5469    ins_cost(MEMORY_REF_COST);
 
  5530    ins_cost(MEMORY_REF_COST);
 
  5470    size(4);
 
  5531    size(4);
 
  5471 
  5532 
  5472    format %{ "LDUW   $mem,$dst\t! compressed ptr" %}
 
  5533    format %{ "LDUW   $mem,$dst\t! compressed ptr" %}
 
  5473    ins_encode %{
 
  5534    ins_encode %{
 
  5474      Register base = as_Register($mem$$base);
 
  5535      Register index = $mem$$index$$Register;
 
  5475      Register index = as_Register($mem$$index);
 
       
  5476      Register dst = $dst$$Register;
 
       
  5477      if (index != G0) {
 
  5536      if (index != G0) {
 
  5478        __ lduw(base, index, dst);
 
  5537        __ lduw($mem$$base$$Register, index, $dst$$Register);
 
  5479      } else {
 
  5538      } else {
 
  5480        __ lduw(base, $mem$$disp, dst);
 
  5539        __ lduw($mem$$base$$Register, $mem$$disp, $dst$$Register);
 
  5481      }
 
  5540      }
 
  5482    %}
 
  5541    %}
 
  5483    ins_pipe(iload_mem);
 
  5542    ins_pipe(iload_mem);
 
  5484 %}
 
  5543 %}
 
  5485 
  5544 
  5517      } else {
 
  5576      } else {
 
  5518        __ lduw(base, $mem$$disp, dst);
 
  5577        __ lduw(base, $mem$$disp, dst);
 
  5519      }
 
  5578      }
 
  5520   %}
 
  5579   %}
 
  5521   ins_pipe(iload_mem);
 
  5580   ins_pipe(iload_mem);
 
  5522 %}
 
       
  5523 
       
  5524 // Load Short (16bit signed)
 
       
  5525 instruct loadS(iRegI dst, memory mem) %{
 
       
  5526   match(Set dst (LoadS mem));
 
       
  5527   ins_cost(MEMORY_REF_COST);
 
       
  5528 
       
  5529   size(4);
 
       
  5530   format %{ "LDSH   $mem,$dst" %}
 
       
  5531   opcode(Assembler::ldsh_op3);
 
       
  5532   ins_encode(simple_form3_mem_reg( mem, dst ) );
 
       
  5533   ins_pipe(iload_mask_mem);
 
       
  5534 %}
 
  5581 %}
 
  5535 
  5582 
  5536 // Load Double
 
  5583 // Load Double
 
  5537 instruct loadD(regD dst, memory mem) %{
 
  5584 instruct loadD(regD dst, memory mem) %{
 
  5538   match(Set dst (LoadD mem));
 
  5585   match(Set dst (LoadD mem));
jdk-sandbox