Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/cpu/sparc/vm/sparc.ad

src/cpu/sparc/vm/sparc.ad

changeset 1059
337400e7a5dd
parent 1040
98cb887364d3
child 1063
7bb995fbd3c0
child 1077
660978a2a31a
equal deleted inserted replaced
1058:9adddb8c0fc8 1059:337400e7a5dd
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));

Mercurial Repository: jdk8-mips64-public/hotspot

mercurial