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