hotspot/src/cpu/x86/vm/templateTable_x86_64.cpp
author xdono
Wed, 02 Jul 2008 12:55:16 -0700
changeset 670 ddf3e9583f2f
parent 593 803947e176bd
child 1388 3677f5f3d66b
child 1066 717c3345024f
permissions -rw-r--r--
6719955: Update copyright year Summary: Update copyright year for files that have been modified in 2008 Reviewed-by: ohair, tbell
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
670
ddf3e9583f2f 6719955: Update copyright year
xdono
parents: 593
diff changeset
     2
 * Copyright 2003-2008 Sun Microsystems, Inc.  All Rights Reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    19
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    20
 * CA 95054 USA or visit www.sun.com if you need additional information or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    21
 * have any questions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
489c9b5090e2 Initial load
duke
parents:
diff changeset
    25
#include "incls/_precompiled.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    26
#include "incls/_templateTable_x86_64.cpp.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    27
489c9b5090e2 Initial load
duke
parents:
diff changeset
    28
#define __ _masm->
489c9b5090e2 Initial load
duke
parents:
diff changeset
    29
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
// Platform-dependent initialization
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
void TemplateTable::pd_initialize() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
  // No amd64 specific initialization
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
// Address computation: local variables
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
static inline Address iaddress(int n) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
  return Address(r14, Interpreter::local_offset_in_bytes(n));
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
static inline Address laddress(int n) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
  return iaddress(n + 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
static inline Address faddress(int n) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
  return iaddress(n);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
static inline Address daddress(int n) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
  return laddress(n);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
static inline Address aaddress(int n) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
  return iaddress(n);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
static inline Address iaddress(Register r) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  return Address(r14, r, Address::times_8, Interpreter::value_offset_in_bytes());
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
static inline Address laddress(Register r) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
  return Address(r14, r, Address::times_8, Interpreter::local_offset_in_bytes(1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
static inline Address faddress(Register r) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  return iaddress(r);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
static inline Address daddress(Register r) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
  return laddress(r);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
static inline Address aaddress(Register r) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  return iaddress(r);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
static inline Address at_rsp() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  return Address(rsp, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
// At top of Java expression stack which may be different than esp().  It
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
// isn't for category 1 objects.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
static inline Address at_tos   () {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  return Address(rsp,  Interpreter::expr_offset_in_bytes(0));
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
static inline Address at_tos_p1() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
  return Address(rsp,  Interpreter::expr_offset_in_bytes(1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
static inline Address at_tos_p2() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  return Address(rsp,  Interpreter::expr_offset_in_bytes(2));
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
static inline Address at_tos_p3() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  return Address(rsp,  Interpreter::expr_offset_in_bytes(3));
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
// Condition conversion
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
static Assembler::Condition j_not(TemplateTable::Condition cc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  switch (cc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  case TemplateTable::equal        : return Assembler::notEqual;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  case TemplateTable::not_equal    : return Assembler::equal;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  case TemplateTable::less         : return Assembler::greaterEqual;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  case TemplateTable::less_equal   : return Assembler::greater;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  case TemplateTable::greater      : return Assembler::lessEqual;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  case TemplateTable::greater_equal: return Assembler::less;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
  return Assembler::zero;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
// Miscelaneous helper routines
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
Address TemplateTable::at_bcp(int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
  assert(_desc->uses_bcp(), "inconsistent uses_bcp information");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  return Address(r13, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
void TemplateTable::patch_bytecode(Bytecodes::Code bytecode, Register bc,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
                                   Register scratch,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
                                   bool load_bc_into_scratch/*=true*/) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  if (!RewriteBytecodes) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  // the pair bytecodes have already done the load.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  if (load_bc_into_scratch) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
    __ movl(bc, bytecode);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  Label patch_done;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  if (JvmtiExport::can_post_breakpoint()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
    Label fast_patch;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
    // if a breakpoint is present we can't rewrite the stream directly
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
    __ movzbl(scratch, at_bcp(0));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
    __ cmpl(scratch, Bytecodes::_breakpoint);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
    __ jcc(Assembler::notEqual, fast_patch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
    __ get_method(scratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
    // Let breakpoint table handling rewrite to quicker bytecode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
    __ call_VM(noreg,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
               CAST_FROM_FN_PTR(address,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
                                InterpreterRuntime::set_original_bytecode_at),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
               scratch, r13, bc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
#ifndef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
    __ jmpb(patch_done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
    __ bind(fast_patch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
    __ jmp(patch_done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
    __ bind(fast_patch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  Label okay;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  __ load_unsigned_byte(scratch, at_bcp(0));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  __ cmpl(scratch, (int) Bytecodes::java_code(bytecode));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  __ jcc(Assembler::equal, okay);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  __ cmpl(scratch, bc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  __ jcc(Assembler::equal, okay);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  __ stop("patching the wrong bytecode");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  __ bind(okay);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  // patch bytecode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  __ movb(at_bcp(0), bc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  __ bind(patch_done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
// Individual instructions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
void TemplateTable::nop() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  // nothing to do
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
void TemplateTable::shouldnotreachhere() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  __ stop("shouldnotreachhere bytecode");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
void TemplateTable::aconst_null() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  transition(vtos, atos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  __ xorl(rax, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
void TemplateTable::iconst(int value) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
  transition(vtos, itos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  if (value == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
    __ xorl(rax, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
    __ movl(rax, value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
void TemplateTable::lconst(int value) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  transition(vtos, ltos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
  if (value == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
    __ xorl(rax, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
    __ movl(rax, value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
void TemplateTable::fconst(int value) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  transition(vtos, ftos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  static float one = 1.0f, two = 2.0f;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  switch (value) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
  case 0:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
    __ xorps(xmm0, xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
  case 1:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
    __ movflt(xmm0, ExternalAddress((address) &one));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
  case 2:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
    __ movflt(xmm0, ExternalAddress((address) &two));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
    ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
void TemplateTable::dconst(int value) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  transition(vtos, dtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
  static double one = 1.0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
  switch (value) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
  case 0:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
    __ xorpd(xmm0, xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  case 1:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
    __ movdbl(xmm0, ExternalAddress((address) &one));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
  default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
    ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
void TemplateTable::bipush() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  transition(vtos, itos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
  __ load_signed_byte(rax, at_bcp(1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
void TemplateTable::sipush() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
  transition(vtos, itos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  __ load_unsigned_word(rax, at_bcp(1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
  __ bswapl(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
  __ sarl(rax, 16);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
void TemplateTable::ldc(bool wide) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
  Label call_ldc, notFloat, notClass, Done;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
  if (wide) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
    __ get_unsigned_2_byte_index_at_bcp(rbx, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
    __ load_unsigned_byte(rbx, at_bcp(1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
  __ get_cpool_and_tags(rcx, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  const int base_offset = constantPoolOopDesc::header_size() * wordSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
  const int tags_offset = typeArrayOopDesc::header_size(T_BYTE) * wordSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
  // get type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
  __ movzbl(rdx, Address(rax, rbx, Address::times_1, tags_offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
  // unresolved string - get the resolved string
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
  __ cmpl(rdx, JVM_CONSTANT_UnresolvedString);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  __ jccb(Assembler::equal, call_ldc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
  // unresolved class - get the resolved class
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
  __ cmpl(rdx, JVM_CONSTANT_UnresolvedClass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
  __ jccb(Assembler::equal, call_ldc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
  // unresolved class in error state - call into runtime to throw the error
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
  // from the first resolution attempt
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
  __ cmpl(rdx, JVM_CONSTANT_UnresolvedClassInError);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
  __ jccb(Assembler::equal, call_ldc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
  // resolved class - need to call vm to get java mirror of the class
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
  __ cmpl(rdx, JVM_CONSTANT_Class);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
  __ jcc(Assembler::notEqual, notClass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
  __ bind(call_ldc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
  __ movl(c_rarg1, wide);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
  call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::ldc), c_rarg1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
  __ push_ptr(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
  __ verify_oop(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
  __ jmp(Done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
  __ bind(notClass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
  __ cmpl(rdx, JVM_CONSTANT_Float);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
  __ jccb(Assembler::notEqual, notFloat);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
  // ftos
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  __ movflt(xmm0, Address(rcx, rbx, Address::times_8, base_offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
  __ push_f();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  __ jmp(Done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  __ bind(notFloat);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
    Label L;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
    __ cmpl(rdx, JVM_CONSTANT_Integer);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
    __ jcc(Assembler::equal, L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
    __ cmpl(rdx, JVM_CONSTANT_String);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
    __ jcc(Assembler::equal, L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
    __ stop("unexpected tag type in ldc");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
    __ bind(L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
  // atos and itos
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
  Label isOop;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
  __ cmpl(rdx, JVM_CONSTANT_Integer);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
  __ jcc(Assembler::notEqual, isOop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
  __ movl(rax, Address(rcx, rbx, Address::times_8, base_offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  __ push_i(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
  __ jmp(Done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
  __ bind(isOop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
  __ movq(rax, Address(rcx, rbx, Address::times_8, base_offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  __ push_ptr(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
  if (VerifyOops) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
    __ verify_oop(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  __ bind(Done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
void TemplateTable::ldc2_w() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
  Label Long, Done;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
  __ get_unsigned_2_byte_index_at_bcp(rbx, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
  __ get_cpool_and_tags(rcx, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
  const int base_offset = constantPoolOopDesc::header_size() * wordSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  const int tags_offset = typeArrayOopDesc::header_size(T_BYTE) * wordSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
  // get type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  __ cmpb(Address(rax, rbx, Address::times_1, tags_offset),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
          JVM_CONSTANT_Double);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  __ jccb(Assembler::notEqual, Long);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  // dtos
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  __ movdbl(xmm0, Address(rcx, rbx, Address::times_8, base_offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  __ push_d();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
  __ jmpb(Done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
  __ bind(Long);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
  // ltos
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
  __ movq(rax, Address(rcx, rbx, Address::times_8, base_offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
  __ push_l();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
  __ bind(Done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
void TemplateTable::locals_index(Register reg, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
  __ load_unsigned_byte(reg, at_bcp(offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
  __ negq(reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
  if (TaggedStackInterpreter) __ shlq(reg, 1);  // index = index*2
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
void TemplateTable::iload() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
  transition(vtos, itos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
  if (RewriteFrequentPairs) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
    Label rewrite, done;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
    const Register bc = c_rarg3;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
    assert(rbx != bc, "register damaged");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
    // get next byte
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
    __ load_unsigned_byte(rbx,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
                          at_bcp(Bytecodes::length_for(Bytecodes::_iload)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
    // if _iload, wait to rewrite to iload2.  We only want to rewrite the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
    // last two iloads in a pair.  Comparing against fast_iload means that
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
    // the next bytecode is neither an iload or a caload, and therefore
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
    // an iload pair.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
    __ cmpl(rbx, Bytecodes::_iload);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
    __ jcc(Assembler::equal, done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
    __ cmpl(rbx, Bytecodes::_fast_iload);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
    __ movl(bc, Bytecodes::_fast_iload2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
    __ jccb(Assembler::equal, rewrite);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
    // if _caload, rewrite to fast_icaload
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
    __ cmpl(rbx, Bytecodes::_caload);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
    __ movl(bc, Bytecodes::_fast_icaload);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
    __ jccb(Assembler::equal, rewrite);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
    // rewrite so iload doesn't check again.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
    __ movl(bc, Bytecodes::_fast_iload);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
    // rewrite
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
    // bc: fast bytecode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
    __ bind(rewrite);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
    patch_bytecode(Bytecodes::_iload, bc, rbx, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
    __ bind(done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  // Get the local value into tos
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
  locals_index(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
  __ movl(rax, iaddress(rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
  debug_only(__ verify_local_tag(frame::TagValue, rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
void TemplateTable::fast_iload2() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
  transition(vtos, itos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
  locals_index(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
  __ movl(rax, iaddress(rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
  debug_only(__ verify_local_tag(frame::TagValue, rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
  __ push(itos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
  locals_index(rbx, 3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
  __ movl(rax, iaddress(rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
  debug_only(__ verify_local_tag(frame::TagValue, rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
void TemplateTable::fast_iload() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
  transition(vtos, itos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  locals_index(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
  __ movl(rax, iaddress(rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
  debug_only(__ verify_local_tag(frame::TagValue, rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
void TemplateTable::lload() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
  transition(vtos, ltos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
  locals_index(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
  __ movq(rax, laddress(rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
  debug_only(__ verify_local_tag(frame::TagCategory2, rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
void TemplateTable::fload() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
  transition(vtos, ftos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
  locals_index(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
  __ movflt(xmm0, faddress(rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
  debug_only(__ verify_local_tag(frame::TagValue, rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
void TemplateTable::dload() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
  transition(vtos, dtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
  locals_index(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
  __ movdbl(xmm0, daddress(rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
  debug_only(__ verify_local_tag(frame::TagCategory2, rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
void TemplateTable::aload() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
  transition(vtos, atos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
  locals_index(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
  __ movq(rax, aaddress(rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  debug_only(__ verify_local_tag(frame::TagReference, rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
void TemplateTable::locals_index_wide(Register reg) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
  __ movl(reg, at_bcp(2));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
  __ bswapl(reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
  __ shrl(reg, 16);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
  __ negq(reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
  if (TaggedStackInterpreter) __ shlq(reg, 1);  // index = index*2
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
void TemplateTable::wide_iload() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
  transition(vtos, itos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
  locals_index_wide(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
  __ movl(rax, iaddress(rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
  debug_only(__ verify_local_tag(frame::TagValue, rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
void TemplateTable::wide_lload() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
  transition(vtos, ltos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
  locals_index_wide(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
  __ movq(rax, laddress(rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
  debug_only(__ verify_local_tag(frame::TagCategory2, rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
void TemplateTable::wide_fload() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
  transition(vtos, ftos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
  locals_index_wide(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
  __ movflt(xmm0, faddress(rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
  debug_only(__ verify_local_tag(frame::TagValue, rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
void TemplateTable::wide_dload() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
  transition(vtos, dtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
  locals_index_wide(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
  __ movdbl(xmm0, daddress(rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
  debug_only(__ verify_local_tag(frame::TagCategory2, rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
void TemplateTable::wide_aload() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
  transition(vtos, atos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
  locals_index_wide(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
  __ movq(rax, aaddress(rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
  debug_only(__ verify_local_tag(frame::TagReference, rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
void TemplateTable::index_check(Register array, Register index) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
  // destroys rbx
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
  // check array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
  __ null_check(array, arrayOopDesc::length_offset_in_bytes());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
  // sign extend index for use by indexed load
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
  __ movslq(index, index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
  // check index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
  __ cmpl(index, Address(array, arrayOopDesc::length_offset_in_bytes()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
  if (index != rbx) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
    // ??? convention: move aberrant index into ebx for exception message
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
    assert(rbx != array, "different registers");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
    __ movl(rbx, index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
  __ jump_cc(Assembler::aboveEqual,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
             ExternalAddress(Interpreter::_throw_ArrayIndexOutOfBoundsException_entry));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
void TemplateTable::iaload() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
  transition(itos, itos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
  __ pop_ptr(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
  // eax: index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
  // rdx: array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
  index_check(rdx, rax); // kills rbx
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
  __ movl(rax, Address(rdx, rax,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
                       Address::times_4,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
                       arrayOopDesc::base_offset_in_bytes(T_INT)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
void TemplateTable::laload() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
  transition(itos, ltos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
  __ pop_ptr(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
  // eax: index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
  // rdx: array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
  index_check(rdx, rax); // kills rbx
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
  __ movq(rax, Address(rdx, rbx,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
                       Address::times_8,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
                       arrayOopDesc::base_offset_in_bytes(T_LONG)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
void TemplateTable::faload() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
  transition(itos, ftos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
  __ pop_ptr(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
  // eax: index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
  // rdx: array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
  index_check(rdx, rax); // kills rbx
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
  __ movflt(xmm0, Address(rdx, rax,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
                         Address::times_4,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
                         arrayOopDesc::base_offset_in_bytes(T_FLOAT)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
void TemplateTable::daload() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
  transition(itos, dtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
  __ pop_ptr(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
  // eax: index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
  // rdx: array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
  index_check(rdx, rax); // kills rbx
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
  __ movdbl(xmm0, Address(rdx, rax,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
                          Address::times_8,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
                          arrayOopDesc::base_offset_in_bytes(T_DOUBLE)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
void TemplateTable::aaload() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
  transition(itos, atos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  __ pop_ptr(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
  // eax: index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
  // rdx: array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
  index_check(rdx, rax); // kills rbx
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   560
  __ load_heap_oop(rax, Address(rdx, rax,
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   561
                       UseCompressedOops ? Address::times_4 : Address::times_8,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
                       arrayOopDesc::base_offset_in_bytes(T_OBJECT)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
void TemplateTable::baload() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
  transition(itos, itos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
  __ pop_ptr(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
  // eax: index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
  // rdx: array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
  index_check(rdx, rax); // kills rbx
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
  __ load_signed_byte(rax,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
                      Address(rdx, rax,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
                              Address::times_1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
                              arrayOopDesc::base_offset_in_bytes(T_BYTE)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
void TemplateTable::caload() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
  transition(itos, itos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
  __ pop_ptr(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
  // eax: index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
  // rdx: array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
  index_check(rdx, rax); // kills rbx
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
  __ load_unsigned_word(rax,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
                        Address(rdx, rax,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
                                Address::times_2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
                                arrayOopDesc::base_offset_in_bytes(T_CHAR)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
// iload followed by caload frequent pair
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
void TemplateTable::fast_icaload() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
  transition(vtos, itos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
  // load index out of locals
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
  locals_index(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
  __ movl(rax, iaddress(rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
  debug_only(__ verify_local_tag(frame::TagValue, rbx));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
  // eax: index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
  // rdx: array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
  __ pop_ptr(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
  index_check(rdx, rax); // kills rbx
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
  __ load_unsigned_word(rax,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
                        Address(rdx, rax,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
                                Address::times_2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
                                arrayOopDesc::base_offset_in_bytes(T_CHAR)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
void TemplateTable::saload() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
  transition(itos, itos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
  __ pop_ptr(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
  // eax: index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
  // rdx: array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
  index_check(rdx, rax); // kills rbx
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
  __ load_signed_word(rax,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
                      Address(rdx, rax,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
                              Address::times_2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
                              arrayOopDesc::base_offset_in_bytes(T_SHORT)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
void TemplateTable::iload(int n) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
  transition(vtos, itos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
  __ movl(rax, iaddress(n));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
  debug_only(__ verify_local_tag(frame::TagValue, n));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
void TemplateTable::lload(int n) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
  transition(vtos, ltos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
  __ movq(rax, laddress(n));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
  debug_only(__ verify_local_tag(frame::TagCategory2, n));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
void TemplateTable::fload(int n) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
  transition(vtos, ftos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
  __ movflt(xmm0, faddress(n));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
  debug_only(__ verify_local_tag(frame::TagValue, n));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
void TemplateTable::dload(int n) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
  transition(vtos, dtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
  __ movdbl(xmm0, daddress(n));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
  debug_only(__ verify_local_tag(frame::TagCategory2, n));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
void TemplateTable::aload(int n) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
  transition(vtos, atos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
  __ movq(rax, aaddress(n));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
  debug_only(__ verify_local_tag(frame::TagReference, n));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
void TemplateTable::aload_0() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
  transition(vtos, atos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
  // According to bytecode histograms, the pairs:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
  // _aload_0, _fast_igetfield
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
  // _aload_0, _fast_agetfield
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
  // _aload_0, _fast_fgetfield
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
  // occur frequently. If RewriteFrequentPairs is set, the (slow)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
  // _aload_0 bytecode checks if the next bytecode is either
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
  // _fast_igetfield, _fast_agetfield or _fast_fgetfield and then
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
  // rewrites the current bytecode into a pair bytecode; otherwise it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
  // rewrites the current bytecode into _fast_aload_0 that doesn't do
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
  // the pair check anymore.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
  // Note: If the next bytecode is _getfield, the rewrite must be
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
  //       delayed, otherwise we may miss an opportunity for a pair.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
  // Also rewrite frequent pairs
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
  //   aload_0, aload_1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
  //   aload_0, iload_1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
  // These bytecodes with a small amount of code are most profitable
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
  // to rewrite
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
  if (RewriteFrequentPairs) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
    Label rewrite, done;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
    const Register bc = c_rarg3;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
    assert(rbx != bc, "register damaged");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
    // get next byte
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
    __ load_unsigned_byte(rbx,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
                          at_bcp(Bytecodes::length_for(Bytecodes::_aload_0)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
    // do actual aload_0
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
    aload(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
    // if _getfield then wait with rewrite
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
    __ cmpl(rbx, Bytecodes::_getfield);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
    __ jcc(Assembler::equal, done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
    // if _igetfield then reqrite to _fast_iaccess_0
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
    assert(Bytecodes::java_code(Bytecodes::_fast_iaccess_0) ==
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
           Bytecodes::_aload_0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
           "fix bytecode definition");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
    __ cmpl(rbx, Bytecodes::_fast_igetfield);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
    __ movl(bc, Bytecodes::_fast_iaccess_0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
    __ jccb(Assembler::equal, rewrite);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
    // if _agetfield then reqrite to _fast_aaccess_0
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
    assert(Bytecodes::java_code(Bytecodes::_fast_aaccess_0) ==
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
           Bytecodes::_aload_0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
           "fix bytecode definition");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
    __ cmpl(rbx, Bytecodes::_fast_agetfield);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
    __ movl(bc, Bytecodes::_fast_aaccess_0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
    __ jccb(Assembler::equal, rewrite);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
    // if _fgetfield then reqrite to _fast_faccess_0
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
    assert(Bytecodes::java_code(Bytecodes::_fast_faccess_0) ==
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
           Bytecodes::_aload_0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
           "fix bytecode definition");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
    __ cmpl(rbx, Bytecodes::_fast_fgetfield);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
    __ movl(bc, Bytecodes::_fast_faccess_0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
    __ jccb(Assembler::equal, rewrite);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
    // else rewrite to _fast_aload0
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
    assert(Bytecodes::java_code(Bytecodes::_fast_aload_0) ==
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
           Bytecodes::_aload_0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
           "fix bytecode definition");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
    __ movl(bc, Bytecodes::_fast_aload_0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
    // rewrite
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
    // bc: fast bytecode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
    __ bind(rewrite);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
    patch_bytecode(Bytecodes::_aload_0, bc, rbx, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
    __ bind(done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
    aload(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
void TemplateTable::istore() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
  transition(itos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
  locals_index(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
  __ movl(iaddress(rbx), rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
  __ tag_local(frame::TagValue, rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
void TemplateTable::lstore() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
  transition(ltos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
  locals_index(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
  __ movq(laddress(rbx), rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
  __ tag_local(frame::TagCategory2, rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
void TemplateTable::fstore() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
  transition(ftos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
  locals_index(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
  __ movflt(faddress(rbx), xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
  __ tag_local(frame::TagValue, rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
void TemplateTable::dstore() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
  transition(dtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
  locals_index(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
  __ movdbl(daddress(rbx), xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
  __ tag_local(frame::TagCategory2, rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
void TemplateTable::astore() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
  __ pop_ptr(rax, rdx);    // will need to pop tag too
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
  locals_index(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
  __ movq(aaddress(rbx), rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
  __ tag_local(rdx, rbx);  // store tag from stack, might be returnAddr
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
void TemplateTable::wide_istore() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
  __ pop_i();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
  locals_index_wide(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
  __ movl(iaddress(rbx), rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
  __ tag_local(frame::TagValue, rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
void TemplateTable::wide_lstore() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
  __ pop_l();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
  locals_index_wide(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
  __ movq(laddress(rbx), rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
  __ tag_local(frame::TagCategory2, rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
void TemplateTable::wide_fstore() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
  __ pop_f();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
  locals_index_wide(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
  __ movflt(faddress(rbx), xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
  __ tag_local(frame::TagValue, rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
void TemplateTable::wide_dstore() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
  __ pop_d();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
  locals_index_wide(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
  __ movdbl(daddress(rbx), xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
  __ tag_local(frame::TagCategory2, rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
void TemplateTable::wide_astore() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
  __ pop_ptr(rax, rdx);    // will need to pop tag too
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
  locals_index_wide(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
  __ movq(aaddress(rbx), rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
  __ tag_local(rdx, rbx);  // store tag from stack, might be returnAddr
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
void TemplateTable::iastore() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
  transition(itos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
  __ pop_i(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
  __ pop_ptr(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
  // eax: value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
  // ebx: index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
  // rdx: array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
  index_check(rdx, rbx); // prefer index in ebx
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
  __ movl(Address(rdx, rbx,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
                  Address::times_4,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
                  arrayOopDesc::base_offset_in_bytes(T_INT)),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
          rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
void TemplateTable::lastore() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
  transition(ltos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
  __ pop_i(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
  __ pop_ptr(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
  // rax: value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
  // ebx: index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
  // rdx: array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
  index_check(rdx, rbx); // prefer index in ebx
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
  __ movq(Address(rdx, rbx,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
                  Address::times_8,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
                  arrayOopDesc::base_offset_in_bytes(T_LONG)),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
          rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
void TemplateTable::fastore() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
  transition(ftos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
  __ pop_i(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
  __ pop_ptr(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
  // xmm0: value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
  // ebx:  index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
  // rdx:  array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
  index_check(rdx, rbx); // prefer index in ebx
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
  __ movflt(Address(rdx, rbx,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
                   Address::times_4,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
                   arrayOopDesc::base_offset_in_bytes(T_FLOAT)),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
           xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
void TemplateTable::dastore() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
  transition(dtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
  __ pop_i(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
  __ pop_ptr(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
  // xmm0: value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
  // ebx:  index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
  // rdx:  array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
  index_check(rdx, rbx); // prefer index in ebx
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
  __ movdbl(Address(rdx, rbx,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
                   Address::times_8,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
                   arrayOopDesc::base_offset_in_bytes(T_DOUBLE)),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
           xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
void TemplateTable::aastore() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
  Label is_null, ok_is_subtype, done;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
  // stack: ..., array, index, value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
  __ movq(rax, at_tos());    // value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
  __ movl(rcx, at_tos_p1()); // index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
  __ movq(rdx, at_tos_p2()); // array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
  index_check(rdx, rcx);     // kills rbx
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
  // do array store check - check for NULL value first
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
  __ testq(rax, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
  __ jcc(Assembler::zero, is_null);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
  // Move subklass into rbx
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   873
  __ load_klass(rbx, rax);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
  // Move superklass into rax
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   875
  __ load_klass(rax, rdx);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
  __ movq(rax, Address(rax,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
                       sizeof(oopDesc) +
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
                       objArrayKlass::element_klass_offset_in_bytes()));
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   879
  // Compress array + index*oopSize + 12 into a single register.  Frees rcx.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
  __ leaq(rdx, Address(rdx, rcx,
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   881
                       UseCompressedOops ? Address::times_4 : Address::times_8,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
                       arrayOopDesc::base_offset_in_bytes(T_OBJECT)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
  // Generate subtype check.  Blows rcx, rdi
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
  // Superklass in rax.  Subklass in rbx.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
  __ gen_subtype_check(rbx, ok_is_subtype);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
  // Come here on failure
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
  // object is at TOS
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
  __ jump(ExternalAddress(Interpreter::_throw_ArrayStoreException_entry));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
  // Come here on success
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
  __ bind(ok_is_subtype);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
  __ movq(rax, at_tos()); // Value
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   895
  __ store_heap_oop(Address(rdx, 0), rax);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
  __ store_check(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
  __ jmp(done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
  // Have a NULL in rax, rdx=array, ecx=index.  Store NULL at ary[idx]
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
  __ bind(is_null);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
  __ profile_null_seen(rbx);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   902
  __ store_heap_oop(Address(rdx, rcx,
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   903
                            UseCompressedOops ? Address::times_4 : Address::times_8,
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   904
                            arrayOopDesc::base_offset_in_bytes(T_OBJECT)),
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   905
                    rax);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
  // Pop stack arguments
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
  __ bind(done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
  __ addq(rsp, 3 * Interpreter::stackElementSize());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
void TemplateTable::bastore() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
  transition(itos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
  __ pop_i(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
  __ pop_ptr(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
  // eax: value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
  // ebx: index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
  // rdx: array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   919
  index_check(rdx, rbx); // prefer index in ebx
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
  __ movb(Address(rdx, rbx,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
                  Address::times_1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
                  arrayOopDesc::base_offset_in_bytes(T_BYTE)),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
          rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
void TemplateTable::castore() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
  transition(itos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
  __ pop_i(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
  __ pop_ptr(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
  // eax: value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
  // ebx: index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
  // rdx: array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
  index_check(rdx, rbx);  // prefer index in ebx
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
  __ movw(Address(rdx, rbx,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
                  Address::times_2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
                  arrayOopDesc::base_offset_in_bytes(T_CHAR)),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   937
          rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   938
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   939
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
void TemplateTable::sastore() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
  castore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
489c9b5090e2 Initial load
duke
parents:
diff changeset
   944
void TemplateTable::istore(int n) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
  transition(itos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   946
  __ movl(iaddress(n), rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   947
  __ tag_local(frame::TagValue, n);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   948
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   949
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
void TemplateTable::lstore(int n) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
  transition(ltos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   952
  __ movq(laddress(n), rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   953
  __ tag_local(frame::TagCategory2, n);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   955
489c9b5090e2 Initial load
duke
parents:
diff changeset
   956
void TemplateTable::fstore(int n) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
  transition(ftos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
  __ movflt(faddress(n), xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
  __ tag_local(frame::TagValue, n);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   960
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
void TemplateTable::dstore(int n) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
  transition(dtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
  __ movdbl(daddress(n), xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
  __ tag_local(frame::TagCategory2, n);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   967
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
void TemplateTable::astore(int n) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
  __ pop_ptr(rax, rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
  __ movq(aaddress(n), rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
  __ tag_local(rdx, n);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
void TemplateTable::pop() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   976
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
  __ addq(rsp, Interpreter::stackElementSize());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
void TemplateTable::pop2() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
  __ addq(rsp, 2 * Interpreter::stackElementSize());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
void TemplateTable::dup() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
  __ load_ptr_and_tag(0, rax, rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
  __ push_ptr(rax, rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
  // stack: ..., a, a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
void TemplateTable::dup_x1() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
  // stack: ..., a, b
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
  __ load_ptr_and_tag(0, rax, rdx);  // load b
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
  __ load_ptr_and_tag(1, rcx, rbx);  // load a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
  __ store_ptr_and_tag(1, rax, rdx); // store b
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
  __ store_ptr_and_tag(0, rcx, rbx); // store a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
  __ push_ptr(rax, rdx);             // push b
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
  // stack: ..., b, a, b
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
void TemplateTable::dup_x2() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
  // stack: ..., a, b, c
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
  __ load_ptr_and_tag(0, rax, rdx);  // load c
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
  __ load_ptr_and_tag(2, rcx, rbx);  // load a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
  __ store_ptr_and_tag(2, rax, rdx); // store c in a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
  __ push_ptr(rax, rdx);             // push c
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
  // stack: ..., c, b, c, c
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
  __ load_ptr_and_tag(2, rax, rdx);  // load b
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
  __ store_ptr_and_tag(2, rcx, rbx); // store a in b
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
  // stack: ..., c, a, c, c
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
  __ store_ptr_and_tag(1, rax, rdx); // store b in c
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1015
  // stack: ..., c, a, b, c
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
void TemplateTable::dup2() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1020
  // stack: ..., a, b
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1021
  __ load_ptr_and_tag(1, rax, rdx);  // load a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
  __ push_ptr(rax, rdx);             // push a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
  __ load_ptr_and_tag(1, rax, rdx);  // load b
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
  __ push_ptr(rax, rdx);             // push b
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
  // stack: ..., a, b, a, b
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
void TemplateTable::dup2_x1() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
  // stack: ..., a, b, c
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
  __ load_ptr_and_tag(0, rcx, rbx);  // load c
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
  __ load_ptr_and_tag(1, rax, rdx);  // load b
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
  __ push_ptr(rax, rdx);             // push b
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
  __ push_ptr(rcx, rbx);             // push c
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
  // stack: ..., a, b, c, b, c
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
  __ store_ptr_and_tag(3, rcx, rbx); // store c in b
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
  // stack: ..., a, c, c, b, c
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
  __ load_ptr_and_tag(4, rcx, rbx);  // load a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
  __ store_ptr_and_tag(2, rcx, rbx); // store a in 2nd c
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
  // stack: ..., a, c, a, b, c
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
  __ store_ptr_and_tag(4, rax, rdx); // store b in a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
  // stack: ..., b, c, a, b, c
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1043
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
void TemplateTable::dup2_x2() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1046
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1047
  // stack: ..., a, b, c, d
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1048
  __ load_ptr_and_tag(0, rcx, rbx);  // load d
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1049
  __ load_ptr_and_tag(1, rax, rdx);  // load c
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1050
  __ push_ptr(rax, rdx);             // push c
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1051
  __ push_ptr(rcx, rbx);             // push d
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
  // stack: ..., a, b, c, d, c, d
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
  __ load_ptr_and_tag(4, rax, rdx);  // load b
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1054
  __ store_ptr_and_tag(2, rax, rdx); // store b in d
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1055
  __ store_ptr_and_tag(4, rcx, rbx); // store d in b
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1056
  // stack: ..., a, d, c, b, c, d
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
  __ load_ptr_and_tag(5, rcx, rbx);  // load a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
  __ load_ptr_and_tag(3, rax, rdx);  // load c
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
  __ store_ptr_and_tag(3, rcx, rbx); // store a in c
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
  __ store_ptr_and_tag(5, rax, rdx); // store c in a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
  // stack: ..., c, d, a, b, c, d
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
void TemplateTable::swap() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1065
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
  // stack: ..., a, b
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1067
  __ load_ptr_and_tag(1, rcx, rbx);  // load a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1068
  __ load_ptr_and_tag(0, rax, rdx);  // load b
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1069
  __ store_ptr_and_tag(0, rcx, rbx); // store a in b
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1070
  __ store_ptr_and_tag(1, rax, rdx); // store b in a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1071
  // stack: ..., b, a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1072
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1073
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1074
void TemplateTable::iop2(Operation op) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
  transition(itos, itos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
  switch (op) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1077
  case add  :                    __ pop_i(rdx); __ addl (rax, rdx); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
  case sub  : __ movl(rdx, rax); __ pop_i(rax); __ subl (rax, rdx); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
  case mul  :                    __ pop_i(rdx); __ imull(rax, rdx); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
  case _and :                    __ pop_i(rdx); __ andl (rax, rdx); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1081
  case _or  :                    __ pop_i(rdx); __ orl  (rax, rdx); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
  case _xor :                    __ pop_i(rdx); __ xorl (rax, rdx); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1083
  case shl  : __ movl(rcx, rax); __ pop_i(rax); __ shll (rax);      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1084
  case shr  : __ movl(rcx, rax); __ pop_i(rax); __ sarl (rax);      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1085
  case ushr : __ movl(rcx, rax); __ pop_i(rax); __ shrl (rax);      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1086
  default   : ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1087
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1089
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
void TemplateTable::lop2(Operation op) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
  transition(ltos, ltos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
  switch (op) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
  case add  :                    __ pop_l(rdx); __ addq (rax, rdx); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
  case sub  : __ movq(rdx, rax); __ pop_l(rax); __ subq (rax, rdx); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1095
  case _and :                    __ pop_l(rdx); __ andq (rax, rdx); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1096
  case _or  :                    __ pop_l(rdx); __ orq  (rax, rdx); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1097
  case _xor :                    __ pop_l(rdx); __ xorq (rax, rdx); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1098
  default : ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1099
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1100
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1101
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1102
void TemplateTable::idiv() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1103
  transition(itos, itos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1104
  __ movl(rcx, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1105
  __ pop_i(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1106
  // Note: could xor eax and ecx and compare with (-1 ^ min_int). If
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
  //       they are not equal, one could do a normal division (no correction
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1108
  //       needed), which may speed up this implementation for the common case.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1109
  //       (see also JVM spec., p.243 & p.271)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1110
  __ corrected_idivl(rcx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1111
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1112
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1113
void TemplateTable::irem() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1114
  transition(itos, itos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1115
  __ movl(rcx, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1116
  __ pop_i(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1117
  // Note: could xor eax and ecx and compare with (-1 ^ min_int). If
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1118
  //       they are not equal, one could do a normal division (no correction
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1119
  //       needed), which may speed up this implementation for the common case.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1120
  //       (see also JVM spec., p.243 & p.271)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1121
  __ corrected_idivl(rcx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1122
  __ movl(rax, rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1123
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1124
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1125
void TemplateTable::lmul() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1126
  transition(ltos, ltos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1127
  __ pop_l(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1128
  __ imulq(rax, rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1129
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1130
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1131
void TemplateTable::ldiv() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1132
  transition(ltos, ltos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1133
  __ movq(rcx, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1134
  __ pop_l(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1135
  // generate explicit div0 check
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1136
  __ testq(rcx, rcx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1137
  __ jump_cc(Assembler::zero,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1138
             ExternalAddress(Interpreter::_throw_ArithmeticException_entry));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1139
  // Note: could xor rax and rcx and compare with (-1 ^ min_int). If
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1140
  //       they are not equal, one could do a normal division (no correction
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1141
  //       needed), which may speed up this implementation for the common case.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1142
  //       (see also JVM spec., p.243 & p.271)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1143
  __ corrected_idivq(rcx); // kills rbx
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1144
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1145
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1146
void TemplateTable::lrem() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1147
  transition(ltos, ltos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1148
  __ movq(rcx, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1149
  __ pop_l(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1150
  __ testq(rcx, rcx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1151
  __ jump_cc(Assembler::zero,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1152
             ExternalAddress(Interpreter::_throw_ArithmeticException_entry));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1153
  // Note: could xor rax and rcx and compare with (-1 ^ min_int). If
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1154
  //       they are not equal, one could do a normal division (no correction
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1155
  //       needed), which may speed up this implementation for the common case.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1156
  //       (see also JVM spec., p.243 & p.271)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1157
  __ corrected_idivq(rcx); // kills rbx
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1158
  __ movq(rax, rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1159
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1160
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1161
void TemplateTable::lshl() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1162
  transition(itos, ltos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1163
  __ movl(rcx, rax);                             // get shift count
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1164
  __ pop_l(rax);                                 // get shift value
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1165
  __ shlq(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1166
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1167
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1168
void TemplateTable::lshr() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1169
  transition(itos, ltos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1170
  __ movl(rcx, rax);                             // get shift count
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1171
  __ pop_l(rax);                                 // get shift value
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1172
  __ sarq(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1173
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1174
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1175
void TemplateTable::lushr() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1176
  transition(itos, ltos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1177
  __ movl(rcx, rax);                             // get shift count
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1178
  __ pop_l(rax);                                 // get shift value
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1179
  __ shrq(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1180
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1181
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1182
void TemplateTable::fop2(Operation op) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1183
  transition(ftos, ftos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1184
  switch (op) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1185
  case add:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1186
    __ addss(xmm0, at_rsp());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1187
    __ addq(rsp, Interpreter::stackElementSize());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1188
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1189
  case sub:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1190
    __ movflt(xmm1, xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1191
    __ pop_f(xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1192
    __ subss(xmm0, xmm1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1193
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1194
  case mul:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1195
    __ mulss(xmm0, at_rsp());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1196
    __ addq(rsp, Interpreter::stackElementSize());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1197
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1198
  case div:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1199
    __ movflt(xmm1, xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1200
    __ pop_f(xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1201
    __ divss(xmm0, xmm1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1202
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1203
  case rem:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1204
    __ movflt(xmm1, xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1205
    __ pop_f(xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1206
    __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::frem), 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1207
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1208
  default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1209
    ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1210
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1211
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1212
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1213
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1214
void TemplateTable::dop2(Operation op) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1215
  transition(dtos, dtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1216
  switch (op) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1217
  case add:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1218
    __ addsd(xmm0, at_rsp());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1219
    __ addq(rsp, 2 * Interpreter::stackElementSize());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1220
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1221
  case sub:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1222
    __ movdbl(xmm1, xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1223
    __ pop_d(xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1224
    __ subsd(xmm0, xmm1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1225
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1226
  case mul:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1227
    __ mulsd(xmm0, at_rsp());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1228
    __ addq(rsp, 2 * Interpreter::stackElementSize());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1229
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1230
  case div:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1231
    __ movdbl(xmm1, xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1232
    __ pop_d(xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1233
    __ divsd(xmm0, xmm1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1234
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1235
  case rem:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1236
    __ movdbl(xmm1, xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1237
    __ pop_d(xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1238
    __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::drem), 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1239
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1240
  default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1241
    ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1242
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1243
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1244
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1245
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1246
void TemplateTable::ineg() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1247
  transition(itos, itos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1248
  __ negl(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1249
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1250
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1251
void TemplateTable::lneg() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1252
  transition(ltos, ltos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1253
  __ negq(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1254
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1255
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1256
// Note: 'double' and 'long long' have 32-bits alignment on x86.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1257
static jlong* double_quadword(jlong *adr, jlong lo, jlong hi) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1258
  // Use the expression (adr)&(~0xF) to provide 128-bits aligned address
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1259
  // of 128-bits operands for SSE instructions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1260
  jlong *operand = (jlong*)(((intptr_t)adr)&((intptr_t)(~0xF)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1261
  // Store the value to a 128-bits operand.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1262
  operand[0] = lo;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1263
  operand[1] = hi;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1264
  return operand;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1265
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1266
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1267
// Buffer for 128-bits masks used by SSE instructions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1268
static jlong float_signflip_pool[2*2];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1269
static jlong double_signflip_pool[2*2];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1270
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1271
void TemplateTable::fneg() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1272
  transition(ftos, ftos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1273
  static jlong *float_signflip  = double_quadword(&float_signflip_pool[1], 0x8000000080000000, 0x8000000080000000);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1274
  __ xorps(xmm0, ExternalAddress((address) float_signflip));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1275
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1276
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1277
void TemplateTable::dneg() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1278
  transition(dtos, dtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1279
  static jlong *double_signflip  = double_quadword(&double_signflip_pool[1], 0x8000000000000000, 0x8000000000000000);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1280
  __ xorpd(xmm0, ExternalAddress((address) double_signflip));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1281
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1282
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1283
void TemplateTable::iinc() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1284
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1285
  __ load_signed_byte(rdx, at_bcp(2)); // get constant
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1286
  locals_index(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1287
  __ addl(iaddress(rbx), rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1288
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1289
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1290
void TemplateTable::wide_iinc() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1291
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1292
  __ movl(rdx, at_bcp(4)); // get constant
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1293
  locals_index_wide(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1294
  __ bswapl(rdx); // swap bytes & sign-extend constant
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1295
  __ sarl(rdx, 16);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1296
  __ addl(iaddress(rbx), rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1297
  // Note: should probably use only one movl to get both
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1298
  //       the index and the constant -> fix this
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1299
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1300
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1301
void TemplateTable::convert() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1302
  // Checking
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1303
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1304
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1305
    TosState tos_in  = ilgl;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1306
    TosState tos_out = ilgl;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1307
    switch (bytecode()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1308
    case Bytecodes::_i2l: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1309
    case Bytecodes::_i2f: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1310
    case Bytecodes::_i2d: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1311
    case Bytecodes::_i2b: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1312
    case Bytecodes::_i2c: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1313
    case Bytecodes::_i2s: tos_in = itos; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1314
    case Bytecodes::_l2i: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1315
    case Bytecodes::_l2f: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1316
    case Bytecodes::_l2d: tos_in = ltos; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1317
    case Bytecodes::_f2i: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1318
    case Bytecodes::_f2l: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1319
    case Bytecodes::_f2d: tos_in = ftos; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1320
    case Bytecodes::_d2i: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1321
    case Bytecodes::_d2l: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1322
    case Bytecodes::_d2f: tos_in = dtos; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1323
    default             : ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1324
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1325
    switch (bytecode()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1326
    case Bytecodes::_l2i: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1327
    case Bytecodes::_f2i: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1328
    case Bytecodes::_d2i: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1329
    case Bytecodes::_i2b: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1330
    case Bytecodes::_i2c: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1331
    case Bytecodes::_i2s: tos_out = itos; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1332
    case Bytecodes::_i2l: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1333
    case Bytecodes::_f2l: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1334
    case Bytecodes::_d2l: tos_out = ltos; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1335
    case Bytecodes::_i2f: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1336
    case Bytecodes::_l2f: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1337
    case Bytecodes::_d2f: tos_out = ftos; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1338
    case Bytecodes::_i2d: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1339
    case Bytecodes::_l2d: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1340
    case Bytecodes::_f2d: tos_out = dtos; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1341
    default             : ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1342
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1343
    transition(tos_in, tos_out);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1344
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1345
#endif // ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1346
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1347
  static const int64_t is_nan = 0x8000000000000000L;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1348
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1349
  // Conversion
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1350
  switch (bytecode()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1351
  case Bytecodes::_i2l:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1352
    __ movslq(rax, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1353
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1354
  case Bytecodes::_i2f:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1355
    __ cvtsi2ssl(xmm0, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1356
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1357
  case Bytecodes::_i2d:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1358
    __ cvtsi2sdl(xmm0, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1359
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1360
  case Bytecodes::_i2b:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1361
    __ movsbl(rax, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1362
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1363
  case Bytecodes::_i2c:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1364
    __ movzwl(rax, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1365
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1366
  case Bytecodes::_i2s:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1367
    __ movswl(rax, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1368
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1369
  case Bytecodes::_l2i:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1370
    __ movl(rax, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1371
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1372
  case Bytecodes::_l2f:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1373
    __ cvtsi2ssq(xmm0, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1374
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1375
  case Bytecodes::_l2d:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1376
    __ cvtsi2sdq(xmm0, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1377
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1378
  case Bytecodes::_f2i:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1379
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1380
    Label L;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1381
    __ cvttss2sil(rax, xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1382
    __ cmpl(rax, 0x80000000); // NaN or overflow/underflow?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1383
    __ jcc(Assembler::notEqual, L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1384
    __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::f2i), 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1385
    __ bind(L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1386
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1387
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1388
  case Bytecodes::_f2l:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1389
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1390
    Label L;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1391
    __ cvttss2siq(rax, xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1392
    // NaN or overflow/underflow?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1393
    __ cmp64(rax, ExternalAddress((address) &is_nan));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1394
    __ jcc(Assembler::notEqual, L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1395
    __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::f2l), 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1396
    __ bind(L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1397
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1398
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1399
  case Bytecodes::_f2d:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1400
    __ cvtss2sd(xmm0, xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1401
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1402
  case Bytecodes::_d2i:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1403
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1404
    Label L;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1405
    __ cvttsd2sil(rax, xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1406
    __ cmpl(rax, 0x80000000); // NaN or overflow/underflow?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1407
    __ jcc(Assembler::notEqual, L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1408
    __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::d2i), 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1409
    __ bind(L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1410
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1411
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1412
  case Bytecodes::_d2l:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1413
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1414
    Label L;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1415
    __ cvttsd2siq(rax, xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1416
    // NaN or overflow/underflow?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1417
    __ cmp64(rax, ExternalAddress((address) &is_nan));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1418
    __ jcc(Assembler::notEqual, L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1419
    __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::d2l), 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1420
    __ bind(L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1421
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1422
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1423
  case Bytecodes::_d2f:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1424
    __ cvtsd2ss(xmm0, xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1425
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1426
  default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1427
    ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1428
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1429
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1430
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1431
void TemplateTable::lcmp() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1432
  transition(ltos, itos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1433
  Label done;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1434
  __ pop_l(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1435
  __ cmpq(rdx, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1436
  __ movl(rax, -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1437
  __ jccb(Assembler::less, done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1438
  __ setb(Assembler::notEqual, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1439
  __ movzbl(rax, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1440
  __ bind(done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1441
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1442
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1443
void TemplateTable::float_cmp(bool is_float, int unordered_result) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1444
  Label done;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1445
  if (is_float) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1446
    // XXX get rid of pop here, use ... reg, mem32
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1447
    __ pop_f(xmm1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1448
    __ ucomiss(xmm1, xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1449
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1450
    // XXX get rid of pop here, use ... reg, mem64
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1451
    __ pop_d(xmm1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1452
    __ ucomisd(xmm1, xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1453
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1454
  if (unordered_result < 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1455
    __ movl(rax, -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1456
    __ jccb(Assembler::parity, done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1457
    __ jccb(Assembler::below, done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1458
    __ setb(Assembler::notEqual, rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1459
    __ movzbl(rax, rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1460
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1461
    __ movl(rax, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1462
    __ jccb(Assembler::parity, done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1463
    __ jccb(Assembler::above, done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1464
    __ movl(rax, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1465
    __ jccb(Assembler::equal, done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1466
    __ decrementl(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1467
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1468
  __ bind(done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1469
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1470
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1471
void TemplateTable::branch(bool is_jsr, bool is_wide) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1472
  __ get_method(rcx); // rcx holds method
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1473
  __ profile_taken_branch(rax, rbx); // rax holds updated MDP, rbx
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1474
                                     // holds bumped taken count
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1475
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1476
  const ByteSize be_offset = methodOopDesc::backedge_counter_offset() +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1477
                             InvocationCounter::counter_offset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1478
  const ByteSize inv_offset = methodOopDesc::invocation_counter_offset() +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1479
                              InvocationCounter::counter_offset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1480
  const int method_offset = frame::interpreter_frame_method_offset * wordSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1481
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1482
  // Load up edx with the branch displacement
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1483
  __ movl(rdx, at_bcp(1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1484
  __ bswapl(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1485
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1486
  if (!is_wide) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1487
    __ sarl(rdx, 16);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1488
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1489
  __ movslq(rdx, rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1490
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1491
  // Handle all the JSR stuff here, then exit.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1492
  // It's much shorter and cleaner than intermingling with the non-JSR
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1493
  // normal-branch stuff occuring below.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1494
  if (is_jsr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1495
    // Pre-load the next target bytecode into rbx
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1496
    __ load_unsigned_byte(rbx, Address(r13, rdx, Address::times_1, 0));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1497
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1498
    // compute return address as bci in rax
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1499
    __ leaq(rax, at_bcp((is_wide ? 5 : 3) -
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1500
                        in_bytes(constMethodOopDesc::codes_offset())));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1501
    __ subq(rax, Address(rcx, methodOopDesc::const_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1502
    // Adjust the bcp in r13 by the displacement in rdx
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1503
    __ addq(r13, rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1504
    // jsr returns atos that is not an oop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1505
    __ push_i(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1506
    __ dispatch_only(vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1507
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1508
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1509
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1510
  // Normal (non-jsr) branch handling
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1511
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1512
  // Adjust the bcp in r13 by the displacement in rdx
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1513
  __ addq(r13, rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1514
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1515
  assert(UseLoopCounter || !UseOnStackReplacement,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1516
         "on-stack-replacement requires loop counters");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1517
  Label backedge_counter_overflow;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1518
  Label profile_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1519
  Label dispatch;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1520
  if (UseLoopCounter) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1521
    // increment backedge counter for backward branches
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1522
    // rax: MDO
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1523
    // ebx: MDO bumped taken-count
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1524
    // rcx: method
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1525
    // rdx: target offset
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1526
    // r13: target bcp
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1527
    // r14: locals pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1528
    __ testl(rdx, rdx);             // check if forward or backward branch
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1529
    __ jcc(Assembler::positive, dispatch); // count only if backward branch
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1530
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1531
    // increment counter
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1532
    __ movl(rax, Address(rcx, be_offset));        // load backedge counter
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1533
    __ incrementl(rax, InvocationCounter::count_increment); // increment
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1534
                                                            // counter
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1535
    __ movl(Address(rcx, be_offset), rax);        // store counter
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1536
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1537
    __ movl(rax, Address(rcx, inv_offset));    // load invocation counter
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1538
    __ andl(rax, InvocationCounter::count_mask_value); // and the status bits
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1539
    __ addl(rax, Address(rcx, be_offset));        // add both counters
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1540
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1541
    if (ProfileInterpreter) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1542
      // Test to see if we should create a method data oop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1543
      __ cmp32(rax,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1544
               ExternalAddress((address) &InvocationCounter::InterpreterProfileLimit));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1545
      __ jcc(Assembler::less, dispatch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1546
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1547
      // if no method data exists, go to profile method
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1548
      __ test_method_data_pointer(rax, profile_method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1549
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1550
      if (UseOnStackReplacement) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1551
        // check for overflow against ebx which is the MDO taken count
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1552
        __ cmp32(rbx,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1553
                 ExternalAddress((address) &InvocationCounter::InterpreterBackwardBranchLimit));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1554
        __ jcc(Assembler::below, dispatch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1555
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1556
        // When ProfileInterpreter is on, the backedge_count comes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1557
        // from the methodDataOop, which value does not get reset on
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1558
        // the call to frequency_counter_overflow().  To avoid
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1559
        // excessive calls to the overflow routine while the method is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1560
        // being compiled, add a second test to make sure the overflow
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1561
        // function is called only once every overflow_frequency.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1562
        const int overflow_frequency = 1024;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1563
        __ andl(rbx, overflow_frequency - 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1564
        __ jcc(Assembler::zero, backedge_counter_overflow);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1565
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1566
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1567
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1568
      if (UseOnStackReplacement) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1569
        // check for overflow against eax, which is the sum of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1570
        // counters
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1571
        __ cmp32(rax,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1572
                 ExternalAddress((address) &InvocationCounter::InterpreterBackwardBranchLimit));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1573
        __ jcc(Assembler::aboveEqual, backedge_counter_overflow);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1574
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1575
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1576
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1577
    __ bind(dispatch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1578
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1579
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1580
  // Pre-load the next target bytecode into rbx
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1581
  __ load_unsigned_byte(rbx, Address(r13, 0));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1582
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1583
  // continue with the bytecode @ target
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1584
  // eax: return bci for jsr's, unused otherwise
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1585
  // ebx: target bytecode
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1586
  // r13: target bcp
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1587
  __ dispatch_only(vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1588
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1589
  if (UseLoopCounter) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1590
    if (ProfileInterpreter) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1591
      // Out-of-line code to allocate method data oop.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1592
      __ bind(profile_method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1593
      __ call_VM(noreg,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1594
                 CAST_FROM_FN_PTR(address,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1595
                                  InterpreterRuntime::profile_method), r13);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1596
      __ load_unsigned_byte(rbx, Address(r13, 0));  // restore target bytecode
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1597
      __ movq(rcx, Address(rbp, method_offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1598
      __ movq(rcx, Address(rcx,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1599
                           in_bytes(methodOopDesc::method_data_offset())));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1600
      __ movq(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1601
              rcx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1602
      __ test_method_data_pointer(rcx, dispatch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1603
      // offset non-null mdp by MDO::data_offset() + IR::profile_method()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1604
      __ addq(rcx, in_bytes(methodDataOopDesc::data_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1605
      __ addq(rcx, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1606
      __ movq(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1607
              rcx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1608
      __ jmp(dispatch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1609
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1610
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1611
    if (UseOnStackReplacement) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1612
      // invocation counter overflow
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1613
      __ bind(backedge_counter_overflow);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1614
      __ negq(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1615
      __ addq(rdx, r13); // branch bcp
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1616
      // IcoResult frequency_counter_overflow([JavaThread*], address branch_bcp)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1617
      __ call_VM(noreg,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1618
                 CAST_FROM_FN_PTR(address,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1619
                                  InterpreterRuntime::frequency_counter_overflow),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1620
                 rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1621
      __ load_unsigned_byte(rbx, Address(r13, 0));  // restore target bytecode
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1622
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1623
      // rax: osr nmethod (osr ok) or NULL (osr not possible)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1624
      // ebx: target bytecode
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1625
      // rdx: scratch
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1626
      // r14: locals pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1627
      // r13: bcp
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1628
      __ testq(rax, rax);                        // test result
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1629
      __ jcc(Assembler::zero, dispatch);         // no osr if null
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1630
      // nmethod may have been invalidated (VM may block upon call_VM return)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1631
      __ movl(rcx, Address(rax, nmethod::entry_bci_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1632
      __ cmpl(rcx, InvalidOSREntryBci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1633
      __ jcc(Assembler::equal, dispatch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1634
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1635
      // We have the address of an on stack replacement routine in eax
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1636
      // We need to prepare to execute the OSR method. First we must
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1637
      // migrate the locals and monitors off of the stack.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1638
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1639
      __ movq(r13, rax);                             // save the nmethod
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1640
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1641
      call_VM(noreg, CAST_FROM_FN_PTR(address, SharedRuntime::OSR_migration_begin));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1642
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1643
      // eax is OSR buffer, move it to expected parameter location
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1644
      __ movq(j_rarg0, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1645
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1646
      // We use j_rarg definitions here so that registers don't conflict as parameter
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1647
      // registers change across platforms as we are in the midst of a calling
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1648
      // sequence to the OSR nmethod and we don't want collision. These are NOT parameters.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1649
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1650
      const Register retaddr = j_rarg2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1651
      const Register sender_sp = j_rarg1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1652
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1653
      // pop the interpreter frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1654
      __ movq(sender_sp, Address(rbp, frame::interpreter_frame_sender_sp_offset * wordSize)); // get sender sp
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1655
      __ leave();                                // remove frame anchor
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1656
      __ popq(retaddr);                            // get return address
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1657
      __ movq(rsp, sender_sp);                   // set sp to sender sp
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1658
      // Ensure compiled code always sees stack at proper alignment
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1659
      __ andq(rsp, -(StackAlignmentInBytes));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1660
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1661
      // unlike x86 we need no specialized return from compiled code
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1662
      // to the interpreter or the call stub.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1663
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1664
      // push the return address
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1665
      __ pushq(retaddr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1666
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1667
      // and begin the OSR nmethod
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1668
      __ jmp(Address(r13, nmethod::osr_entry_point_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1669
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1670
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1671
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1672
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1673
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1674
void TemplateTable::if_0cmp(Condition cc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1675
  transition(itos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1676
  // assume branch is more often taken than not (loops use backward branches)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1677
  Label not_taken;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1678
  __ testl(rax, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1679
  __ jcc(j_not(cc), not_taken);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1680
  branch(false, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1681
  __ bind(not_taken);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1682
  __ profile_not_taken_branch(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1683
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1684
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1685
void TemplateTable::if_icmp(Condition cc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1686
  transition(itos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1687
  // assume branch is more often taken than not (loops use backward branches)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1688
  Label not_taken;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1689
  __ pop_i(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1690
  __ cmpl(rdx, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1691
  __ jcc(j_not(cc), not_taken);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1692
  branch(false, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1693
  __ bind(not_taken);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1694
  __ profile_not_taken_branch(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1695
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1696
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1697
void TemplateTable::if_nullcmp(Condition cc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1698
  transition(atos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1699
  // assume branch is more often taken than not (loops use backward branches)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1700
  Label not_taken;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1701
  __ testq(rax, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1702
  __ jcc(j_not(cc), not_taken);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1703
  branch(false, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1704
  __ bind(not_taken);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1705
  __ profile_not_taken_branch(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1706
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1707
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1708
void TemplateTable::if_acmp(Condition cc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1709
  transition(atos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1710
  // assume branch is more often taken than not (loops use backward branches)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1711
  Label not_taken;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1712
  __ pop_ptr(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1713
  __ cmpq(rdx, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1714
  __ jcc(j_not(cc), not_taken);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1715
  branch(false, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1716
  __ bind(not_taken);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1717
  __ profile_not_taken_branch(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1718
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1719
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1720
void TemplateTable::ret() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1721
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1722
  locals_index(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1723
  __ movq(rbx, aaddress(rbx)); // get return bci, compute return bcp
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1724
  __ profile_ret(rbx, rcx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1725
  __ get_method(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1726
  __ movq(r13, Address(rax, methodOopDesc::const_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1727
  __ leaq(r13, Address(r13, rbx, Address::times_1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1728
                       constMethodOopDesc::codes_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1729
  __ dispatch_next(vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1730
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1731
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1732
void TemplateTable::wide_ret() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1733
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1734
  locals_index_wide(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1735
  __ movq(rbx, aaddress(rbx)); // get return bci, compute return bcp
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1736
  __ profile_ret(rbx, rcx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1737
  __ get_method(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1738
  __ movq(r13, Address(rax, methodOopDesc::const_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1739
  __ leaq(r13, Address(r13, rbx, Address::times_1, constMethodOopDesc::codes_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1740
  __ dispatch_next(vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1741
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1742
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1743
void TemplateTable::tableswitch() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1744
  Label default_case, continue_execution;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1745
  transition(itos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1746
  // align r13
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1747
  __ leaq(rbx, at_bcp(BytesPerInt));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1748
  __ andq(rbx, -BytesPerInt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1749
  // load lo & hi
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1750
  __ movl(rcx, Address(rbx, BytesPerInt));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1751
  __ movl(rdx, Address(rbx, 2 * BytesPerInt));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1752
  __ bswapl(rcx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1753
  __ bswapl(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1754
  // check against lo & hi
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1755
  __ cmpl(rax, rcx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1756
  __ jcc(Assembler::less, default_case);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1757
  __ cmpl(rax, rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1758
  __ jcc(Assembler::greater, default_case);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1759
  // lookup dispatch offset
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1760
  __ subl(rax, rcx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1761
  __ movl(rdx, Address(rbx, rax, Address::times_4, 3 * BytesPerInt));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1762
  __ profile_switch_case(rax, rbx, rcx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1763
  // continue execution
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1764
  __ bind(continue_execution);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1765
  __ bswapl(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1766
  __ movslq(rdx, rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1767
  __ load_unsigned_byte(rbx, Address(r13, rdx, Address::times_1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1768
  __ addq(r13, rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1769
  __ dispatch_only(vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1770
  // handle default
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1771
  __ bind(default_case);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1772
  __ profile_switch_default(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1773
  __ movl(rdx, Address(rbx, 0));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1774
  __ jmp(continue_execution);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1775
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1776
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1777
void TemplateTable::lookupswitch() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1778
  transition(itos, itos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1779
  __ stop("lookupswitch bytecode should have been rewritten");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1780
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1781
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1782
void TemplateTable::fast_linearswitch() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1783
  transition(itos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1784
  Label loop_entry, loop, found, continue_execution;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1785
  // bswap rax so we can avoid bswapping the table entries
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1786
  __ bswapl(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1787
  // align r13
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1788
  __ leaq(rbx, at_bcp(BytesPerInt)); // btw: should be able to get rid of
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1789
                                     // this instruction (change offsets
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1790
                                     // below)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1791
  __ andq(rbx, -BytesPerInt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1792
  // set counter
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1793
  __ movl(rcx, Address(rbx, BytesPerInt));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1794
  __ bswapl(rcx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1795
  __ jmpb(loop_entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1796
  // table search
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1797
  __ bind(loop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1798
  __ cmpl(rax, Address(rbx, rcx, Address::times_8, 2 * BytesPerInt));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1799
  __ jcc(Assembler::equal, found);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1800
  __ bind(loop_entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1801
  __ decrementl(rcx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1802
  __ jcc(Assembler::greaterEqual, loop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1803
  // default case
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1804
  __ profile_switch_default(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1805
  __ movl(rdx, Address(rbx, 0));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1806
  __ jmp(continue_execution);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1807
  // entry found -> get offset
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1808
  __ bind(found);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1809
  __ movl(rdx, Address(rbx, rcx, Address::times_8, 3 * BytesPerInt));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1810
  __ profile_switch_case(rcx, rax, rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1811
  // continue execution
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1812
  __ bind(continue_execution);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1813
  __ bswapl(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1814
  __ movslq(rdx, rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1815
  __ load_unsigned_byte(rbx, Address(r13, rdx, Address::times_1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1816
  __ addq(r13, rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1817
  __ dispatch_only(vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1818
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1819
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1820
void TemplateTable::fast_binaryswitch() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1821
  transition(itos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1822
  // Implementation using the following core algorithm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1823
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1824
  // int binary_search(int key, LookupswitchPair* array, int n) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1825
  //   // Binary search according to "Methodik des Programmierens" by
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1826
  //   // Edsger W. Dijkstra and W.H.J. Feijen, Addison Wesley Germany 1985.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1827
  //   int i = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1828
  //   int j = n;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1829
  //   while (i+1 < j) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1830
  //     // invariant P: 0 <= i < j <= n and (a[i] <= key < a[j] or Q)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1831
  //     // with      Q: for all i: 0 <= i < n: key < a[i]
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1832
  //     // where a stands for the array and assuming that the (inexisting)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1833
  //     // element a[n] is infinitely big.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1834
  //     int h = (i + j) >> 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1835
  //     // i < h < j
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1836
  //     if (key < array[h].fast_match()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1837
  //       j = h;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1838
  //     } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1839
  //       i = h;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1840
  //     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1841
  //   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1842
  //   // R: a[i] <= key < a[i+1] or Q
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1843
  //   // (i.e., if key is within array, i is the correct index)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1844
  //   return i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1845
  // }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1846
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1847
  // Register allocation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1848
  const Register key   = rax; // already set (tosca)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1849
  const Register array = rbx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1850
  const Register i     = rcx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1851
  const Register j     = rdx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1852
  const Register h     = rdi;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1853
  const Register temp  = rsi;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1854
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1855
  // Find array start
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1856
  __ leaq(array, at_bcp(3 * BytesPerInt)); // btw: should be able to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1857
                                           // get rid of this
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1858
                                           // instruction (change
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1859
                                           // offsets below)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1860
  __ andq(array, -BytesPerInt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1861
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1862
  // Initialize i & j
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1863
  __ xorl(i, i);                            // i = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1864
  __ movl(j, Address(array, -BytesPerInt)); // j = length(array);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1865
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1866
  // Convert j into native byteordering
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1867
  __ bswapl(j);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1868
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1869
  // And start
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1870
  Label entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1871
  __ jmp(entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1872
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1873
  // binary search loop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1874
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1875
    Label loop;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1876
    __ bind(loop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1877
    // int h = (i + j) >> 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1878
    __ leal(h, Address(i, j, Address::times_1)); // h = i + j;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1879
    __ sarl(h, 1);                               // h = (i + j) >> 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1880
    // if (key < array[h].fast_match()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1881
    //   j = h;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1882
    // } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1883
    //   i = h;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1884
    // }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1885
    // Convert array[h].match to native byte-ordering before compare
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1886
    __ movl(temp, Address(array, h, Address::times_8));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1887
    __ bswapl(temp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1888
    __ cmpl(key, temp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1889
    // j = h if (key <  array[h].fast_match())
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1890
    __ cmovl(Assembler::less, j, h);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1891
    // i = h if (key >= array[h].fast_match())
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1892
    __ cmovl(Assembler::greaterEqual, i, h);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1893
    // while (i+1 < j)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1894
    __ bind(entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1895
    __ leal(h, Address(i, 1)); // i+1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1896
    __ cmpl(h, j);             // i+1 < j
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1897
    __ jcc(Assembler::less, loop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1898
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1899
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1900
  // end of binary search, result index is i (must check again!)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1901
  Label default_case;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1902
  // Convert array[i].match to native byte-ordering before compare
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1903
  __ movl(temp, Address(array, i, Address::times_8));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1904
  __ bswapl(temp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1905
  __ cmpl(key, temp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1906
  __ jcc(Assembler::notEqual, default_case);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1907
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1908
  // entry found -> j = offset
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1909
  __ movl(j , Address(array, i, Address::times_8, BytesPerInt));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1910
  __ profile_switch_case(i, key, array);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1911
  __ bswapl(j);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1912
  __ movslq(j, j);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1913
  __ load_unsigned_byte(rbx, Address(r13, j, Address::times_1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1914
  __ addq(r13, j);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1915
  __ dispatch_only(vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1916
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1917
  // default case -> j = default offset
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1918
  __ bind(default_case);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1919
  __ profile_switch_default(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1920
  __ movl(j, Address(array, -2 * BytesPerInt));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1921
  __ bswapl(j);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1922
  __ movslq(j, j);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1923
  __ load_unsigned_byte(rbx, Address(r13, j, Address::times_1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1924
  __ addq(r13, j);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1925
  __ dispatch_only(vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1926
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1927
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1928
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1929
void TemplateTable::_return(TosState state) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1930
  transition(state, state);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1931
  assert(_desc->calls_vm(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1932
         "inconsistent calls_vm information"); // call in remove_activation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1933
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1934
  if (_desc->bytecode() == Bytecodes::_return_register_finalizer) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1935
    assert(state == vtos, "only valid state");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1936
    __ movq(c_rarg1, aaddress(0));
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  1937
    __ load_klass(rdi, c_rarg1);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1938
    __ movl(rdi, Address(rdi, Klass::access_flags_offset_in_bytes() + sizeof(oopDesc)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1939
    __ testl(rdi, JVM_ACC_HAS_FINALIZER);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1940
    Label skip_register_finalizer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1941
    __ jcc(Assembler::zero, skip_register_finalizer);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1942
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1943
    __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::register_finalizer), c_rarg1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1944
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1945
    __ bind(skip_register_finalizer);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1946
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1947
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1948
  __ remove_activation(state, r13);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1949
  __ jmp(r13);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1950
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1951
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1952
// ----------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1953
// Volatile variables demand their effects be made known to all CPU's
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1954
// in order.  Store buffers on most chips allow reads & writes to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1955
// reorder; the JMM's ReadAfterWrite.java test fails in -Xint mode
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1956
// without some kind of memory barrier (i.e., it's not sufficient that
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1957
// the interpreter does not reorder volatile references, the hardware
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1958
// also must not reorder them).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1959
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1960
// According to the new Java Memory Model (JMM):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1961
// (1) All volatiles are serialized wrt to each other.  ALSO reads &
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1962
//     writes act as aquire & release, so:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1963
// (2) A read cannot let unrelated NON-volatile memory refs that
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1964
//     happen after the read float up to before the read.  It's OK for
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1965
//     non-volatile memory refs that happen before the volatile read to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1966
//     float down below it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1967
// (3) Similar a volatile write cannot let unrelated NON-volatile
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1968
//     memory refs that happen BEFORE the write float down to after the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1969
//     write.  It's OK for non-volatile memory refs that happen after the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1970
//     volatile write to float up before it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1971
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1972
// We only put in barriers around volatile refs (they are expensive),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1973
// not _between_ memory refs (that would require us to track the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1974
// flavor of the previous memory refs).  Requirements (2) and (3)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1975
// require some barriers before volatile stores and after volatile
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1976
// loads.  These nearly cover requirement (1) but miss the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1977
// volatile-store-volatile-load case.  This final case is placed after
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1978
// volatile-stores although it could just as well go before
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1979
// volatile-loads.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1980
void TemplateTable::volatile_barrier(Assembler::Membar_mask_bits
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1981
                                     order_constraint) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1982
  // Helper function to insert a is-volatile test and memory barrier
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1983
  if (os::is_MP()) { // Not needed on single CPU
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1984
    __ membar(order_constraint);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1985
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1986
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1987
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1988
void TemplateTable::resolve_cache_and_index(int byte_no,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1989
                                            Register Rcache,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1990
                                            Register index) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1991
  assert(byte_no == 1 || byte_no == 2, "byte_no out of range");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1992
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1993
  const Register temp = rbx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1994
  assert_different_registers(Rcache, index, temp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1995
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1996
  const int shift_count = (1 + byte_no) * BitsPerByte;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1997
  Label resolved;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1998
  __ get_cache_and_index_at_bcp(Rcache, index, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1999
  __ movl(temp, Address(Rcache,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2000
                        index, Address::times_8,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2001
                        constantPoolCacheOopDesc::base_offset() +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2002
                        ConstantPoolCacheEntry::indices_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2003
  __ shrl(temp, shift_count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2004
  // have we resolved this bytecode?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2005
  __ andl(temp, 0xFF);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2006
  __ cmpl(temp, (int) bytecode());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2007
  __ jcc(Assembler::equal, resolved);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2008
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2009
  // resolve first time through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2010
  address entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2011
  switch (bytecode()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2012
  case Bytecodes::_getstatic:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2013
  case Bytecodes::_putstatic:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2014
  case Bytecodes::_getfield:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2015
  case Bytecodes::_putfield:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2016
    entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_get_put);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2017
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2018
  case Bytecodes::_invokevirtual:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2019
  case Bytecodes::_invokespecial:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2020
  case Bytecodes::_invokestatic:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2021
  case Bytecodes::_invokeinterface:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2022
    entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_invoke);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2023
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2024
  default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2025
    ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2026
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2027
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2028
  __ movl(temp, (int) bytecode());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2029
  __ call_VM(noreg, entry, temp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2030
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2031
  // Update registers with resolved info
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2032
  __ get_cache_and_index_at_bcp(Rcache, index, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2033
  __ bind(resolved);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2034
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2035
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2036
// The Rcache and index registers must be set before call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2037
void TemplateTable::load_field_cp_cache_entry(Register obj,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2038
                                              Register cache,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2039
                                              Register index,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2040
                                              Register off,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2041
                                              Register flags,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2042
                                              bool is_static = false) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2043
  assert_different_registers(cache, index, flags, off);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2044
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2045
  ByteSize cp_base_offset = constantPoolCacheOopDesc::base_offset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2046
  // Field offset
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2047
  __ movq(off, Address(cache, index, Address::times_8,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2048
                       in_bytes(cp_base_offset +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2049
                                ConstantPoolCacheEntry::f2_offset())));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2050
  // Flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2051
  __ movl(flags, Address(cache, index, Address::times_8,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2052
                         in_bytes(cp_base_offset +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2053
                                  ConstantPoolCacheEntry::flags_offset())));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2054
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2055
  // klass overwrite register
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2056
  if (is_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2057
    __ movq(obj, Address(cache, index, Address::times_8,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2058
                         in_bytes(cp_base_offset +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2059
                                  ConstantPoolCacheEntry::f1_offset())));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2060
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2061
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2062
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2063
void TemplateTable::load_invoke_cp_cache_entry(int byte_no,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2064
                                               Register method,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2065
                                               Register itable_index,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2066
                                               Register flags,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2067
                                               bool is_invokevirtual,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2068
                                               bool is_invokevfinal /*unused*/) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2069
  // setup registers
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2070
  const Register cache = rcx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2071
  const Register index = rdx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2072
  assert_different_registers(method, flags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2073
  assert_different_registers(method, cache, index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2074
  assert_different_registers(itable_index, flags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2075
  assert_different_registers(itable_index, cache, index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2076
  // determine constant pool cache field offsets
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2077
  const int method_offset = in_bytes(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2078
    constantPoolCacheOopDesc::base_offset() +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2079
      (is_invokevirtual
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2080
       ? ConstantPoolCacheEntry::f2_offset()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2081
       : ConstantPoolCacheEntry::f1_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2082
  const int flags_offset = in_bytes(constantPoolCacheOopDesc::base_offset() +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2083
                                    ConstantPoolCacheEntry::flags_offset());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2084
  // access constant pool cache fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2085
  const int index_offset = in_bytes(constantPoolCacheOopDesc::base_offset() +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2086
                                    ConstantPoolCacheEntry::f2_offset());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2087
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2088
  resolve_cache_and_index(byte_no, cache, index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2089
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2090
  assert(wordSize == 8, "adjust code below");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2091
  __ movq(method, Address(cache, index, Address::times_8, method_offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2092
  if (itable_index != noreg) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2093
    __ movq(itable_index,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2094
            Address(cache, index, Address::times_8, index_offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2095
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2096
  __ movl(flags , Address(cache, index, Address::times_8, flags_offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2097
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2098
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2099
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2100
// The registers cache and index expected to be set before call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2101
// Correct values of the cache and index registers are preserved.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2102
void TemplateTable::jvmti_post_field_access(Register cache, Register index,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2103
                                            bool is_static, bool has_tos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2104
  // do the JVMTI work here to avoid disturbing the register state below
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2105
  // We use c_rarg registers here because we want to use the register used in
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2106
  // the call to the VM
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2107
  if (JvmtiExport::can_post_field_access()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2108
    // Check to see if a field access watch has been set before we
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2109
    // take the time to call into the VM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2110
    Label L1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2111
    assert_different_registers(cache, index, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2112
    __ mov32(rax, ExternalAddress((address) JvmtiExport::get_field_access_count_addr()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2113
    __ testl(rax, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2114
    __ jcc(Assembler::zero, L1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2115
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2116
    __ get_cache_and_index_at_bcp(c_rarg2, c_rarg3, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2117
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2118
    // cache entry pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2119
    __ addq(c_rarg2, in_bytes(constantPoolCacheOopDesc::base_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2120
    __ shll(c_rarg3, LogBytesPerWord);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2121
    __ addq(c_rarg2, c_rarg3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2122
    if (is_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2123
      __ xorl(c_rarg1, c_rarg1); // NULL object reference
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2124
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2125
      __ movq(c_rarg1, at_tos()); // get object pointer without popping it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2126
      __ verify_oop(c_rarg1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2127
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2128
    // c_rarg1: object pointer or NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2129
    // c_rarg2: cache entry pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2130
    // c_rarg3: jvalue object on the stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2131
    __ call_VM(noreg, CAST_FROM_FN_PTR(address,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2132
                                       InterpreterRuntime::post_field_access),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2133
               c_rarg1, c_rarg2, c_rarg3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2134
    __ get_cache_and_index_at_bcp(cache, index, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2135
    __ bind(L1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2136
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2137
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2138
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2139
void TemplateTable::pop_and_check_object(Register r) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2140
  __ pop_ptr(r);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2141
  __ null_check(r);  // for field access must check obj.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2142
  __ verify_oop(r);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2143
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2144
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2145
void TemplateTable::getfield_or_static(int byte_no, bool is_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2146
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2147
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2148
  const Register cache = rcx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2149
  const Register index = rdx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2150
  const Register obj   = c_rarg3;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2151
  const Register off   = rbx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2152
  const Register flags = rax;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2153
  const Register bc = c_rarg3; // uses same reg as obj, so don't mix them
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2154
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2155
  resolve_cache_and_index(byte_no, cache, index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2156
  jvmti_post_field_access(cache, index, is_static, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2157
  load_field_cp_cache_entry(obj, cache, index, off, flags, is_static);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2158
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2159
  if (!is_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2160
    // obj is on the stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2161
    pop_and_check_object(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2162
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2163
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2164
  const Address field(obj, off, Address::times_1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2165
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2166
  Label Done, notByte, notInt, notShort, notChar,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2167
              notLong, notFloat, notObj, notDouble;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2168
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2169
  __ shrl(flags, ConstantPoolCacheEntry::tosBits);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2170
  assert(btos == 0, "change code, btos != 0");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2171
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2172
  __ andl(flags, 0x0F);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2173
  __ jcc(Assembler::notZero, notByte);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2174
  // btos
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2175
  __ load_signed_byte(rax, field);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2176
  __ push(btos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2177
  // Rewrite bytecode to be faster
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2178
  if (!is_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2179
    patch_bytecode(Bytecodes::_fast_bgetfield, bc, rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2180
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2181
  __ jmp(Done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2182
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2183
  __ bind(notByte);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2184
  __ cmpl(flags, atos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2185
  __ jcc(Assembler::notEqual, notObj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2186
  // atos
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  2187
  __ load_heap_oop(rax, field);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2188
  __ push(atos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2189
  if (!is_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2190
    patch_bytecode(Bytecodes::_fast_agetfield, bc, rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2191
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2192
  __ jmp(Done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2193
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2194
  __ bind(notObj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2195
  __ cmpl(flags, itos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2196
  __ jcc(Assembler::notEqual, notInt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2197
  // itos
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2198
  __ movl(rax, field);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2199
  __ push(itos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2200
  // Rewrite bytecode to be faster
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2201
  if (!is_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2202
    patch_bytecode(Bytecodes::_fast_igetfield, bc, rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2203
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2204
  __ jmp(Done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2205
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2206
  __ bind(notInt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2207
  __ cmpl(flags, ctos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2208
  __ jcc(Assembler::notEqual, notChar);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2209
  // ctos
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2210
  __ load_unsigned_word(rax, field);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2211
  __ push(ctos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2212
  // Rewrite bytecode to be faster
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2213
  if (!is_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2214
    patch_bytecode(Bytecodes::_fast_cgetfield, bc, rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2215
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2216
  __ jmp(Done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2217
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2218
  __ bind(notChar);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2219
  __ cmpl(flags, stos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2220
  __ jcc(Assembler::notEqual, notShort);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2221
  // stos
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2222
  __ load_signed_word(rax, field);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2223
  __ push(stos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2224
  // Rewrite bytecode to be faster
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2225
  if (!is_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2226
    patch_bytecode(Bytecodes::_fast_sgetfield, bc, rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2227
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2228
  __ jmp(Done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2229
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2230
  __ bind(notShort);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2231
  __ cmpl(flags, ltos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2232
  __ jcc(Assembler::notEqual, notLong);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2233
  // ltos
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2234
  __ movq(rax, field);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2235
  __ push(ltos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2236
  // Rewrite bytecode to be faster
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2237
  if (!is_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2238
    patch_bytecode(Bytecodes::_fast_lgetfield, bc, rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2239
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2240
  __ jmp(Done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2241
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2242
  __ bind(notLong);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2243
  __ cmpl(flags, ftos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2244
  __ jcc(Assembler::notEqual, notFloat);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2245
  // ftos
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2246
  __ movflt(xmm0, field);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2247
  __ push(ftos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2248
  // Rewrite bytecode to be faster
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2249
  if (!is_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2250
    patch_bytecode(Bytecodes::_fast_fgetfield, bc, rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2251
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2252
  __ jmp(Done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2253
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2254
  __ bind(notFloat);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2255
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2256
  __ cmpl(flags, dtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2257
  __ jcc(Assembler::notEqual, notDouble);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2258
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2259
  // dtos
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2260
  __ movdbl(xmm0, field);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2261
  __ push(dtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2262
  // Rewrite bytecode to be faster
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2263
  if (!is_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2264
    patch_bytecode(Bytecodes::_fast_dgetfield, bc, rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2265
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2266
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2267
  __ jmp(Done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2268
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2269
  __ bind(notDouble);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2270
  __ stop("Bad state");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2271
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2272
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2273
  __ bind(Done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2274
  // [jk] not needed currently
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2275
  // volatile_barrier(Assembler::Membar_mask_bits(Assembler::LoadLoad |
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2276
  //                                              Assembler::LoadStore));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2277
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2278
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2279
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2280
void TemplateTable::getfield(int byte_no) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2281
  getfield_or_static(byte_no, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2282
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2283
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2284
void TemplateTable::getstatic(int byte_no) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2285
  getfield_or_static(byte_no, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2286
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2287
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2288
// The registers cache and index expected to be set before call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2289
// The function may destroy various registers, just not the cache and index registers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2290
void TemplateTable::jvmti_post_field_mod(Register cache, Register index, bool is_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2291
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2292
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2293
  ByteSize cp_base_offset = constantPoolCacheOopDesc::base_offset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2294
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2295
  if (JvmtiExport::can_post_field_modification()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2296
    // Check to see if a field modification watch has been set before
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2297
    // we take the time to call into the VM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2298
    Label L1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2299
    assert_different_registers(cache, index, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2300
    __ mov32(rax, ExternalAddress((address)JvmtiExport::get_field_modification_count_addr()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2301
    __ testl(rax, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2302
    __ jcc(Assembler::zero, L1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2303
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2304
    __ get_cache_and_index_at_bcp(c_rarg2, rscratch1, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2305
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2306
    if (is_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2307
      // Life is simple.  Null out the object pointer.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2308
      __ xorl(c_rarg1, c_rarg1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2309
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2310
      // Life is harder. The stack holds the value on top, followed by
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2311
      // the object.  We don't know the size of the value, though; it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2312
      // could be one or two words depending on its type. As a result,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2313
      // we must find the type to determine where the object is.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2314
      __ movl(c_rarg3, Address(c_rarg2, rscratch1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2315
                           Address::times_8,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2316
                           in_bytes(cp_base_offset +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2317
                                     ConstantPoolCacheEntry::flags_offset())));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2318
      __ shrl(c_rarg3, ConstantPoolCacheEntry::tosBits);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2319
      // Make sure we don't need to mask rcx for tosBits after the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2320
      // above shift
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2321
      ConstantPoolCacheEntry::verify_tosBits();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2322
      __ movq(c_rarg1, at_tos_p1());  // initially assume a one word jvalue
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2323
      __ cmpl(c_rarg3, ltos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2324
      __ cmovq(Assembler::equal,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2325
               c_rarg1, at_tos_p2()); // ltos (two word jvalue)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2326
      __ cmpl(c_rarg3, dtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2327
      __ cmovq(Assembler::equal,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2328
               c_rarg1, at_tos_p2()); // dtos (two word jvalue)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2329
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2330
    // cache entry pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2331
    __ addq(c_rarg2, in_bytes(cp_base_offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2332
    __ shll(rscratch1, LogBytesPerWord);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2333
    __ addq(c_rarg2, rscratch1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2334
    // object (tos)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2335
    __ movq(c_rarg3, rsp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2336
    // c_rarg1: object pointer set up above (NULL if static)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2337
    // c_rarg2: cache entry pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2338
    // c_rarg3: jvalue object on the stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2339
    __ call_VM(noreg,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2340
               CAST_FROM_FN_PTR(address,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2341
                                InterpreterRuntime::post_field_modification),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2342
               c_rarg1, c_rarg2, c_rarg3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2343
    __ get_cache_and_index_at_bcp(cache, index, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2344
    __ bind(L1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2345
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2346
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2347
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2348
void TemplateTable::putfield_or_static(int byte_no, bool is_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2349
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2350
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2351
  const Register cache = rcx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2352
  const Register index = rdx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2353
  const Register obj   = rcx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2354
  const Register off   = rbx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2355
  const Register flags = rax;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2356
  const Register bc    = c_rarg3;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2357
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2358
  resolve_cache_and_index(byte_no, cache, index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2359
  jvmti_post_field_mod(cache, index, is_static);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2360
  load_field_cp_cache_entry(obj, cache, index, off, flags, is_static);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2361
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2362
  // [jk] not needed currently
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2363
  // volatile_barrier(Assembler::Membar_mask_bits(Assembler::LoadStore |
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2364
  //                                              Assembler::StoreStore));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2365
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2366
  Label notVolatile, Done;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2367
  __ movl(rdx, flags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2368
  __ shrl(rdx, ConstantPoolCacheEntry::volatileField);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2369
  __ andl(rdx, 0x1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2370
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2371
  // field address
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2372
  const Address field(obj, off, Address::times_1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2373
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2374
  Label notByte, notInt, notShort, notChar,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2375
        notLong, notFloat, notObj, notDouble;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2376
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2377
  __ shrl(flags, ConstantPoolCacheEntry::tosBits);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2378
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2379
  assert(btos == 0, "change code, btos != 0");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2380
  __ andl(flags, 0x0f);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2381
  __ jcc(Assembler::notZero, notByte);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2382
  // btos
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2383
  __ pop(btos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2384
  if (!is_static) pop_and_check_object(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2385
  __ movb(field, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2386
  if (!is_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2387
    patch_bytecode(Bytecodes::_fast_bputfield, bc, rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2388
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2389
  __ jmp(Done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2390
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2391
  __ bind(notByte);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2392
  __ cmpl(flags, atos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2393
  __ jcc(Assembler::notEqual, notObj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2394
  // atos
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2395
  __ pop(atos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2396
  if (!is_static) pop_and_check_object(obj);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  2397
  __ store_heap_oop(field, rax);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2398
  __ store_check(obj, field); // Need to mark card
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2399
  if (!is_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2400
    patch_bytecode(Bytecodes::_fast_aputfield, bc, rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2401
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2402
  __ jmp(Done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2403
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2404
  __ bind(notObj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2405
  __ cmpl(flags, itos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2406
  __ jcc(Assembler::notEqual, notInt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2407
  // itos
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2408
  __ pop(itos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2409
  if (!is_static) pop_and_check_object(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2410
  __ movl(field, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2411
  if (!is_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2412
    patch_bytecode(Bytecodes::_fast_iputfield, bc, rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2413
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2414
  __ jmp(Done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2415
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2416
  __ bind(notInt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2417
  __ cmpl(flags, ctos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2418
  __ jcc(Assembler::notEqual, notChar);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2419
  // ctos
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2420
  __ pop(ctos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2421
  if (!is_static) pop_and_check_object(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2422
  __ movw(field, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2423
  if (!is_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2424
    patch_bytecode(Bytecodes::_fast_cputfield, bc, rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2425
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2426
  __ jmp(Done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2427
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2428
  __ bind(notChar);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2429
  __ cmpl(flags, stos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2430
  __ jcc(Assembler::notEqual, notShort);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2431
  // stos
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2432
  __ pop(stos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2433
  if (!is_static) pop_and_check_object(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2434
  __ movw(field, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2435
  if (!is_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2436
    patch_bytecode(Bytecodes::_fast_sputfield, bc, rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2437
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2438
  __ jmp(Done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2439
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2440
  __ bind(notShort);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2441
  __ cmpl(flags, ltos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2442
  __ jcc(Assembler::notEqual, notLong);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2443
  // ltos
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2444
  __ pop(ltos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2445
  if (!is_static) pop_and_check_object(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2446
  __ movq(field, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2447
  if (!is_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2448
    patch_bytecode(Bytecodes::_fast_lputfield, bc, rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2449
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2450
  __ jmp(Done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2451
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2452
  __ bind(notLong);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2453
  __ cmpl(flags, ftos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2454
  __ jcc(Assembler::notEqual, notFloat);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2455
  // ftos
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2456
  __ pop(ftos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2457
  if (!is_static) pop_and_check_object(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2458
  __ movflt(field, xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2459
  if (!is_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2460
    patch_bytecode(Bytecodes::_fast_fputfield, bc, rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2461
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2462
  __ jmp(Done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2463
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2464
  __ bind(notFloat);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2465
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2466
  __ cmpl(flags, dtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2467
  __ jcc(Assembler::notEqual, notDouble);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2468
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2469
  // dtos
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2470
  __ pop(dtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2471
  if (!is_static) pop_and_check_object(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2472
  __ movdbl(field, xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2473
  if (!is_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2474
    patch_bytecode(Bytecodes::_fast_dputfield, bc, rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2475
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2476
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2477
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2478
  __ jmp(Done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2479
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2480
  __ bind(notDouble);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2481
  __ stop("Bad state");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2482
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2483
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2484
  __ bind(Done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2485
  // Check for volatile store
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2486
  __ testl(rdx, rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2487
  __ jcc(Assembler::zero, notVolatile);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2488
  volatile_barrier(Assembler::Membar_mask_bits(Assembler::StoreLoad |
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2489
                                               Assembler::StoreStore));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2490
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2491
  __ bind(notVolatile);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2492
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2493
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2494
void TemplateTable::putfield(int byte_no) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2495
  putfield_or_static(byte_no, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2496
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2497
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2498
void TemplateTable::putstatic(int byte_no) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2499
  putfield_or_static(byte_no, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2500
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2501
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2502
void TemplateTable::jvmti_post_fast_field_mod() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2503
  if (JvmtiExport::can_post_field_modification()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2504
    // Check to see if a field modification watch has been set before
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2505
    // we take the time to call into the VM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2506
    Label L2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2507
    __ mov32(c_rarg3, ExternalAddress((address)JvmtiExport::get_field_modification_count_addr()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2508
    __ testl(c_rarg3, c_rarg3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2509
    __ jcc(Assembler::zero, L2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2510
    __ pop_ptr(rbx);                  // copy the object pointer from tos
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2511
    __ verify_oop(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2512
    __ push_ptr(rbx);                 // put the object pointer back on tos
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2513
    __ subq(rsp, sizeof(jvalue));  // add space for a jvalue object
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2514
    __ movq(c_rarg3, rsp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2515
    const Address field(c_rarg3, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2516
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2517
    switch (bytecode()) {          // load values into the jvalue object
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  2518
    case Bytecodes::_fast_aputfield: __ movq(field, rax); break;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2519
    case Bytecodes::_fast_lputfield: __ movq(field, rax); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2520
    case Bytecodes::_fast_iputfield: __ movl(field, rax); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2521
    case Bytecodes::_fast_bputfield: __ movb(field, rax); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2522
    case Bytecodes::_fast_sputfield: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2523
    case Bytecodes::_fast_cputfield: __ movw(field, rax); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2524
    case Bytecodes::_fast_fputfield: __ movflt(field, xmm0); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2525
    case Bytecodes::_fast_dputfield: __ movdbl(field, xmm0); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2526
    default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2527
      ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2528
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2529
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2530
    // Save rax because call_VM() will clobber it, then use it for
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2531
    // JVMTI purposes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2532
    __ pushq(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2533
    // access constant pool cache entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2534
    __ get_cache_entry_pointer_at_bcp(c_rarg2, rax, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2535
    __ verify_oop(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2536
    // rbx: object pointer copied above
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2537
    // c_rarg2: cache entry pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2538
    // c_rarg3: jvalue object on the stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2539
    __ call_VM(noreg,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2540
               CAST_FROM_FN_PTR(address,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2541
                                InterpreterRuntime::post_field_modification),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2542
               rbx, c_rarg2, c_rarg3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2543
    __ popq(rax);     // restore lower value
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2544
    __ addq(rsp, sizeof(jvalue));  // release jvalue object space
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2545
    __ bind(L2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2546
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2547
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2548
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2549
void TemplateTable::fast_storefield(TosState state) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2550
  transition(state, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2551
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2552
  ByteSize base = constantPoolCacheOopDesc::base_offset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2553
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2554
  jvmti_post_fast_field_mod();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2555
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2556
  // access constant pool cache
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2557
  __ get_cache_and_index_at_bcp(rcx, rbx, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2558
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2559
  // test for volatile with rdx
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2560
  __ movl(rdx, Address(rcx, rbx, Address::times_8,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2561
                       in_bytes(base +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2562
                                ConstantPoolCacheEntry::flags_offset())));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2563
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2564
  // replace index with field offset from cache entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2565
  __ movq(rbx, Address(rcx, rbx, Address::times_8,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2566
                       in_bytes(base + ConstantPoolCacheEntry::f2_offset())));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2567
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2568
  // [jk] not needed currently
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2569
  // volatile_barrier(Assembler::Membar_mask_bits(Assembler::LoadStore |
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2570
  //                                              Assembler::StoreStore));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2571
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2572
  Label notVolatile;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2573
  __ shrl(rdx, ConstantPoolCacheEntry::volatileField);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2574
  __ andl(rdx, 0x1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2575
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2576
  // Get object from stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2577
  pop_and_check_object(rcx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2578
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2579
  // field address
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2580
  const Address field(rcx, rbx, Address::times_1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2581
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2582
  // access field
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2583
  switch (bytecode()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2584
  case Bytecodes::_fast_aputfield:
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  2585
    __ store_heap_oop(field, rax);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2586
    __ store_check(rcx, field);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2587
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2588
  case Bytecodes::_fast_lputfield:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2589
    __ movq(field, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2590
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2591
  case Bytecodes::_fast_iputfield:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2592
    __ movl(field, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2593
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2594
  case Bytecodes::_fast_bputfield:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2595
    __ movb(field, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2596
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2597
  case Bytecodes::_fast_sputfield:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2598
    // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2599
  case Bytecodes::_fast_cputfield:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2600
    __ movw(field, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2601
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2602
  case Bytecodes::_fast_fputfield:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2603
    __ movflt(field, xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2604
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2605
  case Bytecodes::_fast_dputfield:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2606
    __ movdbl(field, xmm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2607
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2608
  default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2609
    ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2610
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2611
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2612
  // Check for volatile store
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2613
  __ testl(rdx, rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2614
  __ jcc(Assembler::zero, notVolatile);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2615
  volatile_barrier(Assembler::Membar_mask_bits(Assembler::StoreLoad |
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2616
                                               Assembler::StoreStore));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2617
  __ bind(notVolatile);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2618
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2619
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2620
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2621
void TemplateTable::fast_accessfield(TosState state) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2622
  transition(atos, state);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2623
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2624
  // Do the JVMTI work here to avoid disturbing the register state below
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2625
  if (JvmtiExport::can_post_field_access()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2626
    // Check to see if a field access watch has been set before we
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2627
    // take the time to call into the VM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2628
    Label L1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2629
    __ mov32(rcx, ExternalAddress((address) JvmtiExport::get_field_access_count_addr()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2630
    __ testl(rcx, rcx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2631
    __ jcc(Assembler::zero, L1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2632
    // access constant pool cache entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2633
    __ get_cache_entry_pointer_at_bcp(c_rarg2, rcx, 1);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  2634
    __ verify_oop(rax);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2635
    __ movq(r12, rax);  // save object pointer before call_VM() clobbers it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2636
    __ movq(c_rarg1, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2637
    // c_rarg1: object pointer copied above
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2638
    // c_rarg2: cache entry pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2639
    __ call_VM(noreg,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2640
               CAST_FROM_FN_PTR(address,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2641
                                InterpreterRuntime::post_field_access),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2642
               c_rarg1, c_rarg2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2643
    __ movq(rax, r12); // restore object pointer
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  2644
    __ reinit_heapbase();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2645
    __ bind(L1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2646
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2647
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2648
  // access constant pool cache
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2649
  __ get_cache_and_index_at_bcp(rcx, rbx, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2650
  // replace index with field offset from cache entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2651
  // [jk] not needed currently
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2652
  // if (os::is_MP()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2653
  //   __ movl(rdx, Address(rcx, rbx, Address::times_8,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2654
  //                        in_bytes(constantPoolCacheOopDesc::base_offset() +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2655
  //                                 ConstantPoolCacheEntry::flags_offset())));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2656
  //   __ shrl(rdx, ConstantPoolCacheEntry::volatileField);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2657
  //   __ andl(rdx, 0x1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2658
  // }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2659
  __ movq(rbx, Address(rcx, rbx, Address::times_8,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2660
                       in_bytes(constantPoolCacheOopDesc::base_offset() +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2661
                                ConstantPoolCacheEntry::f2_offset())));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2662
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2663
  // rax: object
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2664
  __ verify_oop(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2665
  __ null_check(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2666
  Address field(rax, rbx, Address::times_1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2667
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2668
  // access field
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2669
  switch (bytecode()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2670
  case Bytecodes::_fast_agetfield:
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  2671
    __ load_heap_oop(rax, field);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2672
    __ verify_oop(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2673
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2674
  case Bytecodes::_fast_lgetfield:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2675
    __ movq(rax, field);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2676
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2677
  case Bytecodes::_fast_igetfield:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2678
    __ movl(rax, field);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2679
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2680
  case Bytecodes::_fast_bgetfield:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2681
    __ movsbl(rax, field);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2682
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2683
  case Bytecodes::_fast_sgetfield:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2684
    __ load_signed_word(rax, field);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2685
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2686
  case Bytecodes::_fast_cgetfield:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2687
    __ load_unsigned_word(rax, field);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2688
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2689
  case Bytecodes::_fast_fgetfield:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2690
    __ movflt(xmm0, field);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2691
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2692
  case Bytecodes::_fast_dgetfield:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2693
    __ movdbl(xmm0, field);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2694
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2695
  default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2696
    ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2697
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2698
  // [jk] not needed currently
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2699
  // if (os::is_MP()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2700
  //   Label notVolatile;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2701
  //   __ testl(rdx, rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2702
  //   __ jcc(Assembler::zero, notVolatile);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2703
  //   __ membar(Assembler::LoadLoad);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2704
  //   __ bind(notVolatile);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2705
  //};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2706
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2707
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2708
void TemplateTable::fast_xaccess(TosState state) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2709
  transition(vtos, state);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2710
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2711
  // get receiver
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2712
  __ movq(rax, aaddress(0));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2713
  debug_only(__ verify_local_tag(frame::TagReference, 0));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2714
  // access constant pool cache
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2715
  __ get_cache_and_index_at_bcp(rcx, rdx, 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2716
  __ movq(rbx,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2717
          Address(rcx, rdx, Address::times_8,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2718
                  in_bytes(constantPoolCacheOopDesc::base_offset() +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2719
                           ConstantPoolCacheEntry::f2_offset())));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2720
  // make sure exception is reported in correct bcp range (getfield is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2721
  // next instruction)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2722
  __ incrementq(r13);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2723
  __ null_check(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2724
  switch (state) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2725
  case itos:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2726
    __ movl(rax, Address(rax, rbx, Address::times_1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2727
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2728
  case atos:
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  2729
    __ load_heap_oop(rax, Address(rax, rbx, Address::times_1));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2730
    __ verify_oop(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2731
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2732
  case ftos:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2733
    __ movflt(xmm0, Address(rax, rbx, Address::times_1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2734
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2735
  default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2736
    ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2737
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2738
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2739
  // [jk] not needed currently
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2740
  // if (os::is_MP()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2741
  //   Label notVolatile;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2742
  //   __ movl(rdx, Address(rcx, rdx, Address::times_8,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2743
  //                        in_bytes(constantPoolCacheOopDesc::base_offset() +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2744
  //                                 ConstantPoolCacheEntry::flags_offset())));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2745
  //   __ shrl(rdx, ConstantPoolCacheEntry::volatileField);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2746
  //   __ testl(rdx, 0x1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2747
  //   __ jcc(Assembler::zero, notVolatile);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2748
  //   __ membar(Assembler::LoadLoad);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2749
  //   __ bind(notVolatile);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2750
  // }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2751
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2752
  __ decrementq(r13);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2753
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2754
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2755
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2756
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2757
//-----------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2758
// Calls
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2759
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2760
void TemplateTable::count_calls(Register method, Register temp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2761
  // implemented elsewhere
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2762
  ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2763
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2764
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2765
void TemplateTable::prepare_invoke(Register method,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2766
                                   Register index,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2767
                                   int byte_no,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2768
                                   Bytecodes::Code code) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2769
  // determine flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2770
  const bool is_invokeinterface  = code == Bytecodes::_invokeinterface;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2771
  const bool is_invokevirtual    = code == Bytecodes::_invokevirtual;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2772
  const bool is_invokespecial    = code == Bytecodes::_invokespecial;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2773
  const bool load_receiver       = code != Bytecodes::_invokestatic;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2774
  const bool receiver_null_check = is_invokespecial;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2775
  const bool save_flags = is_invokeinterface || is_invokevirtual;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2776
  // setup registers & access constant pool cache
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2777
  const Register recv   = rcx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2778
  const Register flags  = rdx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2779
  assert_different_registers(method, index, recv, flags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2780
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2781
  // save 'interpreter return address'
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2782
  __ save_bcp();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2783
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2784
  load_invoke_cp_cache_entry(byte_no, method, index, flags, is_invokevirtual);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2785
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2786
  // load receiver if needed (note: no return address pushed yet)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2787
  if (load_receiver) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2788
    __ movl(recv, flags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2789
    __ andl(recv, 0xFF);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2790
    if (TaggedStackInterpreter) __ shll(recv, 1);  // index*2
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  2791
    __ movq(recv, Address(rsp, recv, Address::times_8,
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  2792
                                 -Interpreter::expr_offset_in_bytes(1)));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2793
    __ verify_oop(recv);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2794
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2795
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2796
  // do null check if needed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2797
  if (receiver_null_check) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2798
    __ null_check(recv);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2799
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2800
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2801
  if (save_flags) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2802
    __ movl(r13, flags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2803
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2804
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2805
  // compute return type
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2806
  __ shrl(flags, ConstantPoolCacheEntry::tosBits);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2807
  // Make sure we don't need to mask flags for tosBits after the above shift
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2808
  ConstantPoolCacheEntry::verify_tosBits();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2809
  // load return address
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2810
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2811
    ExternalAddress return_5((address)Interpreter::return_5_addrs_by_index_table());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2812
    ExternalAddress return_3((address)Interpreter::return_3_addrs_by_index_table());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2813
    __ lea(rscratch1, (is_invokeinterface ? return_5 : return_3));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2814
    __ movq(flags, Address(rscratch1, flags, Address::times_8));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2815
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2816
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2817
  // push return address
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2818
  __ pushq(flags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2819
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2820
  // Restore flag field from the constant pool cache, and restore esi
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2821
  // for later null checks.  r13 is the bytecode pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2822
  if (save_flags) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2823
    __ movl(flags, r13);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2824
    __ restore_bcp();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2825
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2826
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2827
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2828
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2829
void TemplateTable::invokevirtual_helper(Register index,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2830
                                         Register recv,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2831
                                         Register flags) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2832
  // Uses temporary registers rax, rdx  assert_different_registers(index, recv, rax, rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2833
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2834
  // Test for an invoke of a final method
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2835
  Label notFinal;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2836
  __ movl(rax, flags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2837
  __ andl(rax, (1 << ConstantPoolCacheEntry::vfinalMethod));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2838
  __ jcc(Assembler::zero, notFinal);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2839
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2840
  const Register method = index;  // method must be rbx
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2841
  assert(method == rbx,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2842
         "methodOop must be rbx for interpreter calling convention");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2843
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2844
  // do the call - the index is actually the method to call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2845
  __ verify_oop(method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2846
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2847
  // It's final, need a null check here!
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2848
  __ null_check(recv);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2849
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2850
  // profile this call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2851
  __ profile_final_call(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2852
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2853
  __ jump_from_interpreted(method, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2854
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2855
  __ bind(notFinal);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2856
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2857
  // get receiver klass
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2858
  __ null_check(recv, oopDesc::klass_offset_in_bytes());
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  2859
  __ load_klass(rax, recv);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2860
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2861
  __ verify_oop(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2862
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2863
  // profile this call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2864
  __ profile_virtual_call(rax, r14, rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2865
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2866
  // get target methodOop & entry point
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2867
  const int base = instanceKlass::vtable_start_offset() * wordSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2868
  assert(vtableEntry::size() * wordSize == 8,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2869
         "adjust the scaling in the code below");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2870
  __ movq(method, Address(rax, index,
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  2871
                                 Address::times_8,
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  2872
                                 base + vtableEntry::method_offset_in_bytes()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2873
  __ movq(rdx, Address(method, methodOopDesc::interpreter_entry_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2874
  __ jump_from_interpreted(method, rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2875
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2876
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2877
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2878
void TemplateTable::invokevirtual(int byte_no) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2879
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2880
  prepare_invoke(rbx, noreg, byte_no, bytecode());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2881
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2882
  // rbx: index
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2883
  // rcx: receiver
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2884
  // rdx: flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2885
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2886
  invokevirtual_helper(rbx, rcx, rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2887
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2888
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2889
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2890
void TemplateTable::invokespecial(int byte_no) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2891
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2892
  prepare_invoke(rbx, noreg, byte_no, bytecode());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2893
  // do the call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2894
  __ verify_oop(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2895
  __ profile_call(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2896
  __ jump_from_interpreted(rbx, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2897
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2898
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2899
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2900
void TemplateTable::invokestatic(int byte_no) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2901
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2902
  prepare_invoke(rbx, noreg, byte_no, bytecode());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2903
  // do the call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2904
  __ verify_oop(rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2905
  __ profile_call(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2906
  __ jump_from_interpreted(rbx, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2907
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2908
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2909
void TemplateTable::fast_invokevfinal(int byte_no) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2910
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2911
  __ stop("fast_invokevfinal not used on amd64");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2912
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2913
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2914
void TemplateTable::invokeinterface(int byte_no) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2915
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2916
  prepare_invoke(rax, rbx, byte_no, bytecode());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2917
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2918
  // rax: Interface
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2919
  // rbx: index
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2920
  // rcx: receiver
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2921
  // rdx: flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2922
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2923
  // Special case of invokeinterface called for virtual method of
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2924
  // java.lang.Object.  See cpCacheOop.cpp for details.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2925
  // This code isn't produced by javac, but could be produced by
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2926
  // another compliant java compiler.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2927
  Label notMethod;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2928
  __ movl(r14, rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2929
  __ andl(r14, (1 << ConstantPoolCacheEntry::methodInterface));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2930
  __ jcc(Assembler::zero, notMethod);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2931
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2932
  invokevirtual_helper(rbx, rcx, rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2933
  __ bind(notMethod);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2934
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2935
  // Get receiver klass into rdx - also a null check
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2936
  __ restore_locals(); // restore r14
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  2937
  __ load_klass(rdx, rcx);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2938
  __ verify_oop(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2939
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2940
  // profile this call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2941
  __ profile_virtual_call(rdx, r13, r14);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2942
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2943
  __ movq(r14, rdx); // Save klassOop in r14
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2944
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2945
  // Compute start of first itableOffsetEntry (which is at the end of
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2946
  // the vtable)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2947
  const int base = instanceKlass::vtable_start_offset() * wordSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2948
  // Get length of vtable
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2949
  assert(vtableEntry::size() * wordSize == 8,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2950
         "adjust the scaling in the code below");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2951
  __ movl(r13, Address(rdx,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2952
                       instanceKlass::vtable_length_offset() * wordSize));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2953
  __ leaq(rdx, Address(rdx, r13, Address::times_8, base));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2954
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2955
  if (HeapWordsPerLong > 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2956
    // Round up to align_object_offset boundary
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2957
    __ round_to_q(rdx, BytesPerLong);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2958
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2959
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2960
  Label entry, search, interface_ok;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2961
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2962
  __ jmpb(entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2963
  __ bind(search);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2964
  __ addq(rdx, itableOffsetEntry::size() * wordSize);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2965
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2966
  __ bind(entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2967
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2968
  // Check that the entry is non-null.  A null entry means that the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2969
  // receiver class doesn't implement the interface, and wasn't the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2970
  // same as the receiver class checked when the interface was
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2971
  // resolved.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2972
  __ pushq(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2973
  __ movq(rdx, Address(rdx, itableOffsetEntry::interface_offset_in_bytes()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2974
  __ testq(rdx, rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2975
  __ jcc(Assembler::notZero, interface_ok);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2976
  // throw exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2977
  __ popq(rdx); // pop saved register first.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2978
  __ popq(rbx); // pop return address (pushed by prepare_invoke)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2979
  __ restore_bcp(); // r13 must be correct for exception handler (was
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2980
                    // destroyed)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2981
  __ restore_locals(); // make sure locals pointer is correct as well
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2982
                       // (was destroyed)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2983
  __ call_VM(noreg, CAST_FROM_FN_PTR(address,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2984
                   InterpreterRuntime::throw_IncompatibleClassChangeError));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2985
  // the call_VM checks for exception, so we should never return here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2986
  __ should_not_reach_here();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2987
  __ bind(interface_ok);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2988
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2989
  __ popq(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2990
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2991
  __ cmpq(rax, Address(rdx, itableOffsetEntry::interface_offset_in_bytes()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2992
  __ jcc(Assembler::notEqual, search);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2993
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2994
  __ movl(rdx, Address(rdx, itableOffsetEntry::offset_offset_in_bytes()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2995
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2996
  __ addq(rdx, r14); // Add offset to klassOop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2997
  assert(itableMethodEntry::size() * wordSize == 8,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2998
         "adjust the scaling in the code below");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2999
  __ movq(rbx, Address(rdx, rbx, Address::times_8));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3000
  // rbx: methodOop to call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3001
  // rcx: receiver
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3002
  // Check for abstract method error
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3003
  // Note: This should be done more efficiently via a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3004
  // throw_abstract_method_error interpreter entry point and a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3005
  // conditional jump to it in case of a null method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3006
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3007
    Label L;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3008
    __ testq(rbx, rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3009
    __ jcc(Assembler::notZero, L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3010
    // throw exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3011
    // note: must restore interpreter registers to canonical
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3012
    //       state for exception handling to work correctly!
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3013
    __ popq(rbx);  // pop return address (pushed by prepare_invoke)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3014
    __ restore_bcp(); // r13 must be correct for exception handler
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3015
                      // (was destroyed)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3016
    __ restore_locals(); // make sure locals pointer is correct as
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3017
                         // well (was destroyed)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3018
    __ call_VM(noreg,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3019
               CAST_FROM_FN_PTR(address,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3020
                             InterpreterRuntime::throw_AbstractMethodError));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3021
    // the call_VM checks for exception, so we should never return here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3022
    __ should_not_reach_here();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3023
    __ bind(L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3024
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3025
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3026
  __ movq(rcx, Address(rbx, methodOopDesc::interpreter_entry_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3027
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3028
  // do the call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3029
  // rcx: receiver
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3030
  // rbx: methodOop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3031
  __ jump_from_interpreted(rbx, rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3032
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3033
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3034
//-----------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3035
// Allocation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3036
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3037
void TemplateTable::_new() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3038
  transition(vtos, atos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3039
  __ get_unsigned_2_byte_index_at_bcp(rdx, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3040
  Label slow_case;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3041
  Label done;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3042
  Label initialize_header;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3043
  Label initialize_object; // including clearing the fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3044
  Label allocate_shared;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3045
  ExternalAddress top((address)Universe::heap()->top_addr());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3046
  ExternalAddress end((address)Universe::heap()->end_addr());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3047
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3048
  __ get_cpool_and_tags(rsi, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3049
  // get instanceKlass
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3050
  __ movq(rsi, Address(rsi, rdx,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3051
                       Address::times_8, sizeof(constantPoolOopDesc)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3052
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3053
  // make sure the class we're about to instantiate has been
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3054
  // resolved. Note: slow_case does a pop of stack, which is why we
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3055
  // loaded class/pushed above
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3056
  const int tags_offset = typeArrayOopDesc::header_size(T_BYTE) * wordSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3057
  __ cmpb(Address(rax, rdx, Address::times_1, tags_offset),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3058
          JVM_CONSTANT_Class);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3059
  __ jcc(Assembler::notEqual, slow_case);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3060
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3061
  // make sure klass is initialized & doesn't have finalizer
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3062
  // make sure klass is fully initialized
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3063
  __ cmpl(Address(rsi,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3064
                  instanceKlass::init_state_offset_in_bytes() +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3065
                  sizeof(oopDesc)),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3066
          instanceKlass::fully_initialized);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3067
  __ jcc(Assembler::notEqual, slow_case);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3068
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3069
  // get instance_size in instanceKlass (scaled to a count of bytes)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3070
  __ movl(rdx,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3071
          Address(rsi,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3072
                  Klass::layout_helper_offset_in_bytes() + sizeof(oopDesc)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3073
  // test to see if it has a finalizer or is malformed in some way
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3074
  __ testl(rdx, Klass::_lh_instance_slow_path_bit);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3075
  __ jcc(Assembler::notZero, slow_case);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3076
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3077
  // Allocate the instance
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3078
  // 1) Try to allocate in the TLAB
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3079
  // 2) if fail and the object is large allocate in the shared Eden
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3080
  // 3) if the above fails (or is not applicable), go to a slow case
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3081
  // (creates a new TLAB, etc.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3082
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3083
  const bool allow_shared_alloc =
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3084
    Universe::heap()->supports_inline_contig_alloc() && !CMSIncrementalMode;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3085
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3086
  if (UseTLAB) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3087
    __ movq(rax, Address(r15_thread, in_bytes(JavaThread::tlab_top_offset())));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3088
    __ leaq(rbx, Address(rax, rdx, Address::times_1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3089
    __ cmpq(rbx, Address(r15_thread, in_bytes(JavaThread::tlab_end_offset())));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3090
    __ jcc(Assembler::above, allow_shared_alloc ? allocate_shared : slow_case);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3091
    __ movq(Address(r15_thread, in_bytes(JavaThread::tlab_top_offset())), rbx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3092
    if (ZeroTLAB) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3093
      // the fields have been already cleared
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3094
      __ jmp(initialize_header);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3095
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3096
      // initialize both the header and fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3097
      __ jmp(initialize_object);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3098
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3099
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3100
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3101
  // Allocation in the shared Eden, if allowed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3102
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3103
  // rdx: instance size in bytes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3104
  if (allow_shared_alloc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3105
    __ bind(allocate_shared);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3106
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3107
    const Register RtopAddr = rscratch1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3108
    const Register RendAddr = rscratch2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3109
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3110
    __ lea(RtopAddr, top);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3111
    __ lea(RendAddr, end);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3112
    __ movq(rax, Address(RtopAddr, 0));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3113
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3114
    // For retries rax gets set by cmpxchgq
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3115
    Label retry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3116
    __ bind(retry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3117
    __ leaq(rbx, Address(rax, rdx, Address::times_1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3118
    __ cmpq(rbx, Address(RendAddr, 0));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3119
    __ jcc(Assembler::above, slow_case);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3120
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3121
    // Compare rax with the top addr, and if still equal, store the new
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3122
    // top addr in rbx at the address of the top addr pointer. Sets ZF if was
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3123
    // equal, and clears it otherwise. Use lock prefix for atomicity on MPs.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3124
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3125
    // rax: object begin
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3126
    // rbx: object end
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3127
    // rdx: instance size in bytes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3128
    if (os::is_MP()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3129
      __ lock();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3130
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3131
    __ cmpxchgq(rbx, Address(RtopAddr, 0));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3132
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3133
    // if someone beat us on the allocation, try again, otherwise continue
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3134
    __ jcc(Assembler::notEqual, retry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3135
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3136
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3137
  if (UseTLAB || Universe::heap()->supports_inline_contig_alloc()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3138
    // The object is initialized before the header.  If the object size is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3139
    // zero, go directly to the header initialization.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3140
    __ bind(initialize_object);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3141
    __ decrementl(rdx, sizeof(oopDesc));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3142
    __ jcc(Assembler::zero, initialize_header);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3143
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3144
    // Initialize object fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3145
    __ xorl(rcx, rcx); // use zero reg to clear memory (shorter code)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3146
    __ shrl(rdx, LogBytesPerLong);  // divide by oopSize to simplify the loop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3147
    {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3148
      Label loop;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3149
      __ bind(loop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3150
      __ movq(Address(rax, rdx, Address::times_8,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3151
                      sizeof(oopDesc) - oopSize),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3152
              rcx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3153
      __ decrementl(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3154
      __ jcc(Assembler::notZero, loop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3155
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3156
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3157
    // initialize object header only.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3158
    __ bind(initialize_header);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3159
    if (UseBiasedLocking) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3160
      __ movq(rscratch1, Address(rsi, Klass::prototype_header_offset_in_bytes() + klassOopDesc::klass_part_offset_in_bytes()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3161
      __ movq(Address(rax, oopDesc::mark_offset_in_bytes()), rscratch1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3162
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3163
      __ movptr(Address(rax, oopDesc::mark_offset_in_bytes()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3164
               (intptr_t) markOopDesc::prototype()); // header (address 0x1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3165
    }
593
803947e176bd 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents: 360
diff changeset
  3166
    __ xorl(rcx, rcx); // use zero reg to clear memory (shorter code)
803947e176bd 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents: 360
diff changeset
  3167
    __ store_klass_gap(rax, rcx);  // zero klass gap for compressed oops
803947e176bd 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents: 360
diff changeset
  3168
    __ store_klass(rax, rsi);      // store klass last
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3169
    __ jmp(done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3170
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3171
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3172
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3173
    SkipIfEqual skip(_masm, &DTraceAllocProbes, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3174
    // Trigger dtrace event for fastpath
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3175
    __ push(atos); // save the return value
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3176
    __ call_VM_leaf(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3177
         CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_object_alloc), rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3178
    __ pop(atos); // restore the return value
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3179
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3180
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3181
  // slow case
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3182
  __ bind(slow_case);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3183
  __ get_constant_pool(c_rarg1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3184
  __ get_unsigned_2_byte_index_at_bcp(c_rarg2, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3185
  call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::_new), c_rarg1, c_rarg2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3186
  __ verify_oop(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3187
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3188
  // continue
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3189
  __ bind(done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3190
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3191
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3192
void TemplateTable::newarray() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3193
  transition(itos, atos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3194
  __ load_unsigned_byte(c_rarg1, at_bcp(1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3195
  __ movl(c_rarg2, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3196
  call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::newarray),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3197
          c_rarg1, c_rarg2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3198
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3199
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3200
void TemplateTable::anewarray() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3201
  transition(itos, atos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3202
  __ get_unsigned_2_byte_index_at_bcp(c_rarg2, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3203
  __ get_constant_pool(c_rarg1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3204
  __ movl(c_rarg3, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3205
  call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::anewarray),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3206
          c_rarg1, c_rarg2, c_rarg3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3207
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3208
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3209
void TemplateTable::arraylength() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3210
  transition(atos, itos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3211
  __ null_check(rax, arrayOopDesc::length_offset_in_bytes());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3212
  __ movl(rax, Address(rax, arrayOopDesc::length_offset_in_bytes()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3213
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3214
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3215
void TemplateTable::checkcast() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3216
  transition(atos, atos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3217
  Label done, is_null, ok_is_subtype, quicked, resolved;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3218
  __ testq(rax, rax); // object is in rax
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3219
  __ jcc(Assembler::zero, is_null);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3220
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3221
  // Get cpool & tags index
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3222
  __ get_cpool_and_tags(rcx, rdx); // rcx=cpool, rdx=tags array
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3223
  __ get_unsigned_2_byte_index_at_bcp(rbx, 1); // rbx=index
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3224
  // See if bytecode has already been quicked
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3225
  __ cmpb(Address(rdx, rbx,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3226
                  Address::times_1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3227
                  typeArrayOopDesc::header_size(T_BYTE) * wordSize),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3228
          JVM_CONSTANT_Class);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3229
  __ jcc(Assembler::equal, quicked);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  3230
  __ push(atos); // save receiver for result, and for GC
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3231
  __ movq(r12, rcx); // save rcx XXX
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3232
  call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::quicken_io_cc));
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  3233
  __ movq(rcx, r12); // restore rcx XXX
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  3234
  __ reinit_heapbase();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3235
  __ pop_ptr(rdx); // restore receiver
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3236
  __ jmpb(resolved);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3237
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3238
  // Get superklass in rax and subklass in rbx
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3239
  __ bind(quicked);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3240
  __ movq(rdx, rax); // Save object in rdx; rax needed for subtype check
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3241
  __ movq(rax, Address(rcx, rbx,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3242
                       Address::times_8, sizeof(constantPoolOopDesc)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3243
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3244
  __ bind(resolved);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  3245
  __ load_klass(rbx, rdx);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3246
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3247
  // Generate subtype check.  Blows rcx, rdi.  Object in rdx.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3248
  // Superklass in rax.  Subklass in rbx.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3249
  __ gen_subtype_check(rbx, ok_is_subtype);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3250
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3251
  // Come here on failure
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3252
  __ push_ptr(rdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3253
  // object is at TOS
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3254
  __ jump(ExternalAddress(Interpreter::_throw_ClassCastException_entry));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3255
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3256
  // Come here on success
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3257
  __ bind(ok_is_subtype);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3258
  __ movq(rax, rdx); // Restore object in rdx
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3259
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3260
  // Collect counts on whether this check-cast sees NULLs a lot or not.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3261
  if (ProfileInterpreter) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3262
    __ jmp(done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3263
    __ bind(is_null);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3264
    __ profile_null_seen(rcx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3265
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3266
    __ bind(is_null);   // same as 'done'
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3267
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3268
  __ bind(done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3269
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3270
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3271
void TemplateTable::instanceof() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3272
  transition(atos, itos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3273
  Label done, is_null, ok_is_subtype, quicked, resolved;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3274
  __ testq(rax, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3275
  __ jcc(Assembler::zero, is_null);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3276
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3277
  // Get cpool & tags index
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3278
  __ get_cpool_and_tags(rcx, rdx); // rcx=cpool, rdx=tags array
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3279
  __ get_unsigned_2_byte_index_at_bcp(rbx, 1); // rbx=index
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3280
  // See if bytecode has already been quicked
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3281
  __ cmpb(Address(rdx, rbx,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3282
                  Address::times_1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3283
                  typeArrayOopDesc::header_size(T_BYTE) * wordSize),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3284
          JVM_CONSTANT_Class);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3285
  __ jcc(Assembler::equal, quicked);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3286
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  3287
  __ push(atos); // save receiver for result, and for GC
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3288
  __ movq(r12, rcx); // save rcx
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3289
  call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::quicken_io_cc));
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  3290
  __ movq(rcx, r12); // restore rcx
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  3291
  __ reinit_heapbase();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3292
  __ pop_ptr(rdx); // restore receiver
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  3293
  __ load_klass(rdx, rdx);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3294
  __ jmpb(resolved);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3295
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3296
  // Get superklass in rax and subklass in rdx
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3297
  __ bind(quicked);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  3298
  __ load_klass(rdx, rax);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3299
  __ movq(rax, Address(rcx, rbx,
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  3300
                              Address::times_8, sizeof(constantPoolOopDesc)));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3301
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3302
  __ bind(resolved);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3303
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3304
  // Generate subtype check.  Blows rcx, rdi
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3305
  // Superklass in rax.  Subklass in rdx.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3306
  __ gen_subtype_check(rdx, ok_is_subtype);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3307
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3308
  // Come here on failure
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3309
  __ xorl(rax, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3310
  __ jmpb(done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3311
  // Come here on success
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3312
  __ bind(ok_is_subtype);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3313
  __ movl(rax, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3314
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3315
  // Collect counts on whether this test sees NULLs a lot or not.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3316
  if (ProfileInterpreter) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3317
    __ jmp(done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3318
    __ bind(is_null);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3319
    __ profile_null_seen(rcx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3320
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3321
    __ bind(is_null);   // same as 'done'
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3322
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3323
  __ bind(done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3324
  // rax = 0: obj == NULL or  obj is not an instanceof the specified klass
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3325
  // rax = 1: obj != NULL and obj is     an instanceof the specified klass
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3326
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3327
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3328
//-----------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3329
// Breakpoints
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3330
void TemplateTable::_breakpoint() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3331
  // Note: We get here even if we are single stepping..
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3332
  // jbug inists on setting breakpoints at every bytecode
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3333
  // even if we are in single step mode.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3334
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3335
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3336
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3337
  // get the unpatched byte code
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3338
  __ get_method(c_rarg1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3339
  __ call_VM(noreg,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3340
             CAST_FROM_FN_PTR(address,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3341
                              InterpreterRuntime::get_original_bytecode_at),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3342
             c_rarg1, r13);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3343
  __ movq(rbx, rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3344
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3345
  // post the breakpoint event
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3346
  __ get_method(c_rarg1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3347
  __ call_VM(noreg,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3348
             CAST_FROM_FN_PTR(address, InterpreterRuntime::_breakpoint),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3349
             c_rarg1, r13);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3350
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3351
  // complete the execution of original bytecode
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3352
  __ dispatch_only_normal(vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3353
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3354
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3355
//-----------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3356
// Exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3357
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3358
void TemplateTable::athrow() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3359
  transition(atos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3360
  __ null_check(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3361
  __ jump(ExternalAddress(Interpreter::throw_exception_entry()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3362
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3363
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3364
//-----------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3365
// Synchronization
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3366
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3367
// Note: monitorenter & exit are symmetric routines; which is reflected
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3368
//       in the assembly code structure as well
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3369
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3370
// Stack layout:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3371
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3372
// [expressions  ] <--- rsp               = expression stack top
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3373
// ..
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3374
// [expressions  ]
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3375
// [monitor entry] <--- monitor block top = expression stack bot
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3376
// ..
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3377
// [monitor entry]
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3378
// [frame data   ] <--- monitor block bot
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3379
// ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3380
// [saved rbp    ] <--- rbp
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3381
void TemplateTable::monitorenter() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3382
  transition(atos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3383
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3384
  // check for NULL object
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3385
  __ null_check(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3386
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3387
  const Address monitor_block_top(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3388
        rbp, frame::interpreter_frame_monitor_block_top_offset * wordSize);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3389
  const Address monitor_block_bot(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3390
        rbp, frame::interpreter_frame_initial_sp_offset * wordSize);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3391
  const int entry_size = frame::interpreter_frame_monitor_size() * wordSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3392
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3393
  Label allocated;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3394
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3395
  // initialize entry pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3396
  __ xorl(c_rarg1, c_rarg1); // points to free slot or NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3397
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3398
  // find a free slot in the monitor block (result in c_rarg1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3399
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3400
    Label entry, loop, exit;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3401
    __ movq(c_rarg3, monitor_block_top); // points to current entry,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3402
                                     // starting with top-most entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3403
    __ leaq(c_rarg2, monitor_block_bot); // points to word before bottom
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3404
                                     // of monitor block
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3405
    __ jmpb(entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3406
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3407
    __ bind(loop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3408
    // check if current entry is used
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3409
    __ cmpq(Address(c_rarg3, BasicObjectLock::obj_offset_in_bytes()), (int) NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3410
    // if not used then remember entry in c_rarg1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3411
    __ cmovq(Assembler::equal, c_rarg1, c_rarg3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3412
    // check if current entry is for same object
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3413
    __ cmpq(rax, Address(c_rarg3, BasicObjectLock::obj_offset_in_bytes()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3414
    // if same object then stop searching
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3415
    __ jccb(Assembler::equal, exit);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3416
    // otherwise advance to next entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3417
    __ addq(c_rarg3, entry_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3418
    __ bind(entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3419
    // check if bottom reached
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3420
    __ cmpq(c_rarg3, c_rarg2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3421
    // if not at bottom then check this entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3422
    __ jcc(Assembler::notEqual, loop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3423
    __ bind(exit);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3424
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3425
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3426
  __ testq(c_rarg1, c_rarg1); // check if a slot has been found
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3427
  __ jcc(Assembler::notZero, allocated); // if found, continue with that one
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3428
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3429
  // allocate one if there's no free slot
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3430
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3431
    Label entry, loop;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3432
    // 1. compute new pointers       // rsp: old expression stack top
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3433
    __ movq(c_rarg1, monitor_block_bot); // c_rarg1: old expression stack bottom
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3434
    __ subq(rsp, entry_size);        // move expression stack top
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3435
    __ subq(c_rarg1, entry_size);        // move expression stack bottom
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3436
    __ movq(c_rarg3, rsp);               // set start value for copy loop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3437
    __ movq(monitor_block_bot, c_rarg1); // set new monitor block bottom
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3438
    __ jmp(entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3439
    // 2. move expression stack contents
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3440
    __ bind(loop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3441
    __ movq(c_rarg2, Address(c_rarg3, entry_size)); // load expression stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3442
                                            // word from old location
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3443
    __ movq(Address(c_rarg3, 0), c_rarg2);  // and store it at new location
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3444
    __ addq(c_rarg3, wordSize);             // advance to next word
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3445
    __ bind(entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3446
    __ cmpq(c_rarg3, c_rarg1);              // check if bottom reached
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3447
    __ jcc(Assembler::notEqual, loop);      // if not at bottom then
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3448
                                            // copy next word
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3449
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3450
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3451
  // call run-time routine
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3452
  // c_rarg1: points to monitor entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3453
  __ bind(allocated);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3454
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3455
  // Increment bcp to point to the next bytecode, so exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3456
  // handling for async. exceptions work correctly.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3457
  // The object has already been poped from the stack, so the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3458
  // expression stack looks correct.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3459
  __ incrementq(r13);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3460
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3461
  // store object
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3462
  __ movq(Address(c_rarg1, BasicObjectLock::obj_offset_in_bytes()), rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3463
  __ lock_object(c_rarg1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3464
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3465
  // check to make sure this monitor doesn't cause stack overflow after locking
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3466
  __ save_bcp();  // in case of exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3467
  __ generate_stack_overflow_check(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3468
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3469
  // The bcp has already been incremented. Just need to dispatch to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3470
  // next instruction.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3471
  __ dispatch_next(vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3472
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3473
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3474
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3475
void TemplateTable::monitorexit() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3476
  transition(atos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3477
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3478
  // check for NULL object
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3479
  __ null_check(rax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3480
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3481
  const Address monitor_block_top(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3482
        rbp, frame::interpreter_frame_monitor_block_top_offset * wordSize);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3483
  const Address monitor_block_bot(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3484
        rbp, frame::interpreter_frame_initial_sp_offset * wordSize);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3485
  const int entry_size = frame::interpreter_frame_monitor_size() * wordSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3486
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3487
  Label found;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3488
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3489
  // find matching slot
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3490
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3491
    Label entry, loop;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3492
    __ movq(c_rarg1, monitor_block_top); // points to current entry,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3493
                                     // starting with top-most entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3494
    __ leaq(c_rarg2, monitor_block_bot); // points to word before bottom
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3495
                                     // of monitor block
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3496
    __ jmpb(entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3497
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3498
    __ bind(loop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3499
    // check if current entry is for same object
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3500
    __ cmpq(rax, Address(c_rarg1, BasicObjectLock::obj_offset_in_bytes()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3501
    // if same object then stop searching
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3502
    __ jcc(Assembler::equal, found);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3503
    // otherwise advance to next entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3504
    __ addq(c_rarg1, entry_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3505
    __ bind(entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3506
    // check if bottom reached
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3507
    __ cmpq(c_rarg1, c_rarg2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3508
    // if not at bottom then check this entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3509
    __ jcc(Assembler::notEqual, loop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3510
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3511
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3512
  // error handling. Unlocking was not block-structured
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3513
  __ call_VM(noreg, CAST_FROM_FN_PTR(address,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3514
                   InterpreterRuntime::throw_illegal_monitor_state_exception));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3515
  __ should_not_reach_here();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3516
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3517
  // call run-time routine
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3518
  // rsi: points to monitor entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3519
  __ bind(found);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3520
  __ push_ptr(rax); // make sure object is on stack (contract with oopMaps)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3521
  __ unlock_object(c_rarg1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3522
  __ pop_ptr(rax); // discard object
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3523
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3524
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3525
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3526
// Wide instructions
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3527
void TemplateTable::wide() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3528
  transition(vtos, vtos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3529
  __ load_unsigned_byte(rbx, at_bcp(1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3530
  __ lea(rscratch1, ExternalAddress((address)Interpreter::_wentry_point));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3531
  __ jmp(Address(rscratch1, rbx, Address::times_8));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3532
  // Note: the r13 increment step is part of the individual wide
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3533
  // bytecode implementations
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3534
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3535
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3536
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3537
// Multi arrays
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3538
void TemplateTable::multianewarray() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3539
  transition(vtos, atos);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3540
  __ load_unsigned_byte(rax, at_bcp(3)); // get number of dimensions
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3541
  // last dim is on top of stack; we want address of first one:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3542
  // first_addr = last_addr + (ndims - 1) * wordSize
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3543
  if (TaggedStackInterpreter) __ shll(rax, 1);  // index*2
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3544
  __ leaq(c_rarg1, Address(rsp, rax, Address::times_8, -wordSize));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3545
  call_VM(rax,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3546
          CAST_FROM_FN_PTR(address, InterpreterRuntime::multianewarray),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3547
          c_rarg1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3548
  __ load_unsigned_byte(rbx, at_bcp(3));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3549
  if (TaggedStackInterpreter) __ shll(rbx, 1);  // index*2
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3550
  __ leaq(rsp, Address(rsp, rbx, Address::times_8));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3551
}