hotspot/src/cpu/sparc/vm/assembler_sparc.cpp
author twisti
Fri, 13 Feb 2009 09:09:35 -0800
changeset 2031 24e034f56dcb
parent 1500 bea9a90f3e8f
child 2148 09c7f703773b
permissions -rw-r--r--
6800154: Add comments to long_by_long_mulhi() for better understandability Summary: This patch adds a comment pointing to the Hacker's Delight version of the algorithm plus a verbatim copy of it. Furthermore it adds inline comments. Reviewed-by: kvn, jrose
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
670
ddf3e9583f2f 6719955: Update copyright year
xdono
parents: 605
diff changeset
     2
 * Copyright 1997-2008 Sun Microsystems, Inc.  All Rights Reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    19
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    20
 * CA 95054 USA or visit www.sun.com if you need additional information or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    21
 * have any questions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
489c9b5090e2 Initial load
duke
parents:
diff changeset
    25
#include "incls/_precompiled.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    26
#include "incls/_assembler_sparc.cpp.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    27
489c9b5090e2 Initial load
duke
parents:
diff changeset
    28
// Implementation of Address
489c9b5090e2 Initial load
duke
parents:
diff changeset
    29
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
Address::Address( addr_type t, int which ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
  switch (t) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
   case extra_in_argument:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
   case extra_out_argument:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
     _base = t == extra_in_argument ? FP : SP;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
     _hi   = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
// Warning:  In LP64 mode, _disp will occupy more than 10 bits.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
//           This is inconsistent with the other constructors but op
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
//           codes such as ld or ldx, only access disp() to get their
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
//           simm13 argument.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
     _disp = ((which - Argument::n_register_parameters + frame::memory_parameter_word_sp_offset) * BytesPerWord) + STACK_BIAS;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
   default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
    ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
static const char* argumentNames[][2] = {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
  {"A0","P0"}, {"A1","P1"}, {"A2","P2"}, {"A3","P3"}, {"A4","P4"},
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
  {"A5","P5"}, {"A6","P6"}, {"A7","P7"}, {"A8","P8"}, {"A9","P9"},
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
  {"A(n>9)","P(n>9)"}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
const char* Argument::name() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
  int nofArgs = sizeof argumentNames / sizeof argumentNames[0];
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
  int num = number();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
  if (num >= nofArgs)  num = nofArgs - 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
  return argumentNames[num][is_in() ? 1 : 0];
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
void Assembler::print_instruction(int inst) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
  const char* s;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
  switch (inv_op(inst)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
  default:         s = "????"; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
  case call_op:    s = "call"; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
  case branch_op:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
    switch (inv_op2(inst)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
      case bpr_op2:    s = "bpr";  break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
      case fb_op2:     s = "fb";   break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
      case fbp_op2:    s = "fbp";  break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
      case br_op2:     s = "br";   break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
      case bp_op2:     s = "bp";   break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
      case cb_op2:     s = "cb";   break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
      default:         s = "????"; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  ::tty->print("%s", s);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
// Patch instruction inst at offset inst_pos to refer to dest_pos
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
// and return the resulting instruction.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
// We should have pcs, not offsets, but since all is relative, it will work out
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
// OK.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
int Assembler::patched_branch(int dest_pos, int inst, int inst_pos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
  int m; // mask for displacement field
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  int v; // new value for displacement field
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
  const int word_aligned_ones = -4;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  switch (inv_op(inst)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  default: ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  case call_op:    m = wdisp(word_aligned_ones, 0, 30);  v = wdisp(dest_pos, inst_pos, 30); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  case branch_op:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
    switch (inv_op2(inst)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
      case bpr_op2:    m = wdisp16(word_aligned_ones, 0);      v = wdisp16(dest_pos, inst_pos);     break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
      case fbp_op2:    m = wdisp(  word_aligned_ones, 0, 19);  v = wdisp(  dest_pos, inst_pos, 19); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
      case bp_op2:     m = wdisp(  word_aligned_ones, 0, 19);  v = wdisp(  dest_pos, inst_pos, 19); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
      case fb_op2:     m = wdisp(  word_aligned_ones, 0, 22);  v = wdisp(  dest_pos, inst_pos, 22); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
      case br_op2:     m = wdisp(  word_aligned_ones, 0, 22);  v = wdisp(  dest_pos, inst_pos, 22); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
      case cb_op2:     m = wdisp(  word_aligned_ones, 0, 22);  v = wdisp(  dest_pos, inst_pos, 22); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
      default: ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  return  inst & ~m  |  v;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
// Return the offset of the branch destionation of instruction inst
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
// at offset pos.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
// Should have pcs, but since all is relative, it works out.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
int Assembler::branch_destination(int inst, int pos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
  int r;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
  switch (inv_op(inst)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  default: ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
  case call_op:        r = inv_wdisp(inst, pos, 30);  break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  case branch_op:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
    switch (inv_op2(inst)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
      case bpr_op2:    r = inv_wdisp16(inst, pos);    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
      case fbp_op2:    r = inv_wdisp(  inst, pos, 19);  break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
      case bp_op2:     r = inv_wdisp(  inst, pos, 19);  break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
      case fb_op2:     r = inv_wdisp(  inst, pos, 22);  break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
      case br_op2:     r = inv_wdisp(  inst, pos, 22);  break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
      case cb_op2:     r = inv_wdisp(  inst, pos, 22);  break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
      default: ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  return r;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
int AbstractAssembler::code_fill_byte() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  return 0x00;                  // illegal instruction 0x00000000
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
   133
Assembler::Condition Assembler::reg_cond_to_cc_cond(Assembler::RCondition in) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
   134
  switch (in) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
   135
  case rc_z:   return equal;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
   136
  case rc_lez: return lessEqual;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
   137
  case rc_lz:  return less;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
   138
  case rc_nz:  return notEqual;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
   139
  case rc_gz:  return greater;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
   140
  case rc_gez: return greaterEqual;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
   141
  default:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
   142
    ShouldNotReachHere();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
   143
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
   144
  return equal;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
   145
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
   146
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
// Generate a bunch 'o stuff (including v9's
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
void Assembler::test_v9() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  add(    G0, G1, G2 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  add(    G3,  0, G4 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  addcc(  G5, G6, G7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  addcc(  I0,  1, I1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  addc(   I2, I3, I4 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  addc(   I5, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  addccc( I7, L0, L1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  addccc( L2, (1 << 12) - 2, L3 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  Label lbl1, lbl2, lbl3;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  bind(lbl1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  bpr( rc_z,    true, pn, L4, pc(),  relocInfo::oop_type );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
  bpr( rc_lez, false, pt, L5, lbl1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
  fb( f_never,     true, pc() + 4,  relocInfo::none);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  fb( f_notEqual, false, lbl2 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  fbp( f_notZero,        true, fcc0, pn, pc() - 4,  relocInfo::none);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  fbp( f_lessOrGreater, false, fcc1, pt, lbl3 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  br( equal,  true, pc() + 1024, relocInfo::none);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  br( lessEqual, false, lbl1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  br( never, false, lbl1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
  bp( less,               true, icc, pn, pc(), relocInfo::none);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  bp( lessEqualUnsigned, false, xcc, pt, lbl2 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  call( pc(), relocInfo::none);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  call( lbl3 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  casa(  L6, L7, O0 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  casxa( O1, O2, O3, 0 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
  udiv(   O4, O5, O7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  udiv(   G0, (1 << 12) - 1, G1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
  sdiv(   G1, G2, G3 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
  sdiv(   G4, -((1 << 12) - 1), G5 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  udivcc( G6, G7, I0 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  udivcc( I1, -((1 << 12) - 2), I2 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  sdivcc( I3, I4, I5 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
  sdivcc( I6, -((1 << 12) - 0), I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
  done();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
  retry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
  fadd( FloatRegisterImpl::S, F0,  F1, F2 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
  fsub( FloatRegisterImpl::D, F34, F0, F62 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
  fcmp(  FloatRegisterImpl::Q, fcc0, F0, F60);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  fcmpe( FloatRegisterImpl::S, fcc1, F31, F30);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
  ftox( FloatRegisterImpl::D, F2, F4 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
  ftoi( FloatRegisterImpl::Q, F4, F8 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
  ftof( FloatRegisterImpl::S, FloatRegisterImpl::Q, F3, F12 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  fxtof( FloatRegisterImpl::S, F4, F5 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
  fitof( FloatRegisterImpl::D, F6, F8 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
  fmov( FloatRegisterImpl::Q, F16, F20 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
  fneg( FloatRegisterImpl::S, F6, F7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
  fabs( FloatRegisterImpl::D, F10, F12 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
  fmul( FloatRegisterImpl::Q,  F24, F28, F32 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
  fmul( FloatRegisterImpl::S,  FloatRegisterImpl::D,  F8, F9, F14 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
  fdiv( FloatRegisterImpl::S,  F10, F11, F12 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
  fsqrt( FloatRegisterImpl::S, F13, F14 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  flush( L0, L1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
  flush( L2, -1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  flushw();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
  illtrap( (1 << 22) - 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
  impdep1( 17, (1 << 19) - 1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
  impdep2( 3,  0 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
  jmpl( L3, L4, L5 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
  jmpl( L6, -1, L7, Relocation::spec_simple(relocInfo::none));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
  ldf(    FloatRegisterImpl::S, O0, O1, F15 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
  ldf(    FloatRegisterImpl::D, O2, -1, F14 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  ldfsr(  O3, O4 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
  ldfsr(  O5, -1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
  ldxfsr( O6, O7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
  ldxfsr( I0, -1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  ldfa(  FloatRegisterImpl::D, I1, I2, 1, F16 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
  ldfa(  FloatRegisterImpl::Q, I3, -1,    F36 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
  ldsb(  I4, I5, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
  ldsb(  I7, -1, G0 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
  ldsh(  G1, G3, G4 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
  ldsh(  G5, -1, G6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
  ldsw(  G7, L0, L1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  ldsw(  L2, -1, L3 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
  ldub(  L4, L5, L6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
  ldub(  L7, -1, O0 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
  lduh(  O1, O2, O3 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
  lduh(  O4, -1, O5 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
  lduw(  O6, O7, G0 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
  lduw(  G1, -1, G2 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
  ldx(   G3, G4, G5 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
  ldx(   G6, -1, G7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
  ldd(   I0, I1, I2 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
  ldd(   I3, -1, I4 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
  ldsba(  I5, I6, 2, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
  ldsba(  L0, -1, L1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
  ldsha(  L2, L3, 3, L4 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
  ldsha(  L5, -1, L6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
  ldswa(  L7, O0, (1 << 8) - 1, O1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
  ldswa(  O2, -1, O3 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
  lduba(  O4, O5, 0, O6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
  lduba(  O7, -1, I0 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
  lduha(  I1, I2, 1, I3 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
  lduha(  I4, -1, I5 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
  lduwa(  I6, I7, 2, L0 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
  lduwa(  L1, -1, L2 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
  ldxa(   L3, L4, 3, L5 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
  ldxa(   L6, -1, L7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  ldda(   G0, G1, 4, G2 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
  ldda(   G3, -1, G4 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
  ldstub(  G5, G6, G7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  ldstub(  O0, -1, O1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  ldstuba( O2, O3, 5, O4 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
  ldstuba( O5, -1, O6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  and3(    I0, L0, O0 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
  and3(    G7, -1, O7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  andcc(   L2, I2, G2 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
  andcc(   L4, -1, G4 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
  andn(    I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
  andn(    I6, -1, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
  andncc(  I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
  andncc(  I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
  or3(     I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
  or3(     I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
  orcc(    I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
  orcc(    I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  orn(     I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
  orn(     I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
  orncc(   I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
  orncc(   I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
  xor3(    I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  xor3(    I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
  xorcc(   I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
  xorcc(   I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
  xnor(    I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
  xnor(    I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
  xnorcc(  I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  xnorcc(  I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
  membar( Membar_mask_bits(StoreStore | LoadStore | StoreLoad | LoadLoad | Sync | MemIssue | Lookaside ) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  membar( StoreStore );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
  membar( LoadStore );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
  membar( StoreLoad );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
  membar( LoadLoad );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
  membar( Sync );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
  membar( MemIssue );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
  membar( Lookaside );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  fmov( FloatRegisterImpl::S, f_ordered,  true, fcc2, F16, F17 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
  fmov( FloatRegisterImpl::D, rc_lz, L5, F18, F20 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
  movcc( overflowClear,  false, icc, I6, L4 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  movcc( f_unorderedOrEqual, true, fcc2, (1 << 10) - 1, O0 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  movr( rc_nz, I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  movr( rc_gz, L1, -1,  L2 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
  mulx(  I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
  mulx(  I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
  sdivx( I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
  sdivx( I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
  udivx( I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
  udivx( I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
  umul(   I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
  umul(   I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
  smul(   I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
  smul(   I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
  umulcc( I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
  umulcc( I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
  smulcc( I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
  smulcc( I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
  mulscc(   I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
  mulscc(   I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
  nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
  popc( G0,  G1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
  popc( -1, G2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
  prefetch(   L1, L2,    severalReads );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
  prefetch(   L3, -1,    oneRead );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
  prefetcha(  O3, O2, 6, severalWritesAndPossiblyReads );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  prefetcha(  G2, -1,    oneWrite );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
  rett( I7, I7);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
  rett( G0, -1, relocInfo::none);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
  save(    I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
  save(    I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
  restore( I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
  restore( I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
  saved();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
  restored();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
  sethi( 0xaaaaaaaa, I3, Relocation::spec_simple(relocInfo::none));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
  sll(  I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
  sll(  I7, 31, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
  srl(  I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
  srl(  I7,  0, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
  sra(  I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
  sra(  I7, 30, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  sllx( I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
  sllx( I7, 63, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
  srlx( I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
  srlx( I7,  0, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
  srax( I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
  srax( I7, 62, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
  sir( -1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
  stbar();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
  stf(    FloatRegisterImpl::Q, F40, G0, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
  stf(    FloatRegisterImpl::S, F18, I3, -1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
  stfsr(  L1, L2 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
  stfsr(  I7, -1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
  stxfsr( I6, I5 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
  stxfsr( L4, -1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  stfa(  FloatRegisterImpl::D, F22, I6, I7, 7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
  stfa(  FloatRegisterImpl::Q, F44, G0, -1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
  stb(  L5, O2, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
  stb(  I7, I6, -1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
  sth(  L5, O2, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
  sth(  I7, I6, -1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
  stw(  L5, O2, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
  stw(  I7, I6, -1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
  stx(  L5, O2, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
  stx(  I7, I6, -1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
  std(  L5, O2, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
  std(  I7, I6, -1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
  stba(  L5, O2, I7, 8 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
  stba(  I7, I6, -1    );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
  stha(  L5, O2, I7, 9 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
  stha(  I7, I6, -1    );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
  stwa(  L5, O2, I7, 0 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
  stwa(  I7, I6, -1    );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
  stxa(  L5, O2, I7, 11 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
  stxa(  I7, I6, -1     );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
  stda(  L5, O2, I7, 12 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
  stda(  I7, I6, -1     );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
  sub(    I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
  sub(    I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
  subcc(  I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
  subcc(  I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
  subc(   I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  subc(   I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
  subccc( I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
  subccc( I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
  swap( I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
  swap( I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
  swapa(   G0, G1, 13, G2 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
  swapa(   I7, -1,     I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
  taddcc(    I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
  taddcc(    I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
  taddcctv(  I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
  taddcctv(  I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
  tsubcc(    I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
  tsubcc(    I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
  tsubcctv(  I5, I6, I7 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
  tsubcctv(  I7, -1, I6 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
  trap( overflowClear, xcc, G0, G1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
  trap( lessEqual,     icc, I7, 17 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
  bind(lbl2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
  bind(lbl3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
  code()->decode();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
// Generate a bunch 'o stuff unique to V8
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
void Assembler::test_v8_onlys() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
  Label lbl1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
  cb( cp_0or1or2, false, pc() - 4, relocInfo::none);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
  cb( cp_never,    true, lbl1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  cpop1(1, 2, 3, 4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
  cpop2(5, 6, 7, 8);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
  ldc( I0, I1, 31);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
  ldc( I2, -1,  0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
  lddc( I4, I4, 30);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
  lddc( I6,  0, 1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
  ldcsr( L0, L1, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
  ldcsr( L1, (1 << 12) - 1, 17 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
  stc( 31, L4, L5);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
  stc( 30, L6, -(1 << 12) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
  stdc( 0, L7, G0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
  stdc( 1, G1, 0 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
  stcsr( 16, G2, G3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
  stcsr( 17, G4, 1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
  stdcq( 4, G5, G6);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
  stdcq( 5, G7, -1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
  bind(lbl1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
  code()->decode();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
// Implementation of MacroAssembler
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
void MacroAssembler::null_check(Register reg, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
  if (needs_explicit_null_check((intptr_t)offset)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
    // provoke OS NULL exception if reg = NULL by
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
    // accessing M[reg] w/o changing any registers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
    ld_ptr(reg, 0, G0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
  else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
    // nothing to do, (later) access of M[reg + offset]
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
    // will provoke OS NULL exception if reg = NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
// Ring buffer jumps
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
void MacroAssembler::ret(  bool trace )   { if (trace) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
                                                    mov(I7, O7); // traceable register
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
                                                    JMP(O7, 2 * BytesPerInstWord);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
                                                  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
                                                    jmpl( I7, 2 * BytesPerInstWord, G0 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
                                                  }
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 MacroAssembler::retl( bool trace )  { if (trace) JMP(O7, 2 * BytesPerInstWord);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
                                                 else jmpl( O7, 2 * BytesPerInstWord, G0 ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
#endif /* PRODUCT */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
void MacroAssembler::jmp2(Register r1, Register r2, const char* file, int line ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
  assert_not_delayed();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
  // This can only be traceable if r1 & r2 are visible after a window save
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
  if (TraceJumps) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
    save_frame(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
    verify_thread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
    ld(G2_thread, in_bytes(JavaThread::jmp_ring_index_offset()), O0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
    add(G2_thread, in_bytes(JavaThread::jmp_ring_offset()), O1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
    sll(O0, exact_log2(4*sizeof(intptr_t)), O2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
    add(O2, O1, O1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
    add(r1->after_save(), r2->after_save(), O2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
    set((intptr_t)file, O3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
    set(line, O4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
    Label L;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
    // get nearby pc, store jmp target
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
    call(L, relocInfo::none);  // No relocation for call to pc+0x8
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
    delayed()->st(O2, O1, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
    bind(L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
    // store nearby pc
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
    st(O7, O1, sizeof(intptr_t));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
    // store file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
    st(O3, O1, 2*sizeof(intptr_t));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
    // store line
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
    st(O4, O1, 3*sizeof(intptr_t));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
    add(O0, 1, O0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
    and3(O0, JavaThread::jump_ring_buffer_size  - 1, O0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
    st(O0, G2_thread, in_bytes(JavaThread::jmp_ring_index_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
    restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
#endif /* PRODUCT */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
  jmpl(r1, r2, G0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
void MacroAssembler::jmp(Register r1, int offset, const char* file, int line ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
  assert_not_delayed();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
  // This can only be traceable if r1 is visible after a window save
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
  if (TraceJumps) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
    save_frame(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
    verify_thread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
    ld(G2_thread, in_bytes(JavaThread::jmp_ring_index_offset()), O0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
    add(G2_thread, in_bytes(JavaThread::jmp_ring_offset()), O1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
    sll(O0, exact_log2(4*sizeof(intptr_t)), O2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
    add(O2, O1, O1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
    add(r1->after_save(), offset, O2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
    set((intptr_t)file, O3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
    set(line, O4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
    Label L;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
    // get nearby pc, store jmp target
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
    call(L, relocInfo::none);  // No relocation for call to pc+0x8
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
    delayed()->st(O2, O1, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
    bind(L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
    // store nearby pc
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
    st(O7, O1, sizeof(intptr_t));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
    // store file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
    st(O3, O1, 2*sizeof(intptr_t));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
    // store line
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
    st(O4, O1, 3*sizeof(intptr_t));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
    add(O0, 1, O0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
    and3(O0, JavaThread::jump_ring_buffer_size  - 1, O0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
    st(O0, G2_thread, in_bytes(JavaThread::jmp_ring_index_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
    restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
#endif /* PRODUCT */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
  jmp(r1, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
// This code sequence is relocatable to any address, even on LP64.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
void MacroAssembler::jumpl( Address& a, Register d, int offset, const char* file, int line ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
  assert_not_delayed();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
  // Force fixed length sethi because NativeJump and NativeFarCall don't handle
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
  // variable length instruction streams.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
  sethi(a, /*ForceRelocatable=*/ true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
  if (TraceJumps) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
    // Must do the add here so relocation can find the remainder of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
    // value to be relocated.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
    add(a.base(), a.disp() + offset, a.base(), a.rspec(offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
    save_frame(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
    verify_thread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
    ld(G2_thread, in_bytes(JavaThread::jmp_ring_index_offset()), O0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
    add(G2_thread, in_bytes(JavaThread::jmp_ring_offset()), O1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
    sll(O0, exact_log2(4*sizeof(intptr_t)), O2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
    add(O2, O1, O1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
    set((intptr_t)file, O3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
    set(line, O4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
    Label L;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
    // get nearby pc, store jmp target
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
    call(L, relocInfo::none);  // No relocation for call to pc+0x8
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
    delayed()->st(a.base()->after_save(), O1, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
    bind(L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
    // store nearby pc
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
    st(O7, O1, sizeof(intptr_t));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
    // store file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
    st(O3, O1, 2*sizeof(intptr_t));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
    // store line
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
    st(O4, O1, 3*sizeof(intptr_t));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
    add(O0, 1, O0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
    and3(O0, JavaThread::jump_ring_buffer_size  - 1, O0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
    st(O0, G2_thread, in_bytes(JavaThread::jmp_ring_index_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
    restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
    jmpl(a.base(), G0, d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
    jmpl(a, d, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
#endif /* PRODUCT */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
    jmpl(a, d, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
void MacroAssembler::jump( Address& a, int offset, const char* file, int line ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
  jumpl( a, G0, offset, file, line );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
// Convert to C varargs format
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
void MacroAssembler::set_varargs( Argument inArg, Register d ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
  // spill register-resident args to their memory slots
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
  // (SPARC calling convention requires callers to have already preallocated these)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
  // Note that the inArg might in fact be an outgoing argument,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
  // if a leaf routine or stub does some tricky argument shuffling.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
  // This routine must work even though one of the saved arguments
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
  // is in the d register (e.g., set_varargs(Argument(0, false), O0)).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
  for (Argument savePtr = inArg;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
       savePtr.is_register();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
       savePtr = savePtr.successor()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
    st_ptr(savePtr.as_register(), savePtr.address_in_frame());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
  // return the address of the first memory slot
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
  add(inArg.address_in_frame(), d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
// Conditional breakpoint (for assertion checks in assembly code)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
void MacroAssembler::breakpoint_trap(Condition c, CC cc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
  trap(c, cc, G0, ST_RESERVED_FOR_USER_0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
// We want to use ST_BREAKPOINT here, but the debugger is confused by it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
void MacroAssembler::breakpoint_trap() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
  trap(ST_RESERVED_FOR_USER_0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
// flush windows (except current) using flushw instruction if avail.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
void MacroAssembler::flush_windows() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
  if (VM_Version::v9_instructions_work())  flushw();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
  else                                     flush_windows_trap();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
// Write serialization page so VM thread can do a pseudo remote membar
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
// We use the current thread pointer to calculate a thread specific
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
// offset to write to within the page. This minimizes bus traffic
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
// due to cache line collision.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
void MacroAssembler::serialize_memory(Register thread, Register tmp1, Register tmp2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
  Address mem_serialize_page(tmp1, os::get_memory_serialize_page());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
  srl(thread, os::get_serialize_page_shift_count(), tmp2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
  if (Assembler::is_simm13(os::vm_page_size())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
    and3(tmp2, (os::vm_page_size() - sizeof(int)), tmp2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
  else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
    set((os::vm_page_size() - sizeof(int)), tmp1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
    and3(tmp2, tmp1, tmp2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
  load_address(mem_serialize_page);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
  st(G0, tmp1, tmp2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
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 MacroAssembler::enter() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
  Unimplemented();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
void MacroAssembler::leave() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
  Unimplemented();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
void MacroAssembler::mult(Register s1, Register s2, Register d) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
  if(VM_Version::v9_instructions_work()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
    mulx (s1, s2, d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
    smul (s1, s2, d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
void MacroAssembler::mult(Register s1, int simm13a, Register d) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
  if(VM_Version::v9_instructions_work()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
    mulx (s1, simm13a, d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
    smul (s1, simm13a, d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
void MacroAssembler::read_ccr_v8_assert(Register ccr_save) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
  const Register s1 = G3_scratch;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
  const Register s2 = G4_scratch;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
  Label get_psr_test;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
  // Get the condition codes the V8 way.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
  read_ccr_trap(s1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
  mov(ccr_save, s2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
  // This is a test of V8 which has icc but not xcc
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
  // so mask off the xcc bits
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
  and3(s2, 0xf, s2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
  // Compare condition codes from the V8 and V9 ways.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
  subcc(s2, s1, G0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
  br(Assembler::notEqual, true, Assembler::pt, get_psr_test);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
  delayed()->breakpoint_trap();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
  bind(get_psr_test);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
void MacroAssembler::write_ccr_v8_assert(Register ccr_save) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
  const Register s1 = G3_scratch;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
  const Register s2 = G4_scratch;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
  Label set_psr_test;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
  // Write out the saved condition codes the V8 way
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
  write_ccr_trap(ccr_save, s1, s2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
  // Read back the condition codes using the V9 instruction
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
  rdccr(s1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
  mov(ccr_save, s2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
  // This is a test of V8 which has icc but not xcc
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
  // so mask off the xcc bits
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
  and3(s2, 0xf, s2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
  and3(s1, 0xf, s1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
  // Compare the V8 way with the V9 way.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
  subcc(s2, s1, G0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
  br(Assembler::notEqual, true, Assembler::pt, set_psr_test);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
  delayed()->breakpoint_trap();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
  bind(set_psr_test);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
#define read_ccr_v8_assert(x)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
#define write_ccr_v8_assert(x)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
#endif // ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
void MacroAssembler::read_ccr(Register ccr_save) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
  if (VM_Version::v9_instructions_work()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
    rdccr(ccr_save);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
    // Test code sequence used on V8.  Do not move above rdccr.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
    read_ccr_v8_assert(ccr_save);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
    read_ccr_trap(ccr_save);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
void MacroAssembler::write_ccr(Register ccr_save) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
  if (VM_Version::v9_instructions_work()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
    // Test code sequence used on V8.  Do not move below wrccr.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
    write_ccr_v8_assert(ccr_save);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
    wrccr(ccr_save);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
    const Register temp_reg1 = G3_scratch;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
    const Register temp_reg2 = G4_scratch;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
    write_ccr_trap(ccr_save, temp_reg1, temp_reg2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
// Calls to C land
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
// a hook for debugging
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
static Thread* reinitialize_thread() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
  return ThreadLocalStorage::thread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
#define reinitialize_thread ThreadLocalStorage::thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
address last_get_thread = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
// call this when G2_thread is not known to be valid
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
void MacroAssembler::get_thread() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
  save_frame(0);                // to avoid clobbering O0
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
  mov(G1, L0);                  // avoid clobbering G1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
  mov(G5_method, L1);           // avoid clobbering G5
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
  mov(G3, L2);                  // avoid clobbering G3 also
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
  mov(G4, L5);                  // avoid clobbering G4
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
  Address last_get_thread_addr(L3, (address)&last_get_thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
  sethi(last_get_thread_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
  inc(L4, get_pc(L4) + 2 * BytesPerInstWord); // skip getpc() code + inc + st_ptr to point L4 at call
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
  st_ptr(L4, last_get_thread_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
  call(CAST_FROM_FN_PTR(address, reinitialize_thread), relocInfo::runtime_call_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
  mov(L0, G1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
  mov(L1, G5_method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
  mov(L2, G3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
  mov(L5, G4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
  restore(O0, 0, G2_thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
static Thread* verify_thread_subroutine(Thread* gthread_value) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
  Thread* correct_value = ThreadLocalStorage::thread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
  guarantee(gthread_value == correct_value, "G2_thread value must be the thread");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
  return correct_value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
void MacroAssembler::verify_thread() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
  if (VerifyThread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
    // NOTE: this chops off the heads of the 64-bit O registers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
#ifdef CC_INTERP
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
    save_frame(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
    // make sure G2_thread contains the right value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
    save_frame_and_mov(0, Lmethod, Lmethod);   // to avoid clobbering O0 (and propagate Lmethod for -Xprof)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
    mov(G1, L1);                // avoid clobbering G1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
    // G2 saved below
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
    mov(G3, L3);                // avoid clobbering G3
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
    mov(G4, L4);                // avoid clobbering G4
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
    mov(G5_method, L5);         // avoid clobbering G5_method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
#endif /* CC_INTERP */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
#if defined(COMPILER2) && !defined(_LP64)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
    // Save & restore possible 64-bit Long arguments in G-regs
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
    srlx(G1,32,L0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
    srlx(G4,32,L6);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
    call(CAST_FROM_FN_PTR(address,verify_thread_subroutine), relocInfo::runtime_call_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
    delayed()->mov(G2_thread, O0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
    mov(L1, G1);                // Restore G1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
    // G2 restored below
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
    mov(L3, G3);                // restore G3
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
    mov(L4, G4);                // restore G4
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
    mov(L5, G5_method);         // restore G5_method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
#if defined(COMPILER2) && !defined(_LP64)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
    // Save & restore possible 64-bit Long arguments in G-regs
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
    sllx(L0,32,G2);             // Move old high G1 bits high in G2
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
    sllx(G1, 0,G1);             // Clear current high G1 bits
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
    or3 (G1,G2,G1);             // Recover 64-bit G1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
    sllx(L6,32,G2);             // Move old high G4 bits high in G2
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
    sllx(G4, 0,G4);             // Clear current high G4 bits
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
    or3 (G4,G2,G4);             // Recover 64-bit G4
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
    restore(O0, 0, G2_thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
void MacroAssembler::save_thread(const Register thread_cache) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
  verify_thread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
  if (thread_cache->is_valid()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
    assert(thread_cache->is_local() || thread_cache->is_in(), "bad volatile");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
    mov(G2_thread, thread_cache);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
  if (VerifyThread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
    // smash G2_thread, as if the VM were about to anyway
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
    set(0x67676767, G2_thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
void MacroAssembler::restore_thread(const Register thread_cache) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
  if (thread_cache->is_valid()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
    assert(thread_cache->is_local() || thread_cache->is_in(), "bad volatile");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
    mov(thread_cache, G2_thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
    verify_thread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
    // do it the slow way
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
    get_thread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
489c9b5090e2 Initial load
duke
parents:
diff changeset
   919
// %%% maybe get rid of [re]set_last_Java_frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
void MacroAssembler::set_last_Java_frame(Register last_java_sp, Register last_Java_pc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
  assert_not_delayed();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
  Address flags(G2_thread,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
                0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
                in_bytes(JavaThread::frame_anchor_offset()) +
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
                         in_bytes(JavaFrameAnchor::flags_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
  Address pc_addr(G2_thread,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
                  0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
                  in_bytes(JavaThread::last_Java_pc_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
  // Always set last_Java_pc and flags first because once last_Java_sp is visible
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
  // has_last_Java_frame is true and users will look at the rest of the fields.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
  // (Note: flags should always be zero before we get here so doesn't need to be set.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
  // Verify that flags was zeroed on return to Java
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
  Label PcOk;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   937
  save_frame(0);                // to avoid clobbering O0
489c9b5090e2 Initial load
duke
parents:
diff changeset
   938
  ld_ptr(pc_addr, L0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   939
  tst(L0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
#ifdef _LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
  brx(Assembler::zero, false, Assembler::pt, PcOk);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
  br(Assembler::zero, false, Assembler::pt, PcOk);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   944
#endif // _LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
  delayed() -> nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   946
  stop("last_Java_pc not zeroed before leaving Java");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   947
  bind(PcOk);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   948
489c9b5090e2 Initial load
duke
parents:
diff changeset
   949
  // Verify that flags was zeroed on return to Java
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
  Label FlagsOk;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
  ld(flags, L0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   952
  tst(L0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   953
  br(Assembler::zero, false, Assembler::pt, FlagsOk);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
  delayed() -> restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   955
  stop("flags not zeroed before leaving Java");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   956
  bind(FlagsOk);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
#endif /* ASSERT */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
  // When returning from calling out from Java mode the frame anchor's last_Java_pc
489c9b5090e2 Initial load
duke
parents:
diff changeset
   960
  // will always be set to NULL. It is set here so that if we are doing a call to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
  // native (not VM) that we capture the known pc and don't have to rely on the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
  // native call having a standard frame linkage where we can find the pc.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
  if (last_Java_pc->is_valid()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
    st_ptr(last_Java_pc, pc_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   967
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
#ifdef _LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
  // Make sure that we have an odd stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
  Label StackOk;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
  andcc(last_java_sp, 0x01, G0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
  br(Assembler::notZero, false, Assembler::pt, StackOk);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
  delayed() -> nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
  stop("Stack Not Biased in set_last_Java_frame");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   976
  bind(StackOk);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
#endif // ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
  assert( last_java_sp != G4_scratch, "bad register usage in set_last_Java_frame");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
  add( last_java_sp, STACK_BIAS, G4_scratch );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
  st_ptr(G4_scratch,    Address(G2_thread, 0, in_bytes(JavaThread::last_Java_sp_offset())));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
  st_ptr(last_java_sp,    Address(G2_thread, 0, in_bytes(JavaThread::last_Java_sp_offset())));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
#endif // _LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
void MacroAssembler::reset_last_Java_frame(void) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
  assert_not_delayed();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
  Address sp_addr(G2_thread, 0, in_bytes(JavaThread::last_Java_sp_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
  Address pc_addr(G2_thread,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
                  0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
                  in_bytes(JavaThread::frame_anchor_offset()) + in_bytes(JavaFrameAnchor::last_Java_pc_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
  Address flags(G2_thread,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
                0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
                in_bytes(JavaThread::frame_anchor_offset()) + in_bytes(JavaFrameAnchor::flags_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
  // check that it WAS previously set
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
#ifdef CC_INTERP
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
    save_frame(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
    save_frame_and_mov(0, Lmethod, Lmethod);     // Propagate Lmethod to helper frame for -Xprof
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
#endif /* CC_INTERP */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
    ld_ptr(sp_addr, L0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
    tst(L0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
    breakpoint_trap(Assembler::zero, Assembler::ptr_cc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
    restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
#endif // ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
  st_ptr(G0, sp_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
  // Always return last_Java_pc to zero
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
  st_ptr(G0, pc_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
  // Always null flags after return to Java
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
  st(G0, flags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1015
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
void MacroAssembler::call_VM_base(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
  Register        oop_result,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1020
  Register        thread_cache,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1021
  Register        last_java_sp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
  address         entry_point,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
  int             number_of_arguments,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
  bool            check_exceptions)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
  assert_not_delayed();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
  // determine last_java_sp register
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
  if (!last_java_sp->is_valid()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
    last_java_sp = SP;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
  // debugging support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
  assert(number_of_arguments >= 0   , "cannot have negative number of arguments");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
  // 64-bit last_java_sp is biased!
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
  set_last_Java_frame(last_java_sp, noreg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
  if (VerifyThread)  mov(G2_thread, O0); // about to be smashed; pass early
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
  save_thread(thread_cache);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
  // do the call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
  call(entry_point, relocInfo::runtime_call_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
  if (!VerifyThread)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
    delayed()->mov(G2_thread, O0);  // pass thread as first argument
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1043
  else
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
    delayed()->nop();             // (thread already passed)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
  restore_thread(thread_cache);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1046
  reset_last_Java_frame();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1047
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1048
  // check for pending exceptions. use Gtemp as scratch register.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1049
  if (check_exceptions) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1050
    check_and_forward_exception(Gtemp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1051
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
  // get oop result if there is one and reset the value in the thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1054
  if (oop_result->is_valid()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1055
    get_vm_result(oop_result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1056
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
void MacroAssembler::check_and_forward_exception(Register scratch_reg)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
  Label L;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
  check_and_handle_popframe(scratch_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
  check_and_handle_earlyret(scratch_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1065
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
  Address exception_addr(G2_thread, 0, in_bytes(Thread::pending_exception_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1067
  ld_ptr(exception_addr, scratch_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1068
  br_null(scratch_reg,false,pt,L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1069
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1070
  // we use O7 linkage so that forward_exception_entry has the issuing PC
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1071
  call(StubRoutines::forward_exception_entry(), relocInfo::runtime_call_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1072
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1073
  bind(L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1074
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1077
void MacroAssembler::check_and_handle_popframe(Register scratch_reg) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
}
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 MacroAssembler::check_and_handle_earlyret(Register scratch_reg) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1083
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1084
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1085
void MacroAssembler::call_VM(Register oop_result, address entry_point, int number_of_arguments, bool check_exceptions) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1086
  call_VM_base(oop_result, noreg, noreg, entry_point, number_of_arguments, check_exceptions);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1087
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1089
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
void MacroAssembler::call_VM(Register oop_result, address entry_point, Register arg_1, bool check_exceptions) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
  // O0 is reserved for the thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
  mov(arg_1, O1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
  call_VM(oop_result, entry_point, 1, check_exceptions);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1095
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1096
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1097
void MacroAssembler::call_VM(Register oop_result, address entry_point, Register arg_1, Register arg_2, bool check_exceptions) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1098
  // O0 is reserved for the thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1099
  mov(arg_1, O1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1100
  mov(arg_2, O2); assert(arg_2 != O1, "smashed argument");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1101
  call_VM(oop_result, entry_point, 2, check_exceptions);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1102
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1103
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1104
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1105
void MacroAssembler::call_VM(Register oop_result, address entry_point, Register arg_1, Register arg_2, Register arg_3, bool check_exceptions) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1106
  // O0 is reserved for the thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
  mov(arg_1, O1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1108
  mov(arg_2, O2); assert(arg_2 != O1,                "smashed argument");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1109
  mov(arg_3, O3); assert(arg_3 != O1 && arg_3 != O2, "smashed argument");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1110
  call_VM(oop_result, entry_point, 3, check_exceptions);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1111
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1112
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1113
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1114
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1115
// Note: The following call_VM overloadings are useful when a "save"
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1116
// has already been performed by a stub, and the last Java frame is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1117
// the previous one.  In that case, last_java_sp must be passed as FP
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1118
// instead of SP.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1119
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1120
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1121
void MacroAssembler::call_VM(Register oop_result, Register last_java_sp, address entry_point, int number_of_arguments, bool check_exceptions) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1122
  call_VM_base(oop_result, noreg, last_java_sp, entry_point, number_of_arguments, check_exceptions);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1123
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1124
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1125
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1126
void MacroAssembler::call_VM(Register oop_result, Register last_java_sp, address entry_point, Register arg_1, bool check_exceptions) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1127
  // O0 is reserved for the thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1128
  mov(arg_1, O1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1129
  call_VM(oop_result, last_java_sp, entry_point, 1, check_exceptions);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1130
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1131
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1132
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1133
void MacroAssembler::call_VM(Register oop_result, Register last_java_sp, address entry_point, Register arg_1, Register arg_2, bool check_exceptions) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1134
  // O0 is reserved for the thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1135
  mov(arg_1, O1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1136
  mov(arg_2, O2); assert(arg_2 != O1, "smashed argument");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1137
  call_VM(oop_result, last_java_sp, entry_point, 2, check_exceptions);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1138
}
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 MacroAssembler::call_VM(Register oop_result, Register last_java_sp, address entry_point, Register arg_1, Register arg_2, Register arg_3, bool check_exceptions) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1142
  // O0 is reserved for the thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1143
  mov(arg_1, O1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1144
  mov(arg_2, O2); assert(arg_2 != O1,                "smashed argument");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1145
  mov(arg_3, O3); assert(arg_3 != O1 && arg_3 != O2, "smashed argument");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1146
  call_VM(oop_result, last_java_sp, entry_point, 3, check_exceptions);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1147
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1148
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1149
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1150
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1151
void MacroAssembler::call_VM_leaf_base(Register thread_cache, address entry_point, int number_of_arguments) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1152
  assert_not_delayed();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1153
  save_thread(thread_cache);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1154
  // do the call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1155
  call(entry_point, relocInfo::runtime_call_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1156
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1157
  restore_thread(thread_cache);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1158
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1159
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1160
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1161
void MacroAssembler::call_VM_leaf(Register thread_cache, address entry_point, int number_of_arguments) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1162
  call_VM_leaf_base(thread_cache, entry_point, number_of_arguments);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1163
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1164
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1165
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1166
void MacroAssembler::call_VM_leaf(Register thread_cache, address entry_point, Register arg_1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1167
  mov(arg_1, O0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1168
  call_VM_leaf(thread_cache, entry_point, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1169
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1170
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1171
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1172
void MacroAssembler::call_VM_leaf(Register thread_cache, address entry_point, Register arg_1, Register arg_2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1173
  mov(arg_1, O0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1174
  mov(arg_2, O1); assert(arg_2 != O0, "smashed argument");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1175
  call_VM_leaf(thread_cache, entry_point, 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1176
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1177
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1178
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1179
void MacroAssembler::call_VM_leaf(Register thread_cache, address entry_point, Register arg_1, Register arg_2, Register arg_3) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1180
  mov(arg_1, O0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1181
  mov(arg_2, O1); assert(arg_2 != O0,                "smashed argument");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1182
  mov(arg_3, O2); assert(arg_3 != O0 && arg_3 != O1, "smashed argument");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1183
  call_VM_leaf(thread_cache, entry_point, 3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1184
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1185
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1186
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1187
void MacroAssembler::get_vm_result(Register oop_result) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1188
  verify_thread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1189
  Address vm_result_addr(G2_thread, 0, in_bytes(JavaThread::vm_result_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1190
  ld_ptr(    vm_result_addr, oop_result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1191
  st_ptr(G0, vm_result_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1192
  verify_oop(oop_result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1193
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1194
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1195
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1196
void MacroAssembler::get_vm_result_2(Register oop_result) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1197
  verify_thread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1198
  Address vm_result_addr_2(G2_thread, 0, in_bytes(JavaThread::vm_result_2_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1199
  ld_ptr(vm_result_addr_2, oop_result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1200
  st_ptr(G0, vm_result_addr_2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1201
  verify_oop(oop_result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1202
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1203
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1204
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1205
// We require that C code which does not return a value in vm_result will
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1206
// leave it undisturbed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1207
void MacroAssembler::set_vm_result(Register oop_result) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1208
  verify_thread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1209
  Address vm_result_addr(G2_thread, 0, in_bytes(JavaThread::vm_result_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1210
  verify_oop(oop_result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1211
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1212
# ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1213
    // Check that we are not overwriting any other oop.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1214
#ifdef CC_INTERP
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1215
    save_frame(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1216
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1217
    save_frame_and_mov(0, Lmethod, Lmethod);     // Propagate Lmethod for -Xprof
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1218
#endif /* CC_INTERP */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1219
    ld_ptr(vm_result_addr, L0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1220
    tst(L0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1221
    restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1222
    breakpoint_trap(notZero, Assembler::ptr_cc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1223
    // }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1224
# endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1225
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1226
  st_ptr(oop_result, vm_result_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1227
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1228
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1229
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1230
void MacroAssembler::card_table_write(jbyte* byte_map_base,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1231
                                      Register tmp, Register obj) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1232
#ifdef _LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1233
  srlx(obj, CardTableModRefBS::card_shift, obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1234
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1235
  srl(obj, CardTableModRefBS::card_shift, obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1236
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1237
  assert( tmp != obj, "need separate temp reg");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1238
  Address rs(tmp, (address)byte_map_base);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1239
  load_address(rs);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1240
  stb(G0, rs.base(), obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1241
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1242
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1243
// %%% Note:  The following six instructions have been moved,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1244
//            unchanged, from assembler_sparc.inline.hpp.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1245
//            They will be refactored at a later date.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1246
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1247
void MacroAssembler::sethi(intptr_t imm22a,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1248
                            Register d,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1249
                            bool ForceRelocatable,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1250
                            RelocationHolder const& rspec) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1251
  Address adr( d, (address)imm22a, rspec );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1252
  MacroAssembler::sethi( adr, ForceRelocatable );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1253
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1254
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1255
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1256
void MacroAssembler::sethi(Address& a, bool ForceRelocatable) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1257
  address save_pc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1258
  int shiftcnt;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1259
  // if addr of local, do not need to load it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1260
  assert(a.base() != FP  &&  a.base() != SP, "just use ld or st for locals");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1261
#ifdef _LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1262
# ifdef CHECK_DELAY
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1263
  assert_not_delayed( (char *)"cannot put two instructions in delay slot" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1264
# endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1265
  v9_dep();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1266
//  ForceRelocatable = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1267
  save_pc = pc();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1268
  if (a.hi32() == 0 && a.low32() >= 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1269
    Assembler::sethi(a.low32(), a.base(), a.rspec());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1270
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1271
  else if (a.hi32() == -1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1272
    Assembler::sethi(~a.low32(), a.base(), a.rspec());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1273
    xor3(a.base(), ~low10(~0), a.base());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1274
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1275
  else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1276
    Assembler::sethi(a.hi32(), a.base(), a.rspec() );   // 22
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1277
    if ( a.hi32() & 0x3ff )                     // Any bits?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1278
      or3( a.base(), a.hi32() & 0x3ff ,a.base() ); // High 32 bits are now in low 32
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1279
    if ( a.low32() & 0xFFFFFC00 ) {             // done?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1280
      if( (a.low32() >> 20) & 0xfff ) {         // Any bits set?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1281
        sllx(a.base(), 12, a.base());           // Make room for next 12 bits
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1282
        or3( a.base(), (a.low32() >> 20) & 0xfff,a.base() ); // Or in next 12
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1283
        shiftcnt = 0;                           // We already shifted
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1284
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1285
      else
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1286
        shiftcnt = 12;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1287
      if( (a.low32() >> 10) & 0x3ff ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1288
        sllx(a.base(), shiftcnt+10, a.base());// Make room for last 10 bits
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1289
        or3( a.base(), (a.low32() >> 10) & 0x3ff,a.base() ); // Or in next 10
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1290
        shiftcnt = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1291
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1292
      else
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1293
        shiftcnt = 10;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1294
      sllx(a.base(), shiftcnt+10 , a.base());           // Shift leaving disp field 0'd
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1295
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1296
    else
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1297
      sllx( a.base(), 32, a.base() );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1298
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1299
  // Pad out the instruction sequence so it can be
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1300
  // patched later.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1301
  if ( ForceRelocatable || (a.rtype() != relocInfo::none &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1302
                            a.rtype() != relocInfo::runtime_call_type) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1303
    while ( pc() < (save_pc + (7 * BytesPerInstWord )) )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1304
      nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1305
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1306
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1307
  Assembler::sethi(a.hi(), a.base(), a.rspec());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1308
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1309
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1310
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1311
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1312
int MacroAssembler::size_of_sethi(address a, bool worst_case) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1313
#ifdef _LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1314
  if (worst_case) return 7;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1315
  intptr_t iaddr = (intptr_t)a;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1316
  int hi32 = (int)(iaddr >> 32);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1317
  int lo32 = (int)(iaddr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1318
  int inst_count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1319
  if (hi32 == 0 && lo32 >= 0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1320
    inst_count = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1321
  else if (hi32 == -1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1322
    inst_count = 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1323
  else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1324
    inst_count = 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1325
    if ( hi32 & 0x3ff )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1326
      inst_count++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1327
    if ( lo32 & 0xFFFFFC00 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1328
      if( (lo32 >> 20) & 0xfff ) inst_count += 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1329
      if( (lo32 >> 10) & 0x3ff ) inst_count += 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1330
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1331
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1332
  return BytesPerInstWord * inst_count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1333
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1334
  return BytesPerInstWord;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1335
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1336
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1337
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1338
int MacroAssembler::worst_case_size_of_set() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1339
  return size_of_sethi(NULL, true) + 1;
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 MacroAssembler::set(intptr_t value, Register d,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1343
                         RelocationHolder const& rspec) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1344
  Address val( d, (address)value, rspec);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1345
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1346
  if ( rspec.type() == relocInfo::none ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1347
    // can optimize
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1348
    if (-4096 <= value  &&  value <= 4095) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1349
      or3(G0, value, d); // setsw (this leaves upper 32 bits sign-extended)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1350
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1351
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1352
    if (inv_hi22(hi22(value)) == value) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1353
      sethi(val);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1354
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1355
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1356
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1357
  assert_not_delayed( (char *)"cannot put two instructions in delay slot" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1358
  sethi( val );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1359
  if (rspec.type() != relocInfo::none || (value & 0x3ff) != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1360
    add( d, value &  0x3ff, d, rspec);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1361
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1362
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1363
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1364
void MacroAssembler::setsw(int value, Register d,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1365
                           RelocationHolder const& rspec) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1366
  Address val( d, (address)value, rspec);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1367
  if ( rspec.type() == relocInfo::none ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1368
    // can optimize
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1369
    if (-4096 <= value  &&  value <= 4095) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1370
      or3(G0, value, d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1371
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1372
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1373
    if (inv_hi22(hi22(value)) == value) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1374
      sethi( val );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1375
#ifndef _LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1376
      if ( value < 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1377
        assert_not_delayed();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1378
        sra (d, G0, d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1379
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1380
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1381
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1382
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1383
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1384
  assert_not_delayed();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1385
  sethi( val );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1386
  add( d, value &  0x3ff, d, rspec);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1387
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1388
  // (A negative value could be loaded in 2 insns with sethi/xor,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1389
  // but it would take a more complex relocation.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1390
#ifndef _LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1391
  if ( value < 0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1392
    sra(d, G0, d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1393
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1394
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1395
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1396
// %%% End of moved six set instructions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1397
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1398
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1399
void MacroAssembler::set64(jlong value, Register d, Register tmp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1400
  assert_not_delayed();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1401
  v9_dep();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1402
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1403
  int hi = (int)(value >> 32);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1404
  int lo = (int)(value & ~0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1405
  // (Matcher::isSimpleConstant64 knows about the following optimizations.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1406
  if (Assembler::is_simm13(lo) && value == lo) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1407
    or3(G0, lo, d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1408
  } else if (hi == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1409
    Assembler::sethi(lo, d);   // hardware version zero-extends to upper 32
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1410
    if (low10(lo) != 0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1411
      or3(d, low10(lo), d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1412
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1413
  else if (hi == -1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1414
    Assembler::sethi(~lo, d);  // hardware version zero-extends to upper 32
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1415
    xor3(d, low10(lo) ^ ~low10(~0), d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1416
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1417
  else if (lo == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1418
    if (Assembler::is_simm13(hi)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1419
      or3(G0, hi, d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1420
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1421
      Assembler::sethi(hi, d);   // hardware version zero-extends to upper 32
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1422
      if (low10(hi) != 0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1423
        or3(d, low10(hi), d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1424
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1425
    sllx(d, 32, d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1426
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1427
  else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1428
    Assembler::sethi(hi, tmp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1429
    Assembler::sethi(lo,   d); // macro assembler version sign-extends
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1430
    if (low10(hi) != 0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1431
      or3 (tmp, low10(hi), tmp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1432
    if (low10(lo) != 0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1433
      or3 (  d, low10(lo),   d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1434
    sllx(tmp, 32, tmp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1435
    or3 (d, tmp, d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1436
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1437
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1438
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1439
// compute size in bytes of sparc frame, given
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1440
// number of extraWords
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1441
int MacroAssembler::total_frame_size_in_bytes(int extraWords) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1442
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1443
  int nWords = frame::memory_parameter_word_sp_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1444
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1445
  nWords += extraWords;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1446
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1447
  if (nWords & 1) ++nWords; // round up to double-word
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1448
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1449
  return nWords * BytesPerWord;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1450
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1451
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1452
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1453
// save_frame: given number of "extra" words in frame,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1454
// issue approp. save instruction (p 200, v8 manual)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1455
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1456
void MacroAssembler::save_frame(int extraWords = 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1457
  int delta = -total_frame_size_in_bytes(extraWords);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1458
  if (is_simm13(delta)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1459
    save(SP, delta, SP);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1460
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1461
    set(delta, G3_scratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1462
    save(SP, G3_scratch, SP);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1463
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1464
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1465
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1466
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1467
void MacroAssembler::save_frame_c1(int size_in_bytes) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1468
  if (is_simm13(-size_in_bytes)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1469
    save(SP, -size_in_bytes, SP);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1470
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1471
    set(-size_in_bytes, G3_scratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1472
    save(SP, G3_scratch, SP);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1473
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1474
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1475
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1476
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1477
void MacroAssembler::save_frame_and_mov(int extraWords,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1478
                                        Register s1, Register d1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1479
                                        Register s2, Register d2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1480
  assert_not_delayed();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1481
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1482
  // The trick here is to use precisely the same memory word
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1483
  // that trap handlers also use to save the register.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1484
  // This word cannot be used for any other purpose, but
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1485
  // it works fine to save the register's value, whether or not
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1486
  // an interrupt flushes register windows at any given moment!
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1487
  Address s1_addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1488
  if (s1->is_valid() && (s1->is_in() || s1->is_local())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1489
    s1_addr = s1->address_in_saved_window();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1490
    st_ptr(s1, s1_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1491
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1492
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1493
  Address s2_addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1494
  if (s2->is_valid() && (s2->is_in() || s2->is_local())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1495
    s2_addr = s2->address_in_saved_window();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1496
    st_ptr(s2, s2_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1497
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1498
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1499
  save_frame(extraWords);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1500
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1501
  if (s1_addr.base() == SP) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1502
    ld_ptr(s1_addr.after_save(), d1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1503
  } else if (s1->is_valid()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1504
    mov(s1->after_save(), d1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1505
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1506
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1507
  if (s2_addr.base() == SP) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1508
    ld_ptr(s2_addr.after_save(), d2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1509
  } else if (s2->is_valid()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1510
    mov(s2->after_save(), d2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1511
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1512
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1513
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1514
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1515
Address MacroAssembler::allocate_oop_address(jobject obj, Register d) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1516
  assert(oop_recorder() != NULL, "this assembler needs an OopRecorder");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1517
  int oop_index = oop_recorder()->allocate_index(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1518
  return Address(d, address(obj), oop_Relocation::spec(oop_index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1519
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1520
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1521
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1522
Address MacroAssembler::constant_oop_address(jobject obj, Register d) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1523
  assert(oop_recorder() != NULL, "this assembler needs an OopRecorder");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1524
  int oop_index = oop_recorder()->find_index(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1525
  return Address(d, address(obj), oop_Relocation::spec(oop_index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1526
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1527
590
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 371
diff changeset
  1528
void  MacroAssembler::set_narrow_oop(jobject obj, Register d) {
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 371
diff changeset
  1529
  assert(oop_recorder() != NULL, "this assembler needs an OopRecorder");
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 371
diff changeset
  1530
  int oop_index = oop_recorder()->find_index(obj);
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 371
diff changeset
  1531
  RelocationHolder rspec = oop_Relocation::spec(oop_index);
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 371
diff changeset
  1532
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 371
diff changeset
  1533
  assert_not_delayed();
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 371
diff changeset
  1534
  // Relocation with special format (see relocInfo_sparc.hpp).
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 371
diff changeset
  1535
  relocate(rspec, 1);
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 371
diff changeset
  1536
  // Assembler::sethi(0x3fffff, d);
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 371
diff changeset
  1537
  emit_long( op(branch_op) | rd(d) | op2(sethi_op2) | hi22(0x3fffff) );
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 371
diff changeset
  1538
  // Don't add relocation for 'add'. Do patching during 'sethi' processing.
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 371
diff changeset
  1539
  add(d, 0x3ff, d);
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 371
diff changeset
  1540
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 371
diff changeset
  1541
}
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 371
diff changeset
  1542
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1543
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1544
void MacroAssembler::align(int modulus) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1545
  while (offset() % modulus != 0) nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1546
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1547
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1548
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1549
void MacroAssembler::safepoint() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1550
  relocate(breakpoint_Relocation::spec(breakpoint_Relocation::safepoint));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1551
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1552
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1553
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1554
void RegistersForDebugging::print(outputStream* s) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1555
  int j;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1556
  for ( j = 0;  j < 8;  ++j )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1557
    if ( j != 6 ) s->print_cr("i%d = 0x%.16lx", j, i[j]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1558
    else          s->print_cr( "fp = 0x%.16lx",    i[j]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1559
  s->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1560
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1561
  for ( j = 0;  j < 8;  ++j )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1562
    s->print_cr("l%d = 0x%.16lx", j, l[j]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1563
  s->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1564
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1565
  for ( j = 0;  j < 8;  ++j )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1566
    if ( j != 6 ) s->print_cr("o%d = 0x%.16lx", j, o[j]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1567
    else          s->print_cr( "sp = 0x%.16lx",    o[j]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1568
  s->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1569
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1570
  for ( j = 0;  j < 8;  ++j )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1571
    s->print_cr("g%d = 0x%.16lx", j, g[j]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1572
  s->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1573
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1574
  // print out floats with compression
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1575
  for (j = 0; j < 32; ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1576
    jfloat val = f[j];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1577
    int last = j;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1578
    for ( ;  last+1 < 32;  ++last ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1579
      char b1[1024], b2[1024];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1580
      sprintf(b1, "%f", val);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1581
      sprintf(b2, "%f", f[last+1]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1582
      if (strcmp(b1, b2))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1583
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1584
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1585
    s->print("f%d", j);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1586
    if ( j != last )  s->print(" - f%d", last);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1587
    s->print(" = %f", val);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1588
    s->fill_to(25);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1589
    s->print_cr(" (0x%x)", val);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1590
    j = last + 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1591
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1592
  s->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1593
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1594
  // and doubles (evens only)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1595
  for (j = 0; j < 32; ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1596
    jdouble val = d[j];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1597
    int last = j;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1598
    for ( ;  last+1 < 32;  ++last ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1599
      char b1[1024], b2[1024];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1600
      sprintf(b1, "%f", val);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1601
      sprintf(b2, "%f", d[last+1]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1602
      if (strcmp(b1, b2))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1603
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1604
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1605
    s->print("d%d", 2 * j);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1606
    if ( j != last )  s->print(" - d%d", last);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1607
    s->print(" = %f", val);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1608
    s->fill_to(30);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1609
    s->print("(0x%x)", *(int*)&val);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1610
    s->fill_to(42);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1611
    s->print_cr("(0x%x)", *(1 + (int*)&val));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1612
    j = last + 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1613
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1614
  s->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1615
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1616
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1617
void RegistersForDebugging::save_registers(MacroAssembler* a) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1618
  a->sub(FP, round_to(sizeof(RegistersForDebugging), sizeof(jdouble)) - STACK_BIAS, O0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1619
  a->flush_windows();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1620
  int i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1621
  for (i = 0; i < 8; ++i) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1622
    a->ld_ptr(as_iRegister(i)->address_in_saved_window().after_save(), L1);  a->st_ptr( L1, O0, i_offset(i));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1623
    a->ld_ptr(as_lRegister(i)->address_in_saved_window().after_save(), L1);  a->st_ptr( L1, O0, l_offset(i));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1624
    a->st_ptr(as_oRegister(i)->after_save(), O0, o_offset(i));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1625
    a->st_ptr(as_gRegister(i)->after_save(), O0, g_offset(i));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1626
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1627
  for (i = 0;  i < 32; ++i) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1628
    a->stf(FloatRegisterImpl::S, as_FloatRegister(i), O0, f_offset(i));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1629
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1630
  for (i = 0; i < (VM_Version::v9_instructions_work() ? 64 : 32); i += 2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1631
    a->stf(FloatRegisterImpl::D, as_FloatRegister(i), O0, d_offset(i));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1632
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1633
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1634
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1635
void RegistersForDebugging::restore_registers(MacroAssembler* a, Register r) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1636
  for (int i = 1; i < 8;  ++i) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1637
    a->ld_ptr(r, g_offset(i), as_gRegister(i));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1638
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1639
  for (int j = 0; j < 32; ++j) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1640
    a->ldf(FloatRegisterImpl::S, O0, f_offset(j), as_FloatRegister(j));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1641
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1642
  for (int k = 0; k < (VM_Version::v9_instructions_work() ? 64 : 32); k += 2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1643
    a->ldf(FloatRegisterImpl::D, O0, d_offset(k), as_FloatRegister(k));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1644
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1645
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1646
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1647
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1648
// pushes double TOS element of FPU stack on CPU stack; pops from FPU stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1649
void MacroAssembler::push_fTOS() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1650
  // %%%%%% need to implement this
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1651
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1652
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1653
// pops double TOS element from CPU stack and pushes on FPU stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1654
void MacroAssembler::pop_fTOS() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1655
  // %%%%%% need to implement this
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1656
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1657
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1658
void MacroAssembler::empty_FPU_stack() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1659
  // %%%%%% need to implement this
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1660
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1661
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1662
void MacroAssembler::_verify_oop(Register reg, const char* msg, const char * file, int line) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1663
  // plausibility check for oops
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1664
  if (!VerifyOops) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1665
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1666
  if (reg == G0)  return;       // always NULL, which is always an oop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1667
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1668
  char buffer[64];
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1669
#ifdef COMPILER1
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1670
  if (CommentedAssembly) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1671
    snprintf(buffer, sizeof(buffer), "verify_oop at %d", offset());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1672
    block_comment(buffer);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1673
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1674
#endif
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1675
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1676
  int len = strlen(file) + strlen(msg) + 1 + 4;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1677
  sprintf(buffer, "%d", line);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1678
  len += strlen(buffer);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1679
  sprintf(buffer, " at offset %d ", offset());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1680
  len += strlen(buffer);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1681
  char * real_msg = new char[len];
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1682
  sprintf(real_msg, "%s%s(%s:%d)", msg, buffer, file, line);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1683
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1684
  // Call indirectly to solve generation ordering problem
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1685
  Address a(O7, (address)StubRoutines::verify_oop_subroutine_entry_address());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1686
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1687
  // Make some space on stack above the current register window.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1688
  // Enough to hold 8 64-bit registers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1689
  add(SP,-8*8,SP);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1690
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1691
  // Save some 64-bit registers; a normal 'save' chops the heads off
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1692
  // of 64-bit longs in the 32-bit build.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1693
  stx(O0,SP,frame::register_save_words*wordSize+STACK_BIAS+0*8);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1694
  stx(O1,SP,frame::register_save_words*wordSize+STACK_BIAS+1*8);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1695
  mov(reg,O0); // Move arg into O0; arg might be in O7 which is about to be crushed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1696
  stx(O7,SP,frame::register_save_words*wordSize+STACK_BIAS+7*8);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1697
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1698
  set((intptr_t)real_msg, O1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1699
  // Load address to call to into O7
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1700
  load_ptr_contents(a, O7);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1701
  // Register call to verify_oop_subroutine
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1702
  callr(O7, G0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1703
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1704
  // recover frame size
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1705
  add(SP, 8*8,SP);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1706
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1707
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1708
void MacroAssembler::_verify_oop_addr(Address addr, const char* msg, const char * file, int line) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1709
  // plausibility check for oops
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1710
  if (!VerifyOops) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1711
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1712
  char buffer[64];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1713
  sprintf(buffer, "%d", line);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1714
  int len = strlen(file) + strlen(msg) + 1 + 4 + strlen(buffer);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1715
  sprintf(buffer, " at SP+%d ", addr.disp());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1716
  len += strlen(buffer);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1717
  char * real_msg = new char[len];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1718
  sprintf(real_msg, "%s at SP+%d (%s:%d)", msg, addr.disp(), file, line);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1719
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1720
  // Call indirectly to solve generation ordering problem
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1721
  Address a(O7, (address)StubRoutines::verify_oop_subroutine_entry_address());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1722
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1723
  // Make some space on stack above the current register window.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1724
  // Enough to hold 8 64-bit registers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1725
  add(SP,-8*8,SP);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1726
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1727
  // Save some 64-bit registers; a normal 'save' chops the heads off
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1728
  // of 64-bit longs in the 32-bit build.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1729
  stx(O0,SP,frame::register_save_words*wordSize+STACK_BIAS+0*8);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1730
  stx(O1,SP,frame::register_save_words*wordSize+STACK_BIAS+1*8);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1731
  ld_ptr(addr.base(), addr.disp() + 8*8, O0); // Load arg into O0; arg might be in O7 which is about to be crushed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1732
  stx(O7,SP,frame::register_save_words*wordSize+STACK_BIAS+7*8);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1733
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1734
  set((intptr_t)real_msg, O1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1735
  // Load address to call to into O7
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1736
  load_ptr_contents(a, O7);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1737
  // Register call to verify_oop_subroutine
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1738
  callr(O7, G0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1739
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1740
  // recover frame size
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1741
  add(SP, 8*8,SP);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1742
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1743
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1744
// side-door communication with signalHandler in os_solaris.cpp
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1745
address MacroAssembler::_verify_oop_implicit_branch[3] = { NULL };
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1746
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1747
// This macro is expanded just once; it creates shared code.  Contract:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1748
// receives an oop in O0.  Must restore O0 & O7 from TLS.  Must not smash ANY
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1749
// registers, including flags.  May not use a register 'save', as this blows
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1750
// the high bits of the O-regs if they contain Long values.  Acts as a 'leaf'
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1751
// call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1752
void MacroAssembler::verify_oop_subroutine() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1753
  assert( VM_Version::v9_instructions_work(), "VerifyOops not supported for V8" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1754
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1755
  // Leaf call; no frame.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1756
  Label succeed, fail, null_or_fail;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1757
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1758
  // O0 and O7 were saved already (O0 in O0's TLS home, O7 in O5's TLS home).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1759
  // O0 is now the oop to be checked.  O7 is the return address.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1760
  Register O0_obj = O0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1761
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1762
  // Save some more registers for temps.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1763
  stx(O2,SP,frame::register_save_words*wordSize+STACK_BIAS+2*8);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1764
  stx(O3,SP,frame::register_save_words*wordSize+STACK_BIAS+3*8);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1765
  stx(O4,SP,frame::register_save_words*wordSize+STACK_BIAS+4*8);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1766
  stx(O5,SP,frame::register_save_words*wordSize+STACK_BIAS+5*8);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1767
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1768
  // Save flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1769
  Register O5_save_flags = O5;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1770
  rdccr( O5_save_flags );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1771
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1772
  { // count number of verifies
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1773
    Register O2_adr   = O2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1774
    Register O3_accum = O3;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1775
    Address count_addr( O2_adr, (address) StubRoutines::verify_oop_count_addr() );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1776
    sethi(count_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1777
    ld(count_addr, O3_accum);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1778
    inc(O3_accum);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1779
    st(O3_accum, count_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1780
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1781
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1782
  Register O2_mask = O2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1783
  Register O3_bits = O3;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1784
  Register O4_temp = O4;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1785
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1786
  // mark lower end of faulting range
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1787
  assert(_verify_oop_implicit_branch[0] == NULL, "set once");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1788
  _verify_oop_implicit_branch[0] = pc();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1789
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1790
  // We can't check the mark oop because it could be in the process of
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1791
  // locking or unlocking while this is running.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1792
  set(Universe::verify_oop_mask (), O2_mask);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1793
  set(Universe::verify_oop_bits (), O3_bits);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1794
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1795
  // assert((obj & oop_mask) == oop_bits);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1796
  and3(O0_obj, O2_mask, O4_temp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1797
  cmp(O4_temp, O3_bits);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1798
  brx(notEqual, false, pn, null_or_fail);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1799
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1800
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1801
  if ((NULL_WORD & Universe::verify_oop_mask()) == Universe::verify_oop_bits()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1802
    // the null_or_fail case is useless; must test for null separately
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1803
    br_null(O0_obj, false, pn, succeed);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1804
    delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1805
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1806
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1807
  // Check the klassOop of this object for being in the right area of memory.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1808
  // Cannot do the load in the delay above slot in case O0 is null
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  1809
  load_klass(O0_obj, O0_obj);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1810
  // assert((klass & klass_mask) == klass_bits);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1811
  if( Universe::verify_klass_mask() != Universe::verify_oop_mask() )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1812
    set(Universe::verify_klass_mask(), O2_mask);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1813
  if( Universe::verify_klass_bits() != Universe::verify_oop_bits() )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1814
    set(Universe::verify_klass_bits(), O3_bits);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1815
  and3(O0_obj, O2_mask, O4_temp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1816
  cmp(O4_temp, O3_bits);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1817
  brx(notEqual, false, pn, fail);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  1818
  delayed()->nop();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1819
  // Check the klass's klass
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  1820
  load_klass(O0_obj, O0_obj);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1821
  and3(O0_obj, O2_mask, O4_temp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1822
  cmp(O4_temp, O3_bits);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1823
  brx(notEqual, false, pn, fail);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1824
  delayed()->wrccr( O5_save_flags ); // Restore CCR's
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1825
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1826
  // mark upper end of faulting range
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1827
  _verify_oop_implicit_branch[1] = pc();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1828
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1829
  //-----------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1830
  // all tests pass
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1831
  bind(succeed);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1832
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1833
  // Restore prior 64-bit registers
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1834
  ldx(SP,frame::register_save_words*wordSize+STACK_BIAS+0*8,O0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1835
  ldx(SP,frame::register_save_words*wordSize+STACK_BIAS+1*8,O1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1836
  ldx(SP,frame::register_save_words*wordSize+STACK_BIAS+2*8,O2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1837
  ldx(SP,frame::register_save_words*wordSize+STACK_BIAS+3*8,O3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1838
  ldx(SP,frame::register_save_words*wordSize+STACK_BIAS+4*8,O4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1839
  ldx(SP,frame::register_save_words*wordSize+STACK_BIAS+5*8,O5);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1840
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1841
  retl();                       // Leaf return; restore prior O7 in delay slot
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1842
  delayed()->ldx(SP,frame::register_save_words*wordSize+STACK_BIAS+7*8,O7);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1843
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1844
  //-----------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1845
  bind(null_or_fail);           // nulls are less common but OK
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1846
  br_null(O0_obj, false, pt, succeed);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1847
  delayed()->wrccr( O5_save_flags ); // Restore CCR's
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1848
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1849
  //-----------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1850
  // report failure:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1851
  bind(fail);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1852
  _verify_oop_implicit_branch[2] = pc();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1853
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1854
  wrccr( O5_save_flags ); // Restore CCR's
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1855
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1856
  save_frame(::round_to(sizeof(RegistersForDebugging) / BytesPerWord, 2));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1857
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1858
  // stop_subroutine expects message pointer in I1.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1859
  mov(I1, O1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1860
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1861
  // Restore prior 64-bit registers
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1862
  ldx(FP,frame::register_save_words*wordSize+STACK_BIAS+0*8,I0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1863
  ldx(FP,frame::register_save_words*wordSize+STACK_BIAS+1*8,I1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1864
  ldx(FP,frame::register_save_words*wordSize+STACK_BIAS+2*8,I2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1865
  ldx(FP,frame::register_save_words*wordSize+STACK_BIAS+3*8,I3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1866
  ldx(FP,frame::register_save_words*wordSize+STACK_BIAS+4*8,I4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1867
  ldx(FP,frame::register_save_words*wordSize+STACK_BIAS+5*8,I5);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1868
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1869
  // factor long stop-sequence into subroutine to save space
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1870
  assert(StubRoutines::Sparc::stop_subroutine_entry_address(), "hasn't been generated yet");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1871
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1872
  // call indirectly to solve generation ordering problem
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1873
  Address a(O5, (address)StubRoutines::Sparc::stop_subroutine_entry_address());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1874
  load_ptr_contents(a, O5);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1875
  jmpl(O5, 0, O7);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1876
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1877
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1878
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1879
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1880
void MacroAssembler::stop(const char* msg) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1881
  // save frame first to get O7 for return address
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1882
  // add one word to size in case struct is odd number of words long
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1883
  // It must be doubleword-aligned for storing doubles into it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1884
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1885
    save_frame(::round_to(sizeof(RegistersForDebugging) / BytesPerWord, 2));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1886
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1887
    // stop_subroutine expects message pointer in I1.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1888
    set((intptr_t)msg, O1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1889
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1890
    // factor long stop-sequence into subroutine to save space
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1891
    assert(StubRoutines::Sparc::stop_subroutine_entry_address(), "hasn't been generated yet");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1892
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1893
    // call indirectly to solve generation ordering problem
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1894
    Address a(O5, (address)StubRoutines::Sparc::stop_subroutine_entry_address());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1895
    load_ptr_contents(a, O5);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1896
    jmpl(O5, 0, O7);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1897
    delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1898
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1899
    breakpoint_trap();   // make stop actually stop rather than writing
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1900
                         // unnoticeable results in the output files.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1901
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1902
    // restore(); done in callee to save space!
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1903
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1904
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1905
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1906
void MacroAssembler::warn(const char* msg) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1907
  save_frame(::round_to(sizeof(RegistersForDebugging) / BytesPerWord, 2));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1908
  RegistersForDebugging::save_registers(this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1909
  mov(O0, L0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1910
  set((intptr_t)msg, O0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1911
  call( CAST_FROM_FN_PTR(address, warning) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1912
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1913
//  ret();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1914
//  delayed()->restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1915
  RegistersForDebugging::restore_registers(this, L0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1916
  restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1917
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1918
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1919
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1920
void MacroAssembler::untested(const char* what) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1921
  // We must be able to turn interactive prompting off
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1922
  // in order to run automated test scripts on the VM
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1923
  // Use the flag ShowMessageBoxOnError
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1924
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1925
  char* b = new char[1024];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1926
  sprintf(b, "untested: %s", what);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1927
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1928
  if ( ShowMessageBoxOnError )   stop(b);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1929
  else                           warn(b);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1930
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1931
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1932
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1933
void MacroAssembler::stop_subroutine() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1934
  RegistersForDebugging::save_registers(this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1935
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1936
  // for the sake of the debugger, stick a PC on the current frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1937
  // (this assumes that the caller has performed an extra "save")
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1938
  mov(I7, L7);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1939
  add(O7, -7 * BytesPerInt, I7);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1940
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1941
  save_frame(); // one more save to free up another O7 register
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1942
  mov(I0, O1); // addr of reg save area
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1943
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1944
  // We expect pointer to message in I1. Caller must set it up in O1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1945
  mov(I1, O0); // get msg
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1946
  call (CAST_FROM_FN_PTR(address, MacroAssembler::debug), relocInfo::runtime_call_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1947
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1948
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1949
  restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1950
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1951
  RegistersForDebugging::restore_registers(this, O0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1952
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1953
  save_frame(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1954
  call(CAST_FROM_FN_PTR(address,breakpoint));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1955
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1956
  restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1957
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1958
  mov(L7, I7);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1959
  retl();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1960
  delayed()->restore(); // see stop above
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1961
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1962
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1963
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1964
void MacroAssembler::debug(char* msg, RegistersForDebugging* regs) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1965
  if ( ShowMessageBoxOnError ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1966
      JavaThreadState saved_state = JavaThread::current()->thread_state();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1967
      JavaThread::current()->set_thread_state(_thread_in_vm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1968
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1969
        // In order to get locks work, we need to fake a in_VM state
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1970
        ttyLocker ttyl;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1971
        ::tty->print_cr("EXECUTION STOPPED: %s\n", msg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1972
        if (CountBytecodes || TraceBytecodes || StopInterpreterAt) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1973
          ::tty->print_cr("Interpreter::bytecode_counter = %d", BytecodeCounter::counter_value());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1974
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1975
        if (os::message_box(msg, "Execution stopped, print registers?"))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1976
          regs->print(::tty);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1977
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1978
      ThreadStateTransition::transition(JavaThread::current(), _thread_in_vm, saved_state);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1979
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1980
  else
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1981
     ::tty->print_cr("=============== DEBUG MESSAGE: %s ================\n", msg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1982
  assert(false, "error");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1983
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1984
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1985
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1986
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1987
void MacroAssembler::test() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1988
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1989
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1990
  CodeBuffer cb("test", 10000, 10000);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1991
  MacroAssembler* a = new MacroAssembler(&cb);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1992
  VM_Version::allow_all();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1993
  a->test_v9();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1994
  a->test_v8_onlys();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1995
  VM_Version::revert();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1996
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1997
  StubRoutines::Sparc::test_stop_entry()();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1998
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1999
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2000
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2001
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2002
void MacroAssembler::calc_mem_param_words(Register Rparam_words, Register Rresult) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2003
  subcc( Rparam_words, Argument::n_register_parameters, Rresult); // how many mem words?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2004
  Label no_extras;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2005
  br( negative, true, pt, no_extras ); // if neg, clear reg
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2006
  delayed()->set( 0, Rresult);         // annuled, so only if taken
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2007
  bind( no_extras );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2008
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2009
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2010
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2011
void MacroAssembler::calc_frame_size(Register Rextra_words, Register Rresult) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2012
#ifdef _LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2013
  add(Rextra_words, frame::memory_parameter_word_sp_offset, Rresult);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2014
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2015
  add(Rextra_words, frame::memory_parameter_word_sp_offset + 1, Rresult);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2016
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2017
  bclr(1, Rresult);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2018
  sll(Rresult, LogBytesPerWord, Rresult);  // Rresult has total frame bytes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2019
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2020
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2021
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2022
void MacroAssembler::calc_frame_size_and_save(Register Rextra_words, Register Rresult) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2023
  calc_frame_size(Rextra_words, Rresult);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2024
  neg(Rresult);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2025
  save(SP, Rresult, SP);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2026
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2027
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2028
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2029
// ---------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2030
Assembler::RCondition cond2rcond(Assembler::Condition c) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2031
  switch (c) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2032
    /*case zero: */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2033
    case Assembler::equal:        return Assembler::rc_z;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2034
    case Assembler::lessEqual:    return Assembler::rc_lez;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2035
    case Assembler::less:         return Assembler::rc_lz;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2036
    /*case notZero:*/
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2037
    case Assembler::notEqual:     return Assembler::rc_nz;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2038
    case Assembler::greater:      return Assembler::rc_gz;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2039
    case Assembler::greaterEqual: return Assembler::rc_gez;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2040
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2041
  ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2042
  return Assembler::rc_z;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2043
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2044
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2045
// compares register with zero and branches.  NOT FOR USE WITH 64-bit POINTERS
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2046
void MacroAssembler::br_zero( Condition c, bool a, Predict p, Register s1, Label& L) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2047
  tst(s1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2048
  br (c, a, p, L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2049
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2050
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2051
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2052
// Compares a pointer register with zero and branches on null.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2053
// Does a test & branch on 32-bit systems and a register-branch on 64-bit.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2054
void MacroAssembler::br_null( Register s1, bool a, Predict p, Label& L ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2055
  assert_not_delayed();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2056
#ifdef _LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2057
  bpr( rc_z, a, p, s1, L );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2058
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2059
  tst(s1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2060
  br ( zero, a, p, L );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2061
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2062
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2063
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2064
void MacroAssembler::br_notnull( Register s1, bool a, Predict p, Label& L ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2065
  assert_not_delayed();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2066
#ifdef _LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2067
  bpr( rc_nz, a, p, s1, L );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2068
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2069
  tst(s1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2070
  br ( notZero, a, p, L );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2071
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2072
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2073
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  2074
void MacroAssembler::br_on_reg_cond( RCondition rc, bool a, Predict p,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  2075
                                     Register s1, address d,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  2076
                                     relocInfo::relocType rt ) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  2077
  if (VM_Version::v9_instructions_work()) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  2078
    bpr(rc, a, p, s1, d, rt);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  2079
  } else {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  2080
    tst(s1);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  2081
    br(reg_cond_to_cc_cond(rc), a, p, d, rt);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  2082
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  2083
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  2084
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  2085
void MacroAssembler::br_on_reg_cond( RCondition rc, bool a, Predict p,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  2086
                                     Register s1, Label& L ) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  2087
  if (VM_Version::v9_instructions_work()) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  2088
    bpr(rc, a, p, s1, L);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  2089
  } else {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  2090
    tst(s1);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  2091
    br(reg_cond_to_cc_cond(rc), a, p, L);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  2092
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  2093
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  2094
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2095
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2096
// instruction sequences factored across compiler & interpreter
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2097
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2098
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2099
void MacroAssembler::lcmp( Register Ra_hi, Register Ra_low,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2100
                           Register Rb_hi, Register Rb_low,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2101
                           Register Rresult) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2102
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2103
  Label check_low_parts, done;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2104
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2105
  cmp(Ra_hi, Rb_hi );  // compare hi parts
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2106
  br(equal, true, pt, check_low_parts);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2107
  delayed()->cmp(Ra_low, Rb_low); // test low parts
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2108
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2109
  // And, with an unsigned comparison, it does not matter if the numbers
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2110
  // are negative or not.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2111
  // E.g., -2 cmp -1: the low parts are 0xfffffffe and 0xffffffff.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2112
  // The second one is bigger (unsignedly).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2113
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2114
  // Other notes:  The first move in each triplet can be unconditional
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2115
  // (and therefore probably prefetchable).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2116
  // And the equals case for the high part does not need testing,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2117
  // since that triplet is reached only after finding the high halves differ.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2118
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2119
  if (VM_Version::v9_instructions_work()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2120
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2121
                                    mov  (                     -1, Rresult);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2122
    ba( false, done );  delayed()-> movcc(greater, false, icc,  1, Rresult);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2123
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2124
  else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2125
    br(less,    true, pt, done); delayed()-> set(-1, Rresult);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2126
    br(greater, true, pt, done); delayed()-> set( 1, Rresult);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2127
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2128
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2129
  bind( check_low_parts );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2130
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2131
  if (VM_Version::v9_instructions_work()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2132
    mov(                               -1, Rresult);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2133
    movcc(equal,           false, icc,  0, Rresult);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2134
    movcc(greaterUnsigned, false, icc,  1, Rresult);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2135
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2136
  else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2137
                                                    set(-1, Rresult);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2138
    br(equal,           true, pt, done); delayed()->set( 0, Rresult);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2139
    br(greaterUnsigned, true, pt, done); delayed()->set( 1, Rresult);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2140
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2141
  bind( done );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2142
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2143
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2144
void MacroAssembler::lneg( Register Rhi, Register Rlow ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2145
  subcc(  G0, Rlow, Rlow );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2146
  subc(   G0, Rhi,  Rhi  );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2147
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2148
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2149
void MacroAssembler::lshl( Register Rin_high,  Register Rin_low,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2150
                           Register Rcount,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2151
                           Register Rout_high, Register Rout_low,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2152
                           Register Rtemp ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2153
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2154
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2155
  Register Ralt_count = Rtemp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2156
  Register Rxfer_bits = Rtemp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2157
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2158
  assert( Ralt_count != Rin_high
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2159
      &&  Ralt_count != Rin_low
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2160
      &&  Ralt_count != Rcount
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2161
      &&  Rxfer_bits != Rin_low
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2162
      &&  Rxfer_bits != Rin_high
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2163
      &&  Rxfer_bits != Rcount
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2164
      &&  Rxfer_bits != Rout_low
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2165
      &&  Rout_low   != Rin_high,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2166
        "register alias checks");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2167
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2168
  Label big_shift, done;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2169
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2170
  // This code can be optimized to use the 64 bit shifts in V9.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2171
  // Here we use the 32 bit shifts.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2172
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2173
  and3( Rcount,         0x3f,           Rcount);     // take least significant 6 bits
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2174
  subcc(Rcount,         31,             Ralt_count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2175
  br(greater, true, pn, big_shift);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2176
  delayed()->
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2177
  dec(Ralt_count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2178
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2179
  // shift < 32 bits, Ralt_count = Rcount-31
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2180
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2181
  // We get the transfer bits by shifting right by 32-count the low
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2182
  // register. This is done by shifting right by 31-count and then by one
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2183
  // more to take care of the special (rare) case where count is zero
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2184
  // (shifting by 32 would not work).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2185
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2186
  neg(  Ralt_count                                 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2187
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2188
  // The order of the next two instructions is critical in the case where
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2189
  // Rin and Rout are the same and should not be reversed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2190
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2191
  srl(  Rin_low,        Ralt_count,     Rxfer_bits ); // shift right by 31-count
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2192
  if (Rcount != Rout_low) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2193
    sll(        Rin_low,        Rcount,         Rout_low   ); // low half
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2194
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2195
  sll(  Rin_high,       Rcount,         Rout_high  );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2196
  if (Rcount == Rout_low) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2197
    sll(        Rin_low,        Rcount,         Rout_low   ); // low half
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2198
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2199
  srl(  Rxfer_bits,     1,              Rxfer_bits ); // shift right by one more
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2200
  ba (false, done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2201
  delayed()->
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2202
  or3(  Rout_high,      Rxfer_bits,     Rout_high);   // new hi value: or in shifted old hi part and xfer from low
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2203
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2204
  // shift >= 32 bits, Ralt_count = Rcount-32
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2205
  bind(big_shift);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2206
  sll(  Rin_low,        Ralt_count,     Rout_high  );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2207
  clr(  Rout_low                                   );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2208
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2209
  bind(done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2210
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2211
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2212
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2213
void MacroAssembler::lshr( Register Rin_high,  Register Rin_low,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2214
                           Register Rcount,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2215
                           Register Rout_high, Register Rout_low,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2216
                           Register Rtemp ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2217
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2218
  Register Ralt_count = Rtemp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2219
  Register Rxfer_bits = Rtemp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2220
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2221
  assert( Ralt_count != Rin_high
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2222
      &&  Ralt_count != Rin_low
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2223
      &&  Ralt_count != Rcount
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2224
      &&  Rxfer_bits != Rin_low
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2225
      &&  Rxfer_bits != Rin_high
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2226
      &&  Rxfer_bits != Rcount
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2227
      &&  Rxfer_bits != Rout_high
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2228
      &&  Rout_high  != Rin_low,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2229
        "register alias checks");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2230
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2231
  Label big_shift, done;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2232
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2233
  // This code can be optimized to use the 64 bit shifts in V9.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2234
  // Here we use the 32 bit shifts.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2235
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2236
  and3( Rcount,         0x3f,           Rcount);     // take least significant 6 bits
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2237
  subcc(Rcount,         31,             Ralt_count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2238
  br(greater, true, pn, big_shift);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2239
  delayed()->dec(Ralt_count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2240
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2241
  // shift < 32 bits, Ralt_count = Rcount-31
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2242
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2243
  // We get the transfer bits by shifting left by 32-count the high
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2244
  // register. This is done by shifting left by 31-count and then by one
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2245
  // more to take care of the special (rare) case where count is zero
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2246
  // (shifting by 32 would not work).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2247
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2248
  neg(  Ralt_count                                  );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2249
  if (Rcount != Rout_low) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2250
    srl(        Rin_low,        Rcount,         Rout_low    );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2251
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2252
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2253
  // The order of the next two instructions is critical in the case where
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2254
  // Rin and Rout are the same and should not be reversed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2255
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2256
  sll(  Rin_high,       Ralt_count,     Rxfer_bits  ); // shift left by 31-count
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2257
  sra(  Rin_high,       Rcount,         Rout_high   ); // high half
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2258
  sll(  Rxfer_bits,     1,              Rxfer_bits  ); // shift left by one more
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2259
  if (Rcount == Rout_low) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2260
    srl(        Rin_low,        Rcount,         Rout_low    );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2261
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2262
  ba (false, done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2263
  delayed()->
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2264
  or3(  Rout_low,       Rxfer_bits,     Rout_low    ); // new low value: or shifted old low part and xfer from high
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2265
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2266
  // shift >= 32 bits, Ralt_count = Rcount-32
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2267
  bind(big_shift);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2268
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2269
  sra(  Rin_high,       Ralt_count,     Rout_low    );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2270
  sra(  Rin_high,       31,             Rout_high   ); // sign into hi
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2271
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2272
  bind( done );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2273
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2274
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2275
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2276
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2277
void MacroAssembler::lushr( Register Rin_high,  Register Rin_low,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2278
                            Register Rcount,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2279
                            Register Rout_high, Register Rout_low,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2280
                            Register Rtemp ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2281
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2282
  Register Ralt_count = Rtemp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2283
  Register Rxfer_bits = Rtemp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2284
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2285
  assert( Ralt_count != Rin_high
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2286
      &&  Ralt_count != Rin_low
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2287
      &&  Ralt_count != Rcount
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2288
      &&  Rxfer_bits != Rin_low
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2289
      &&  Rxfer_bits != Rin_high
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2290
      &&  Rxfer_bits != Rcount
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2291
      &&  Rxfer_bits != Rout_high
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2292
      &&  Rout_high  != Rin_low,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2293
        "register alias checks");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2294
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2295
  Label big_shift, done;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2296
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2297
  // This code can be optimized to use the 64 bit shifts in V9.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2298
  // Here we use the 32 bit shifts.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2299
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2300
  and3( Rcount,         0x3f,           Rcount);     // take least significant 6 bits
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2301
  subcc(Rcount,         31,             Ralt_count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2302
  br(greater, true, pn, big_shift);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2303
  delayed()->dec(Ralt_count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2304
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2305
  // shift < 32 bits, Ralt_count = Rcount-31
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2306
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2307
  // We get the transfer bits by shifting left by 32-count the high
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2308
  // register. This is done by shifting left by 31-count and then by one
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2309
  // more to take care of the special (rare) case where count is zero
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2310
  // (shifting by 32 would not work).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2311
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2312
  neg(  Ralt_count                                  );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2313
  if (Rcount != Rout_low) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2314
    srl(        Rin_low,        Rcount,         Rout_low    );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2315
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2316
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2317
  // The order of the next two instructions is critical in the case where
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2318
  // Rin and Rout are the same and should not be reversed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2319
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2320
  sll(  Rin_high,       Ralt_count,     Rxfer_bits  ); // shift left by 31-count
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2321
  srl(  Rin_high,       Rcount,         Rout_high   ); // high half
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2322
  sll(  Rxfer_bits,     1,              Rxfer_bits  ); // shift left by one more
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2323
  if (Rcount == Rout_low) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2324
    srl(        Rin_low,        Rcount,         Rout_low    );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2325
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2326
  ba (false, done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2327
  delayed()->
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2328
  or3(  Rout_low,       Rxfer_bits,     Rout_low    ); // new low value: or shifted old low part and xfer from high
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2329
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2330
  // shift >= 32 bits, Ralt_count = Rcount-32
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2331
  bind(big_shift);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2332
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2333
  srl(  Rin_high,       Ralt_count,     Rout_low    );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2334
  clr(  Rout_high                                   );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2335
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2336
  bind( done );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2337
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2338
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2339
#ifdef _LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2340
void MacroAssembler::lcmp( Register Ra, Register Rb, Register Rresult) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2341
  cmp(Ra, Rb);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2342
  mov(                       -1, Rresult);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2343
  movcc(equal,   false, xcc,  0, Rresult);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2344
  movcc(greater, false, xcc,  1, Rresult);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2345
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2346
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2347
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2348
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2349
void MacroAssembler::float_cmp( bool is_float, int unordered_result,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2350
                                FloatRegister Fa, FloatRegister Fb,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2351
                                Register Rresult) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2352
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2353
  fcmp(is_float ? FloatRegisterImpl::S : FloatRegisterImpl::D, fcc0, Fa, Fb);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2354
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2355
  Condition lt = unordered_result == -1 ? f_unorderedOrLess    : f_less;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2356
  Condition eq =                          f_equal;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2357
  Condition gt = unordered_result ==  1 ? f_unorderedOrGreater : f_greater;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2358
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2359
  if (VM_Version::v9_instructions_work()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2360
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2361
    mov(                   -1, Rresult );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2362
    movcc( eq, true, fcc0,  0, Rresult );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2363
    movcc( gt, true, fcc0,  1, Rresult );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2364
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2365
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2366
    Label done;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2367
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2368
                                         set( -1, Rresult );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2369
    //fb(lt, true, pn, done); delayed()->set( -1, Rresult );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2370
    fb( eq, true, pn, done);  delayed()->set(  0, Rresult );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2371
    fb( gt, true, pn, done);  delayed()->set(  1, Rresult );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2372
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2373
    bind (done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2374
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2375
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2376
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2377
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2378
void MacroAssembler::fneg( FloatRegisterImpl::Width w, FloatRegister s, FloatRegister d)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2379
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2380
  if (VM_Version::v9_instructions_work()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2381
    Assembler::fneg(w, s, d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2382
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2383
    if (w == FloatRegisterImpl::S) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2384
      Assembler::fneg(w, s, d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2385
    } else if (w == FloatRegisterImpl::D) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2386
      // number() does a sanity check on the alignment.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2387
      assert(((s->encoding(FloatRegisterImpl::D) & 1) == 0) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2388
        ((d->encoding(FloatRegisterImpl::D) & 1) == 0), "float register alignment check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2389
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2390
      Assembler::fneg(FloatRegisterImpl::S, s, d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2391
      Assembler::fmov(FloatRegisterImpl::S, s->successor(), d->successor());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2392
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2393
      assert(w == FloatRegisterImpl::Q, "Invalid float register width");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2394
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2395
      // number() does a sanity check on the alignment.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2396
      assert(((s->encoding(FloatRegisterImpl::D) & 3) == 0) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2397
        ((d->encoding(FloatRegisterImpl::D) & 3) == 0), "float register alignment check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2398
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2399
      Assembler::fneg(FloatRegisterImpl::S, s, d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2400
      Assembler::fmov(FloatRegisterImpl::S, s->successor(), d->successor());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2401
      Assembler::fmov(FloatRegisterImpl::S, s->successor()->successor(), d->successor()->successor());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2402
      Assembler::fmov(FloatRegisterImpl::S, s->successor()->successor()->successor(), d->successor()->successor()->successor());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2403
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2404
  }
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 MacroAssembler::fmov( FloatRegisterImpl::Width w, FloatRegister s, FloatRegister d)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2408
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2409
  if (VM_Version::v9_instructions_work()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2410
    Assembler::fmov(w, s, d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2411
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2412
    if (w == FloatRegisterImpl::S) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2413
      Assembler::fmov(w, s, d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2414
    } else if (w == FloatRegisterImpl::D) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2415
      // number() does a sanity check on the alignment.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2416
      assert(((s->encoding(FloatRegisterImpl::D) & 1) == 0) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2417
        ((d->encoding(FloatRegisterImpl::D) & 1) == 0), "float register alignment check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2418
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2419
      Assembler::fmov(FloatRegisterImpl::S, s, d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2420
      Assembler::fmov(FloatRegisterImpl::S, s->successor(), d->successor());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2421
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2422
      assert(w == FloatRegisterImpl::Q, "Invalid float register width");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2423
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2424
      // number() does a sanity check on the alignment.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2425
      assert(((s->encoding(FloatRegisterImpl::D) & 3) == 0) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2426
        ((d->encoding(FloatRegisterImpl::D) & 3) == 0), "float register alignment check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2427
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2428
      Assembler::fmov(FloatRegisterImpl::S, s, d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2429
      Assembler::fmov(FloatRegisterImpl::S, s->successor(), d->successor());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2430
      Assembler::fmov(FloatRegisterImpl::S, s->successor()->successor(), d->successor()->successor());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2431
      Assembler::fmov(FloatRegisterImpl::S, s->successor()->successor()->successor(), d->successor()->successor()->successor());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2432
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2433
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2434
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2435
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2436
void MacroAssembler::fabs( FloatRegisterImpl::Width w, FloatRegister s, FloatRegister d)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2437
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2438
  if (VM_Version::v9_instructions_work()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2439
    Assembler::fabs(w, s, d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2440
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2441
    if (w == FloatRegisterImpl::S) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2442
      Assembler::fabs(w, s, d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2443
    } else if (w == FloatRegisterImpl::D) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2444
      // number() does a sanity check on the alignment.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2445
      assert(((s->encoding(FloatRegisterImpl::D) & 1) == 0) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2446
        ((d->encoding(FloatRegisterImpl::D) & 1) == 0), "float register alignment check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2447
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2448
      Assembler::fabs(FloatRegisterImpl::S, s, d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2449
      Assembler::fmov(FloatRegisterImpl::S, s->successor(), d->successor());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2450
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2451
      assert(w == FloatRegisterImpl::Q, "Invalid float register width");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2452
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2453
      // number() does a sanity check on the alignment.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2454
      assert(((s->encoding(FloatRegisterImpl::D) & 3) == 0) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2455
       ((d->encoding(FloatRegisterImpl::D) & 3) == 0), "float register alignment check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2456
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2457
      Assembler::fabs(FloatRegisterImpl::S, s, d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2458
      Assembler::fmov(FloatRegisterImpl::S, s->successor(), d->successor());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2459
      Assembler::fmov(FloatRegisterImpl::S, s->successor()->successor(), d->successor()->successor());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2460
      Assembler::fmov(FloatRegisterImpl::S, s->successor()->successor()->successor(), d->successor()->successor()->successor());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2461
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2462
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2463
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2464
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2465
void MacroAssembler::save_all_globals_into_locals() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2466
  mov(G1,L1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2467
  mov(G2,L2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2468
  mov(G3,L3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2469
  mov(G4,L4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2470
  mov(G5,L5);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2471
  mov(G6,L6);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2472
  mov(G7,L7);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2473
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2474
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2475
void MacroAssembler::restore_globals_from_locals() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2476
  mov(L1,G1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2477
  mov(L2,G2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2478
  mov(L3,G3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2479
  mov(L4,G4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2480
  mov(L5,G5);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2481
  mov(L6,G6);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2482
  mov(L7,G7);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2483
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2484
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2485
// Use for 64 bit operation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2486
void MacroAssembler::casx_under_lock(Register top_ptr_reg, Register top_reg, Register ptr_reg, address lock_addr, bool use_call_vm)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2487
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2488
  // store ptr_reg as the new top value
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2489
#ifdef _LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2490
  casx(top_ptr_reg, top_reg, ptr_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2491
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2492
  cas_under_lock(top_ptr_reg, top_reg, ptr_reg, lock_addr, use_call_vm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2493
#endif // _LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2494
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2495
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2496
// [RGV] This routine does not handle 64 bit operations.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2497
//       use casx_under_lock() or casx directly!!!
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2498
void MacroAssembler::cas_under_lock(Register top_ptr_reg, Register top_reg, Register ptr_reg, address lock_addr, bool use_call_vm)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2499
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2500
  // store ptr_reg as the new top value
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2501
  if (VM_Version::v9_instructions_work()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2502
    cas(top_ptr_reg, top_reg, ptr_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2503
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2504
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2505
    // If the register is not an out nor global, it is not visible
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2506
    // after the save.  Allocate a register for it, save its
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2507
    // value in the register save area (the save may not flush
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2508
    // registers to the save area).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2509
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2510
    Register top_ptr_reg_after_save;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2511
    Register top_reg_after_save;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2512
    Register ptr_reg_after_save;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2513
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2514
    if (top_ptr_reg->is_out() || top_ptr_reg->is_global()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2515
      top_ptr_reg_after_save = top_ptr_reg->after_save();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2516
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2517
      Address reg_save_addr = top_ptr_reg->address_in_saved_window();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2518
      top_ptr_reg_after_save = L0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2519
      st(top_ptr_reg, reg_save_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2520
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2521
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2522
    if (top_reg->is_out() || top_reg->is_global()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2523
      top_reg_after_save = top_reg->after_save();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2524
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2525
      Address reg_save_addr = top_reg->address_in_saved_window();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2526
      top_reg_after_save = L1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2527
      st(top_reg, reg_save_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2528
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2529
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2530
    if (ptr_reg->is_out() || ptr_reg->is_global()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2531
      ptr_reg_after_save = ptr_reg->after_save();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2532
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2533
      Address reg_save_addr = ptr_reg->address_in_saved_window();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2534
      ptr_reg_after_save = L2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2535
      st(ptr_reg, reg_save_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2536
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2537
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2538
    const Register& lock_reg = L3;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2539
    const Register& lock_ptr_reg = L4;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2540
    const Register& value_reg = L5;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2541
    const Register& yield_reg = L6;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2542
    const Register& yieldall_reg = L7;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2543
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2544
    save_frame();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2545
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2546
    if (top_ptr_reg_after_save == L0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2547
      ld(top_ptr_reg->address_in_saved_window().after_save(), top_ptr_reg_after_save);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2548
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2549
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2550
    if (top_reg_after_save == L1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2551
      ld(top_reg->address_in_saved_window().after_save(), top_reg_after_save);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2552
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2553
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2554
    if (ptr_reg_after_save == L2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2555
      ld(ptr_reg->address_in_saved_window().after_save(), ptr_reg_after_save);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2556
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2557
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2558
    Label(retry_get_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2559
    Label(not_same);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2560
    Label(dont_yield);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2561
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2562
    assert(lock_addr, "lock_address should be non null for v8");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2563
    set((intptr_t)lock_addr, lock_ptr_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2564
    // Initialize yield counter
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2565
    mov(G0,yield_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2566
    mov(G0, yieldall_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2567
    set(StubRoutines::Sparc::locked, lock_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2568
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2569
    bind(retry_get_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2570
    cmp(yield_reg, V8AtomicOperationUnderLockSpinCount);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2571
    br(Assembler::less, false, Assembler::pt, dont_yield);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2572
    delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2573
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2574
    if(use_call_vm) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2575
      Untested("Need to verify global reg consistancy");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2576
      call_VM(noreg, CAST_FROM_FN_PTR(address, SharedRuntime::yield_all), yieldall_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2577
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2578
      // Save the regs and make space for a C call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2579
      save(SP, -96, SP);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2580
      save_all_globals_into_locals();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2581
      call(CAST_FROM_FN_PTR(address,os::yield_all));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2582
      delayed()->mov(yieldall_reg, O0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2583
      restore_globals_from_locals();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2584
      restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2585
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2586
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2587
    // reset the counter
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2588
    mov(G0,yield_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2589
    add(yieldall_reg, 1, yieldall_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2590
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2591
    bind(dont_yield);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2592
    // try to get lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2593
    swap(lock_ptr_reg, 0, lock_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2594
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2595
    // did we get the lock?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2596
    cmp(lock_reg, StubRoutines::Sparc::unlocked);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2597
    br(Assembler::notEqual, true, Assembler::pn, retry_get_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2598
    delayed()->add(yield_reg,1,yield_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2599
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2600
    // yes, got lock.  do we have the same top?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2601
    ld(top_ptr_reg_after_save, 0, value_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2602
    cmp(value_reg, top_reg_after_save);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2603
    br(Assembler::notEqual, false, Assembler::pn, not_same);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2604
    delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2605
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2606
    // yes, same top.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2607
    st(ptr_reg_after_save, top_ptr_reg_after_save, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2608
    membar(Assembler::StoreStore);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2609
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2610
    bind(not_same);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2611
    mov(value_reg, ptr_reg_after_save);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2612
    st(lock_reg, lock_ptr_reg, 0); // unlock
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2613
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2614
    restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2615
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2616
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2617
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1388
diff changeset
  2618
void MacroAssembler::biased_locking_enter(Register obj_reg, Register mark_reg,
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1388
diff changeset
  2619
                                          Register temp_reg,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2620
                                          Label& done, Label* slow_case,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2621
                                          BiasedLockingCounters* counters) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2622
  assert(UseBiasedLocking, "why call this otherwise?");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2623
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2624
  if (PrintBiasedLockingStatistics) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2625
    assert_different_registers(obj_reg, mark_reg, temp_reg, O7);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2626
    if (counters == NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2627
      counters = BiasedLocking::counters();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2628
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2629
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2630
  Label cas_label;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2631
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2632
  // Biased locking
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2633
  // See whether the lock is currently biased toward our thread and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2634
  // whether the epoch is still valid
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2635
  // Note that the runtime guarantees sufficient alignment of JavaThread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2636
  // pointers to allow age to be placed into low bits
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2637
  assert(markOopDesc::age_shift == markOopDesc::lock_bits + markOopDesc::biased_lock_bits, "biased locking makes assumptions about bit layout");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2638
  and3(mark_reg, markOopDesc::biased_lock_mask_in_place, temp_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2639
  cmp(temp_reg, markOopDesc::biased_lock_pattern);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2640
  brx(Assembler::notEqual, false, Assembler::pn, cas_label);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  2641
  delayed()->nop();
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  2642
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  2643
  load_klass(obj_reg, temp_reg);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2644
  ld_ptr(Address(temp_reg, 0, Klass::prototype_header_offset_in_bytes() + klassOopDesc::klass_part_offset_in_bytes()), temp_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2645
  or3(G2_thread, temp_reg, temp_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2646
  xor3(mark_reg, temp_reg, temp_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2647
  andcc(temp_reg, ~((int) markOopDesc::age_mask_in_place), temp_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2648
  if (counters != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2649
    cond_inc(Assembler::equal, (address) counters->biased_lock_entry_count_addr(), mark_reg, temp_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2650
    // Reload mark_reg as we may need it later
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2651
    ld_ptr(Address(obj_reg, 0, oopDesc::mark_offset_in_bytes()), mark_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2652
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2653
  brx(Assembler::equal, true, Assembler::pt, done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2654
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2655
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2656
  Label try_revoke_bias;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2657
  Label try_rebias;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2658
  Address mark_addr = Address(obj_reg, 0, oopDesc::mark_offset_in_bytes());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2659
  assert(mark_addr.disp() == 0, "cas must take a zero displacement");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2660
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2661
  // At this point we know that the header has the bias pattern and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2662
  // that we are not the bias owner in the current epoch. We need to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2663
  // figure out more details about the state of the header in order to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2664
  // know what operations can be legally performed on the object's
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2665
  // header.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2666
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2667
  // If the low three bits in the xor result aren't clear, that means
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2668
  // the prototype header is no longer biased and we have to revoke
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2669
  // the bias on this object.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2670
  btst(markOopDesc::biased_lock_mask_in_place, temp_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2671
  brx(Assembler::notZero, false, Assembler::pn, try_revoke_bias);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2672
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2673
  // Biasing is still enabled for this data type. See whether the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2674
  // epoch of the current bias is still valid, meaning that the epoch
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2675
  // bits of the mark word are equal to the epoch bits of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2676
  // prototype header. (Note that the prototype header's epoch bits
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2677
  // only change at a safepoint.) If not, attempt to rebias the object
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2678
  // toward the current thread. Note that we must be absolutely sure
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2679
  // that the current epoch is invalid in order to do this because
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2680
  // otherwise the manipulations it performs on the mark word are
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2681
  // illegal.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2682
  delayed()->btst(markOopDesc::epoch_mask_in_place, temp_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2683
  brx(Assembler::notZero, false, Assembler::pn, try_rebias);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2684
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2685
  // The epoch of the current bias is still valid but we know nothing
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2686
  // about the owner; it might be set or it might be clear. Try to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2687
  // acquire the bias of the object using an atomic operation. If this
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2688
  // fails we will go in to the runtime to revoke the object's bias.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2689
  // Note that we first construct the presumed unbiased header so we
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2690
  // don't accidentally blow away another thread's valid bias.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2691
  delayed()->and3(mark_reg,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2692
                  markOopDesc::biased_lock_mask_in_place | markOopDesc::age_mask_in_place | markOopDesc::epoch_mask_in_place,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2693
                  mark_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2694
  or3(G2_thread, mark_reg, temp_reg);
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1388
diff changeset
  2695
  casn(mark_addr.base(), mark_reg, temp_reg);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2696
  // If the biasing toward our thread failed, this means that
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2697
  // another thread succeeded in biasing it toward itself and we
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2698
  // need to revoke that bias. The revocation will occur in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2699
  // interpreter runtime in the slow case.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2700
  cmp(mark_reg, temp_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2701
  if (counters != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2702
    cond_inc(Assembler::zero, (address) counters->anonymously_biased_lock_entry_count_addr(), mark_reg, temp_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2703
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2704
  if (slow_case != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2705
    brx(Assembler::notEqual, true, Assembler::pn, *slow_case);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2706
    delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2707
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2708
  br(Assembler::always, false, Assembler::pt, done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2709
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2710
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2711
  bind(try_rebias);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2712
  // At this point we know the epoch has expired, meaning that the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2713
  // current "bias owner", if any, is actually invalid. Under these
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2714
  // circumstances _only_, we are allowed to use the current header's
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2715
  // value as the comparison value when doing the cas to acquire the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2716
  // bias in the current epoch. In other words, we allow transfer of
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2717
  // the bias from one thread to another directly in this situation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2718
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2719
  // FIXME: due to a lack of registers we currently blow away the age
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2720
  // bits in this situation. Should attempt to preserve them.
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  2721
  load_klass(obj_reg, temp_reg);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2722
  ld_ptr(Address(temp_reg, 0, Klass::prototype_header_offset_in_bytes() + klassOopDesc::klass_part_offset_in_bytes()), temp_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2723
  or3(G2_thread, temp_reg, temp_reg);
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1388
diff changeset
  2724
  casn(mark_addr.base(), mark_reg, temp_reg);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2725
  // If the biasing toward our thread failed, this means that
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2726
  // another thread succeeded in biasing it toward itself and we
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2727
  // need to revoke that bias. The revocation will occur in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2728
  // interpreter runtime in the slow case.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2729
  cmp(mark_reg, temp_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2730
  if (counters != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2731
    cond_inc(Assembler::zero, (address) counters->rebiased_lock_entry_count_addr(), mark_reg, temp_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2732
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2733
  if (slow_case != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2734
    brx(Assembler::notEqual, true, Assembler::pn, *slow_case);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2735
    delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2736
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2737
  br(Assembler::always, false, Assembler::pt, done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2738
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2739
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2740
  bind(try_revoke_bias);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2741
  // The prototype mark in the klass doesn't have the bias bit set any
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2742
  // more, indicating that objects of this data type are not supposed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2743
  // to be biased any more. We are going to try to reset the mark of
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2744
  // this object to the prototype value and fall through to the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2745
  // CAS-based locking scheme. Note that if our CAS fails, it means
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2746
  // that another thread raced us for the privilege of revoking the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2747
  // bias of this particular object, so it's okay to continue in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2748
  // normal locking code.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2749
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2750
  // FIXME: due to a lack of registers we currently blow away the age
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2751
  // bits in this situation. Should attempt to preserve them.
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  2752
  load_klass(obj_reg, temp_reg);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2753
  ld_ptr(Address(temp_reg, 0, Klass::prototype_header_offset_in_bytes() + klassOopDesc::klass_part_offset_in_bytes()), temp_reg);
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1388
diff changeset
  2754
  casn(mark_addr.base(), mark_reg, temp_reg);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2755
  // Fall through to the normal CAS-based lock, because no matter what
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2756
  // the result of the above CAS, some thread must have succeeded in
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2757
  // removing the bias bit from the object's header.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2758
  if (counters != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2759
    cmp(mark_reg, temp_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2760
    cond_inc(Assembler::zero, (address) counters->revoked_lock_entry_count_addr(), mark_reg, temp_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2761
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2762
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2763
  bind(cas_label);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2764
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2765
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2766
void MacroAssembler::biased_locking_exit (Address mark_addr, Register temp_reg, Label& done,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2767
                                          bool allow_delay_slot_filling) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2768
  // Check for biased locking unlock case, which is a no-op
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2769
  // Note: we do not have to check the thread ID for two reasons.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2770
  // First, the interpreter checks for IllegalMonitorStateException at
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2771
  // a higher level. Second, if the bias was revoked while we held the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2772
  // lock, the object could not be rebiased toward another thread, so
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2773
  // the bias bit would be clear.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2774
  ld_ptr(mark_addr, temp_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2775
  and3(temp_reg, markOopDesc::biased_lock_mask_in_place, temp_reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2776
  cmp(temp_reg, markOopDesc::biased_lock_pattern);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2777
  brx(Assembler::equal, allow_delay_slot_filling, Assembler::pt, done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2778
  delayed();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2779
  if (!allow_delay_slot_filling) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2780
    nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2781
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2782
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2783
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2784
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2785
// CASN -- 32-64 bit switch hitter similar to the synthetic CASN provided by
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2786
// Solaris/SPARC's "as".  Another apt name would be cas_ptr()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2787
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2788
void MacroAssembler::casn (Register addr_reg, Register cmp_reg, Register set_reg ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2789
  casx_under_lock (addr_reg, cmp_reg, set_reg, (address)StubRoutines::Sparc::atomic_memory_operation_lock_addr()) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2790
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2791
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2792
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2793
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2794
// compiler_lock_object() and compiler_unlock_object() are direct transliterations
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2795
// of i486.ad fast_lock() and fast_unlock().  See those methods for detailed comments.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2796
// The code could be tightened up considerably.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2797
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2798
// box->dhw disposition - post-conditions at DONE_LABEL.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2799
// -   Successful inflated lock:  box->dhw != 0.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2800
//     Any non-zero value suffices.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2801
//     Consider G2_thread, rsp, boxReg, or unused_mark()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2802
// -   Successful Stack-lock: box->dhw == mark.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2803
//     box->dhw must contain the displaced mark word value
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2804
// -   Failure -- icc.ZFlag == 0 and box->dhw is undefined.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2805
//     The slow-path fast_enter() and slow_enter() operators
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2806
//     are responsible for setting box->dhw = NonZero (typically ::unused_mark).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2807
// -   Biased: box->dhw is undefined
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2808
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2809
// SPARC refworkload performance - specifically jetstream and scimark - are
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2810
// extremely sensitive to the size of the code emitted by compiler_lock_object
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2811
// and compiler_unlock_object.  Critically, the key factor is code size, not path
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2812
// length.  (Simply experiments to pad CLO with unexecuted NOPs demonstrte the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2813
// effect).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2814
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2815
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1388
diff changeset
  2816
void MacroAssembler::compiler_lock_object(Register Roop, Register Rmark,
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1388
diff changeset
  2817
                                          Register Rbox, Register Rscratch,
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1388
diff changeset
  2818
                                          BiasedLockingCounters* counters,
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1388
diff changeset
  2819
                                          bool try_bias) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2820
   Address mark_addr(Roop, 0, oopDesc::mark_offset_in_bytes());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2821
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2822
   verify_oop(Roop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2823
   Label done ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2824
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2825
   if (counters != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2826
     inc_counter((address) counters->total_entry_count_addr(), Rmark, Rscratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2827
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2828
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2829
   if (EmitSync & 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2830
     mov    (3, Rscratch) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2831
     st_ptr (Rscratch, Rbox, BasicLock::displaced_header_offset_in_bytes());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2832
     cmp    (SP, G0) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2833
     return ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2834
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2835
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2836
   if (EmitSync & 2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2837
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2838
     // Fetch object's markword
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2839
     ld_ptr(mark_addr, Rmark);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2840
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1388
diff changeset
  2841
     if (try_bias) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2842
        biased_locking_enter(Roop, Rmark, Rscratch, done, NULL, counters);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2843
     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2844
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2845
     // Save Rbox in Rscratch to be used for the cas operation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2846
     mov(Rbox, Rscratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2847
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2848
     // set Rmark to markOop | markOopDesc::unlocked_value
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2849
     or3(Rmark, markOopDesc::unlocked_value, Rmark);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2850
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2851
     // Initialize the box.  (Must happen before we update the object mark!)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2852
     st_ptr(Rmark, Rbox, BasicLock::displaced_header_offset_in_bytes());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2853
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2854
     // compare object markOop with Rmark and if equal exchange Rscratch with object markOop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2855
     assert(mark_addr.disp() == 0, "cas must take a zero displacement");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2856
     casx_under_lock(mark_addr.base(), Rmark, Rscratch,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2857
        (address)StubRoutines::Sparc::atomic_memory_operation_lock_addr());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2858
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2859
     // if compare/exchange succeeded we found an unlocked object and we now have locked it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2860
     // hence we are done
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2861
     cmp(Rmark, Rscratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2862
#ifdef _LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2863
     sub(Rscratch, STACK_BIAS, Rscratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2864
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2865
     brx(Assembler::equal, false, Assembler::pt, done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2866
     delayed()->sub(Rscratch, SP, Rscratch);  //pull next instruction into delay slot
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2867
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2868
     // we did not find an unlocked object so see if this is a recursive case
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2869
     // sub(Rscratch, SP, Rscratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2870
     assert(os::vm_page_size() > 0xfff, "page size too small - change the constant");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2871
     andcc(Rscratch, 0xfffff003, Rscratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2872
     st_ptr(Rscratch, Rbox, BasicLock::displaced_header_offset_in_bytes());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2873
     bind (done) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2874
     return ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2875
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2876
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2877
   Label Egress ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2878
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2879
   if (EmitSync & 256) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2880
      Label IsInflated ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2881
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2882
      ld_ptr (mark_addr, Rmark);           // fetch obj->mark
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2883
      // Triage: biased, stack-locked, neutral, inflated
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1388
diff changeset
  2884
      if (try_bias) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2885
        biased_locking_enter(Roop, Rmark, Rscratch, done, NULL, counters);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2886
        // Invariant: if control reaches this point in the emitted stream
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2887
        // then Rmark has not been modified.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2888
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2889
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2890
      // Store mark into displaced mark field in the on-stack basic-lock "box"
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2891
      // Critically, this must happen before the CAS
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2892
      // Maximize the ST-CAS distance to minimize the ST-before-CAS penalty.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2893
      st_ptr (Rmark, Rbox, BasicLock::displaced_header_offset_in_bytes());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2894
      andcc  (Rmark, 2, G0) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2895
      brx    (Assembler::notZero, false, Assembler::pn, IsInflated) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2896
      delayed() ->
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2897
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2898
      // Try stack-lock acquisition.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2899
      // Beware: the 1st instruction is in a delay slot
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2900
      mov    (Rbox,  Rscratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2901
      or3    (Rmark, markOopDesc::unlocked_value, Rmark);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2902
      assert (mark_addr.disp() == 0, "cas must take a zero displacement");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2903
      casn   (mark_addr.base(), Rmark, Rscratch) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2904
      cmp    (Rmark, Rscratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2905
      brx    (Assembler::equal, false, Assembler::pt, done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2906
      delayed()->sub(Rscratch, SP, Rscratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2907
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2908
      // Stack-lock attempt failed - check for recursive stack-lock.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2909
      // See the comments below about how we might remove this case.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2910
#ifdef _LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2911
      sub    (Rscratch, STACK_BIAS, Rscratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2912
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2913
      assert(os::vm_page_size() > 0xfff, "page size too small - change the constant");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2914
      andcc  (Rscratch, 0xfffff003, Rscratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2915
      br     (Assembler::always, false, Assembler::pt, done) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2916
      delayed()-> st_ptr (Rscratch, Rbox, BasicLock::displaced_header_offset_in_bytes());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2917
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2918
      bind   (IsInflated) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2919
      if (EmitSync & 64) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2920
         // If m->owner != null goto IsLocked
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2921
         // Pessimistic form: Test-and-CAS vs CAS
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2922
         // The optimistic form avoids RTS->RTO cache line upgrades.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2923
         ld_ptr (Address (Rmark, 0, ObjectMonitor::owner_offset_in_bytes()-2), Rscratch) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2924
         andcc  (Rscratch, Rscratch, G0) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2925
         brx    (Assembler::notZero, false, Assembler::pn, done) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2926
         delayed()->nop() ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2927
         // m->owner == null : it's unlocked.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2928
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2929
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2930
      // Try to CAS m->owner from null to Self
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2931
      // Invariant: if we acquire the lock then _recursions should be 0.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2932
      add    (Rmark, ObjectMonitor::owner_offset_in_bytes()-2, Rmark) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2933
      mov    (G2_thread, Rscratch) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2934
      casn   (Rmark, G0, Rscratch) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2935
      cmp    (Rscratch, G0) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2936
      // Intentional fall-through into done
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2937
   } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2938
      // Aggressively avoid the Store-before-CAS penalty
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2939
      // Defer the store into box->dhw until after the CAS
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2940
      Label IsInflated, Recursive ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2941
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2942
// Anticipate CAS -- Avoid RTS->RTO upgrade
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2943
// prefetch (mark_addr, Assembler::severalWritesAndPossiblyReads) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2944
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2945
      ld_ptr (mark_addr, Rmark);           // fetch obj->mark
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2946
      // Triage: biased, stack-locked, neutral, inflated
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2947
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1388
diff changeset
  2948
      if (try_bias) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2949
        biased_locking_enter(Roop, Rmark, Rscratch, done, NULL, counters);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2950
        // Invariant: if control reaches this point in the emitted stream
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2951
        // then Rmark has not been modified.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2952
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2953
      andcc  (Rmark, 2, G0) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2954
      brx    (Assembler::notZero, false, Assembler::pn, IsInflated) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2955
      delayed()->                         // Beware - dangling delay-slot
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2956
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2957
      // Try stack-lock acquisition.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2958
      // Transiently install BUSY (0) encoding in the mark word.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2959
      // if the CAS of 0 into the mark was successful then we execute:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2960
      //   ST box->dhw  = mark   -- save fetched mark in on-stack basiclock box
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2961
      //   ST obj->mark = box    -- overwrite transient 0 value
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2962
      // This presumes TSO, of course.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2963
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2964
      mov    (0, Rscratch) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2965
      or3    (Rmark, markOopDesc::unlocked_value, Rmark);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2966
      assert (mark_addr.disp() == 0, "cas must take a zero displacement");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2967
      casn   (mark_addr.base(), Rmark, Rscratch) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2968
// prefetch (mark_addr, Assembler::severalWritesAndPossiblyReads) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2969
      cmp    (Rscratch, Rmark) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2970
      brx    (Assembler::notZero, false, Assembler::pn, Recursive) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2971
      delayed() ->
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2972
        st_ptr (Rmark, Rbox, BasicLock::displaced_header_offset_in_bytes());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2973
      if (counters != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2974
        cond_inc(Assembler::equal, (address) counters->fast_path_entry_count_addr(), Rmark, Rscratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2975
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2976
      br     (Assembler::always, false, Assembler::pt, done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2977
      delayed() ->
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2978
        st_ptr (Rbox, mark_addr) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2979
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2980
      bind   (Recursive) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2981
      // Stack-lock attempt failed - check for recursive stack-lock.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2982
      // Tests show that we can remove the recursive case with no impact
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2983
      // on refworkload 0.83.  If we need to reduce the size of the code
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2984
      // emitted by compiler_lock_object() the recursive case is perfect
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2985
      // candidate.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2986
      //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2987
      // A more extreme idea is to always inflate on stack-lock recursion.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2988
      // This lets us eliminate the recursive checks in compiler_lock_object
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2989
      // and compiler_unlock_object and the (box->dhw == 0) encoding.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2990
      // A brief experiment - requiring changes to synchronizer.cpp, interpreter,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2991
      // and showed a performance *increase*.  In the same experiment I eliminated
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2992
      // the fast-path stack-lock code from the interpreter and always passed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2993
      // control to the "slow" operators in synchronizer.cpp.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2994
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2995
      // RScratch contains the fetched obj->mark value from the failed CASN.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2996
#ifdef _LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2997
      sub    (Rscratch, STACK_BIAS, Rscratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2998
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2999
      sub(Rscratch, SP, Rscratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3000
      assert(os::vm_page_size() > 0xfff, "page size too small - change the constant");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3001
      andcc  (Rscratch, 0xfffff003, Rscratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3002
      if (counters != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3003
        // Accounting needs the Rscratch register
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3004
        st_ptr (Rscratch, Rbox, BasicLock::displaced_header_offset_in_bytes());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3005
        cond_inc(Assembler::equal, (address) counters->fast_path_entry_count_addr(), Rmark, Rscratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3006
        br     (Assembler::always, false, Assembler::pt, done) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3007
        delayed()->nop() ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3008
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3009
        br     (Assembler::always, false, Assembler::pt, done) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3010
        delayed()-> st_ptr (Rscratch, Rbox, BasicLock::displaced_header_offset_in_bytes());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3011
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3012
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3013
      bind   (IsInflated) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3014
      if (EmitSync & 64) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3015
         // If m->owner != null goto IsLocked
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3016
         // Test-and-CAS vs CAS
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3017
         // Pessimistic form avoids futile (doomed) CAS attempts
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3018
         // The optimistic form avoids RTS->RTO cache line upgrades.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3019
         ld_ptr (Address (Rmark, 0, ObjectMonitor::owner_offset_in_bytes()-2), Rscratch) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3020
         andcc  (Rscratch, Rscratch, G0) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3021
         brx    (Assembler::notZero, false, Assembler::pn, done) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3022
         delayed()->nop() ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3023
         // m->owner == null : it's unlocked.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3024
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3025
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3026
      // Try to CAS m->owner from null to Self
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3027
      // Invariant: if we acquire the lock then _recursions should be 0.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3028
      add    (Rmark, ObjectMonitor::owner_offset_in_bytes()-2, Rmark) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3029
      mov    (G2_thread, Rscratch) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3030
      casn   (Rmark, G0, Rscratch) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3031
      cmp    (Rscratch, G0) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3032
      // ST box->displaced_header = NonZero.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3033
      // Any non-zero value suffices:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3034
      //    unused_mark(), G2_thread, RBox, RScratch, rsp, etc.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3035
      st_ptr (Rbox, Rbox, BasicLock::displaced_header_offset_in_bytes());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3036
      // Intentional fall-through into done
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3037
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3038
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3039
   bind   (done) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3040
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3041
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1388
diff changeset
  3042
void MacroAssembler::compiler_unlock_object(Register Roop, Register Rmark,
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1388
diff changeset
  3043
                                            Register Rbox, Register Rscratch,
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1388
diff changeset
  3044
                                            bool try_bias) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3045
   Address mark_addr(Roop, 0, oopDesc::mark_offset_in_bytes());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3046
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3047
   Label done ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3048
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3049
   if (EmitSync & 4) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3050
     cmp  (SP, G0) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3051
     return ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3052
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3053
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3054
   if (EmitSync & 8) {
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1388
diff changeset
  3055
     if (try_bias) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3056
        biased_locking_exit(mark_addr, Rscratch, done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3057
     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3058
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3059
     // Test first if it is a fast recursive unlock
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3060
     ld_ptr(Rbox, BasicLock::displaced_header_offset_in_bytes(), Rmark);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3061
     cmp(Rmark, G0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3062
     brx(Assembler::equal, false, Assembler::pt, done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3063
     delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3064
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3065
     // Check if it is still a light weight lock, this is is true if we see
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3066
     // the stack address of the basicLock in the markOop of the object
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3067
     assert(mark_addr.disp() == 0, "cas must take a zero displacement");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3068
     casx_under_lock(mark_addr.base(), Rbox, Rmark,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3069
       (address)StubRoutines::Sparc::atomic_memory_operation_lock_addr());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3070
     br (Assembler::always, false, Assembler::pt, done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3071
     delayed()->cmp(Rbox, Rmark);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3072
     bind (done) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3073
     return ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3074
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3075
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3076
   // Beware ... If the aggregate size of the code emitted by CLO and CUO is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3077
   // is too large performance rolls abruptly off a cliff.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3078
   // This could be related to inlining policies, code cache management, or
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3079
   // I$ effects.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3080
   Label LStacked ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3081
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1388
diff changeset
  3082
   if (try_bias) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3083
      // TODO: eliminate redundant LDs of obj->mark
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3084
      biased_locking_exit(mark_addr, Rscratch, done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3085
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3086
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3087
   ld_ptr (Roop, oopDesc::mark_offset_in_bytes(), Rmark) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3088
   ld_ptr (Rbox, BasicLock::displaced_header_offset_in_bytes(), Rscratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3089
   andcc  (Rscratch, Rscratch, G0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3090
   brx    (Assembler::zero, false, Assembler::pn, done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3091
   delayed()-> nop() ;      // consider: relocate fetch of mark, above, into this DS
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3092
   andcc  (Rmark, 2, G0) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3093
   brx    (Assembler::zero, false, Assembler::pt, LStacked) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3094
   delayed()-> nop() ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3095
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3096
   // It's inflated
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3097
   // Conceptually we need a #loadstore|#storestore "release" MEMBAR before
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3098
   // the ST of 0 into _owner which releases the lock.  This prevents loads
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3099
   // and stores within the critical section from reordering (floating)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3100
   // past the store that releases the lock.  But TSO is a strong memory model
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3101
   // and that particular flavor of barrier is a noop, so we can safely elide it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3102
   // Note that we use 1-0 locking by default for the inflated case.  We
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3103
   // close the resultant (and rare) race by having contented threads in
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3104
   // monitorenter periodically poll _owner.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3105
   ld_ptr (Address(Rmark, 0, ObjectMonitor::owner_offset_in_bytes()-2), Rscratch) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3106
   ld_ptr (Address(Rmark, 0, ObjectMonitor::recursions_offset_in_bytes()-2), Rbox) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3107
   xor3   (Rscratch, G2_thread, Rscratch) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3108
   orcc   (Rbox, Rscratch, Rbox) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3109
   brx    (Assembler::notZero, false, Assembler::pn, done) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3110
   delayed()->
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3111
   ld_ptr (Address (Rmark, 0, ObjectMonitor::EntryList_offset_in_bytes()-2), Rscratch) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3112
   ld_ptr (Address (Rmark, 0, ObjectMonitor::cxq_offset_in_bytes()-2), Rbox) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3113
   orcc   (Rbox, Rscratch, G0) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3114
   if (EmitSync & 65536) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3115
      Label LSucc ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3116
      brx    (Assembler::notZero, false, Assembler::pn, LSucc) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3117
      delayed()->nop() ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3118
      br     (Assembler::always, false, Assembler::pt, done) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3119
      delayed()->
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3120
      st_ptr (G0, Address (Rmark, 0, ObjectMonitor::owner_offset_in_bytes()-2)) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3121
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3122
      bind   (LSucc) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3123
      st_ptr (G0, Address (Rmark, 0, ObjectMonitor::owner_offset_in_bytes()-2)) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3124
      if (os::is_MP()) { membar (StoreLoad) ; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3125
      ld_ptr (Address (Rmark, 0, ObjectMonitor::succ_offset_in_bytes()-2), Rscratch) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3126
      andcc  (Rscratch, Rscratch, G0) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3127
      brx    (Assembler::notZero, false, Assembler::pt, done) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3128
      delayed()-> andcc (G0, G0, G0) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3129
      add    (Rmark, ObjectMonitor::owner_offset_in_bytes()-2, Rmark) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3130
      mov    (G2_thread, Rscratch) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3131
      casn   (Rmark, G0, Rscratch) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3132
      cmp    (Rscratch, G0) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3133
      // invert icc.zf and goto done
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3134
      brx    (Assembler::notZero, false, Assembler::pt, done) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3135
      delayed() -> cmp (G0, G0) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3136
      br     (Assembler::always, false, Assembler::pt, done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3137
      delayed() -> cmp (G0, 1) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3138
   } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3139
      brx    (Assembler::notZero, false, Assembler::pn, done) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3140
      delayed()->nop() ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3141
      br     (Assembler::always, false, Assembler::pt, done) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3142
      delayed()->
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3143
      st_ptr (G0, Address (Rmark, 0, ObjectMonitor::owner_offset_in_bytes()-2)) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3144
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3145
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3146
   bind   (LStacked) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3147
   // Consider: we could replace the expensive CAS in the exit
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3148
   // path with a simple ST of the displaced mark value fetched from
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3149
   // the on-stack basiclock box.  That admits a race where a thread T2
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3150
   // in the slow lock path -- inflating with monitor M -- could race a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3151
   // thread T1 in the fast unlock path, resulting in a missed wakeup for T2.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3152
   // More precisely T1 in the stack-lock unlock path could "stomp" the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3153
   // inflated mark value M installed by T2, resulting in an orphan
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3154
   // object monitor M and T2 becoming stranded.  We can remedy that situation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3155
   // by having T2 periodically poll the object's mark word using timed wait
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3156
   // operations.  If T2 discovers that a stomp has occurred it vacates
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3157
   // the monitor M and wakes any other threads stranded on the now-orphan M.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3158
   // In addition the monitor scavenger, which performs deflation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3159
   // would also need to check for orpan monitors and stranded threads.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3160
   //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3161
   // Finally, inflation is also used when T2 needs to assign a hashCode
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3162
   // to O and O is stack-locked by T1.  The "stomp" race could cause
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3163
   // an assigned hashCode value to be lost.  We can avoid that condition
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3164
   // and provide the necessary hashCode stability invariants by ensuring
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3165
   // that hashCode generation is idempotent between copying GCs.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3166
   // For example we could compute the hashCode of an object O as
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3167
   // O's heap address XOR some high quality RNG value that is refreshed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3168
   // at GC-time.  The monitor scavenger would install the hashCode
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3169
   // found in any orphan monitors.  Again, the mechanism admits a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3170
   // lost-update "stomp" WAW race but detects and recovers as needed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3171
   //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3172
   // A prototype implementation showed excellent results, although
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3173
   // the scavenger and timeout code was rather involved.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3174
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3175
   casn   (mark_addr.base(), Rbox, Rscratch) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3176
   cmp    (Rbox, Rscratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3177
   // Intentional fall through into done ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3178
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3179
   bind   (done) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3180
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3181
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3182
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3183
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3184
void MacroAssembler::print_CPU_state() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3185
  // %%%%% need to implement this
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3186
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3187
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3188
void MacroAssembler::verify_FPU(int stack_depth, const char* s) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3189
  // %%%%% need to implement this
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3190
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3191
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3192
void MacroAssembler::push_IU_state() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3193
  // %%%%% need to implement this
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3194
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3195
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3196
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3197
void MacroAssembler::pop_IU_state() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3198
  // %%%%% need to implement this
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3199
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3200
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3201
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3202
void MacroAssembler::push_FPU_state() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3203
  // %%%%% need to implement this
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3204
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3205
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3206
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3207
void MacroAssembler::pop_FPU_state() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3208
  // %%%%% need to implement this
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3209
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3210
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3211
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3212
void MacroAssembler::push_CPU_state() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3213
  // %%%%% need to implement this
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3214
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3215
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3216
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3217
void MacroAssembler::pop_CPU_state() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3218
  // %%%%% need to implement this
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3219
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3220
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3221
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3222
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3223
void MacroAssembler::verify_tlab() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3224
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3225
  if (UseTLAB && VerifyOops) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3226
    Label next, next2, ok;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3227
    Register t1 = L0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3228
    Register t2 = L1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3229
    Register t3 = L2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3230
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3231
    save_frame(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3232
    ld_ptr(G2_thread, in_bytes(JavaThread::tlab_top_offset()), t1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3233
    ld_ptr(G2_thread, in_bytes(JavaThread::tlab_start_offset()), t2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3234
    or3(t1, t2, t3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3235
    cmp(t1, t2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3236
    br(Assembler::greaterEqual, false, Assembler::pn, next);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3237
    delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3238
    stop("assert(top >= start)");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3239
    should_not_reach_here();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3240
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3241
    bind(next);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3242
    ld_ptr(G2_thread, in_bytes(JavaThread::tlab_top_offset()), t1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3243
    ld_ptr(G2_thread, in_bytes(JavaThread::tlab_end_offset()), t2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3244
    or3(t3, t2, t3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3245
    cmp(t1, t2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3246
    br(Assembler::lessEqual, false, Assembler::pn, next2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3247
    delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3248
    stop("assert(top <= end)");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3249
    should_not_reach_here();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3250
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3251
    bind(next2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3252
    and3(t3, MinObjAlignmentInBytesMask, t3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3253
    cmp(t3, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3254
    br(Assembler::lessEqual, false, Assembler::pn, ok);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3255
    delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3256
    stop("assert(aligned)");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3257
    should_not_reach_here();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3258
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3259
    bind(ok);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3260
    restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3261
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3262
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3263
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3264
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3265
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3266
void MacroAssembler::eden_allocate(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3267
  Register obj,                        // result: pointer to object after successful allocation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3268
  Register var_size_in_bytes,          // object size in bytes if unknown at compile time; invalid otherwise
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3269
  int      con_size_in_bytes,          // object size in bytes if   known at compile time
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3270
  Register t1,                         // temp register
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3271
  Register t2,                         // temp register
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3272
  Label&   slow_case                   // continuation point if fast allocation fails
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3273
){
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3274
  // make sure arguments make sense
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3275
  assert_different_registers(obj, var_size_in_bytes, t1, t2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3276
  assert(0 <= con_size_in_bytes && Assembler::is_simm13(con_size_in_bytes), "illegal object size");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3277
  assert((con_size_in_bytes & MinObjAlignmentInBytesMask) == 0, "object size is not multiple of alignment");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3278
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3279
  if (CMSIncrementalMode || !Universe::heap()->supports_inline_contig_alloc()) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3280
    // No allocation in the shared eden.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3281
    br(Assembler::always, false, Assembler::pt, slow_case);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3282
    delayed()->nop();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3283
  } else {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3284
    // get eden boundaries
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3285
    // note: we need both top & top_addr!
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3286
    const Register top_addr = t1;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3287
    const Register end      = t2;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3288
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3289
    CollectedHeap* ch = Universe::heap();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3290
    set((intx)ch->top_addr(), top_addr);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3291
    intx delta = (intx)ch->end_addr() - (intx)ch->top_addr();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3292
    ld_ptr(top_addr, delta, end);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3293
    ld_ptr(top_addr, 0, obj);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3294
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3295
    // try to allocate
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3296
    Label retry;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3297
    bind(retry);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3298
#ifdef ASSERT
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3299
    // make sure eden top is properly aligned
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3300
    {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3301
      Label L;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3302
      btst(MinObjAlignmentInBytesMask, obj);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3303
      br(Assembler::zero, false, Assembler::pt, L);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3304
      delayed()->nop();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3305
      stop("eden top is not properly aligned");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3306
      bind(L);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3307
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3308
#endif // ASSERT
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3309
    const Register free = end;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3310
    sub(end, obj, free);                                   // compute amount of free space
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3311
    if (var_size_in_bytes->is_valid()) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3312
      // size is unknown at compile time
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3313
      cmp(free, var_size_in_bytes);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3314
      br(Assembler::lessUnsigned, false, Assembler::pn, slow_case); // if there is not enough space go the slow case
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3315
      delayed()->add(obj, var_size_in_bytes, end);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3316
    } else {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3317
      // size is known at compile time
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3318
      cmp(free, con_size_in_bytes);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3319
      br(Assembler::lessUnsigned, false, Assembler::pn, slow_case); // if there is not enough space go the slow case
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3320
      delayed()->add(obj, con_size_in_bytes, end);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3321
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3322
    // Compare obj with the value at top_addr; if still equal, swap the value of
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3323
    // end with the value at top_addr. If not equal, read the value at top_addr
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3324
    // into end.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3325
    casx_under_lock(top_addr, obj, end, (address)StubRoutines::Sparc::atomic_memory_operation_lock_addr());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3326
    // if someone beat us on the allocation, try again, otherwise continue
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3327
    cmp(obj, end);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3328
    brx(Assembler::notEqual, false, Assembler::pn, retry);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3329
    delayed()->mov(end, obj);                              // nop if successfull since obj == end
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3330
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3331
#ifdef ASSERT
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3332
    // make sure eden top is properly aligned
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3333
    {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3334
      Label L;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3335
      const Register top_addr = t1;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3336
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3337
      set((intx)ch->top_addr(), top_addr);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3338
      ld_ptr(top_addr, 0, top_addr);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3339
      btst(MinObjAlignmentInBytesMask, top_addr);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3340
      br(Assembler::zero, false, Assembler::pt, L);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3341
      delayed()->nop();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3342
      stop("eden top is not properly aligned");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3343
      bind(L);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3344
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3345
#endif // ASSERT
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3346
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3347
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3348
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3349
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3350
void MacroAssembler::tlab_allocate(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3351
  Register obj,                        // result: pointer to object after successful allocation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3352
  Register var_size_in_bytes,          // object size in bytes if unknown at compile time; invalid otherwise
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3353
  int      con_size_in_bytes,          // object size in bytes if   known at compile time
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3354
  Register t1,                         // temp register
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3355
  Label&   slow_case                   // continuation point if fast allocation fails
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3356
){
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3357
  // make sure arguments make sense
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3358
  assert_different_registers(obj, var_size_in_bytes, t1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3359
  assert(0 <= con_size_in_bytes && is_simm13(con_size_in_bytes), "illegal object size");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3360
  assert((con_size_in_bytes & MinObjAlignmentInBytesMask) == 0, "object size is not multiple of alignment");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3361
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3362
  const Register free  = t1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3363
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3364
  verify_tlab();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3365
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3366
  ld_ptr(G2_thread, in_bytes(JavaThread::tlab_top_offset()), obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3367
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3368
  // calculate amount of free space
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3369
  ld_ptr(G2_thread, in_bytes(JavaThread::tlab_end_offset()), free);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3370
  sub(free, obj, free);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3371
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3372
  Label done;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3373
  if (var_size_in_bytes == noreg) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3374
    cmp(free, con_size_in_bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3375
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3376
    cmp(free, var_size_in_bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3377
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3378
  br(Assembler::less, false, Assembler::pn, slow_case);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3379
  // calculate the new top pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3380
  if (var_size_in_bytes == noreg) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3381
    delayed()->add(obj, con_size_in_bytes, free);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3382
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3383
    delayed()->add(obj, var_size_in_bytes, free);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3384
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3385
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3386
  bind(done);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3387
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3388
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3389
  // make sure new free pointer is properly aligned
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3390
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3391
    Label L;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3392
    btst(MinObjAlignmentInBytesMask, free);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3393
    br(Assembler::zero, false, Assembler::pt, L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3394
    delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3395
    stop("updated TLAB free is not properly aligned");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3396
    bind(L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3397
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3398
#endif // ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3399
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3400
  // update the tlab top pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3401
  st_ptr(free, G2_thread, in_bytes(JavaThread::tlab_top_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3402
  verify_tlab();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3403
}
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 MacroAssembler::tlab_refill(Label& retry, Label& try_eden, Label& slow_case) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3407
  Register top = O0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3408
  Register t1 = G1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3409
  Register t2 = G3;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3410
  Register t3 = O1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3411
  assert_different_registers(top, t1, t2, t3, G4, G5 /* preserve G4 and G5 */);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3412
  Label do_refill, discard_tlab;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3413
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3414
  if (CMSIncrementalMode || !Universe::heap()->supports_inline_contig_alloc()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3415
    // No allocation in the shared eden.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3416
    br(Assembler::always, false, Assembler::pt, slow_case);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3417
    delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3418
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3419
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3420
  ld_ptr(G2_thread, in_bytes(JavaThread::tlab_top_offset()), top);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3421
  ld_ptr(G2_thread, in_bytes(JavaThread::tlab_end_offset()), t1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3422
  ld_ptr(G2_thread, in_bytes(JavaThread::tlab_refill_waste_limit_offset()), t2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3423
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3424
  // calculate amount of free space
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3425
  sub(t1, top, t1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3426
  srl_ptr(t1, LogHeapWordSize, t1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3427
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3428
  // Retain tlab and allocate object in shared space if
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3429
  // the amount free in the tlab is too large to discard.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3430
  cmp(t1, t2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3431
  brx(Assembler::lessEqual, false, Assembler::pt, discard_tlab);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3432
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3433
  // increment waste limit to prevent getting stuck on this slow path
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3434
  delayed()->add(t2, ThreadLocalAllocBuffer::refill_waste_limit_increment(), t2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3435
  st_ptr(t2, G2_thread, in_bytes(JavaThread::tlab_refill_waste_limit_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3436
  if (TLABStats) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3437
    // increment number of slow_allocations
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3438
    ld(G2_thread, in_bytes(JavaThread::tlab_slow_allocations_offset()), t2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3439
    add(t2, 1, t2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3440
    stw(t2, G2_thread, in_bytes(JavaThread::tlab_slow_allocations_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3441
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3442
  br(Assembler::always, false, Assembler::pt, try_eden);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3443
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3444
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3445
  bind(discard_tlab);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3446
  if (TLABStats) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3447
    // increment number of refills
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3448
    ld(G2_thread, in_bytes(JavaThread::tlab_number_of_refills_offset()), t2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3449
    add(t2, 1, t2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3450
    stw(t2, G2_thread, in_bytes(JavaThread::tlab_number_of_refills_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3451
    // accumulate wastage
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3452
    ld(G2_thread, in_bytes(JavaThread::tlab_fast_refill_waste_offset()), t2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3453
    add(t2, t1, t2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3454
    stw(t2, G2_thread, in_bytes(JavaThread::tlab_fast_refill_waste_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3455
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3456
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3457
  // if tlab is currently allocated (top or end != null) then
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3458
  // fill [top, end + alignment_reserve) with array object
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3459
  br_null(top, false, Assembler::pn, do_refill);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3460
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3461
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3462
  set((intptr_t)markOopDesc::prototype()->copy_set_hash(0x2), t2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3463
  st_ptr(t2, top, oopDesc::mark_offset_in_bytes()); // set up the mark word
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3464
  // set klass to intArrayKlass
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3465
  sub(t1, typeArrayOopDesc::header_size(T_INT), t1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3466
  add(t1, ThreadLocalAllocBuffer::alignment_reserve(), t1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3467
  sll_ptr(t1, log2_intptr(HeapWordSize/sizeof(jint)), t1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3468
  st(t1, top, arrayOopDesc::length_offset_in_bytes());
593
803947e176bd 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents: 590
diff changeset
  3469
  set((intptr_t)Universe::intArrayKlassObj_addr(), t2);
803947e176bd 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents: 590
diff changeset
  3470
  ld_ptr(t2, 0, t2);
803947e176bd 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents: 590
diff changeset
  3471
  // store klass last.  concurrent gcs assumes klass length is valid if
803947e176bd 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents: 590
diff changeset
  3472
  // klass field is not null.
803947e176bd 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents: 590
diff changeset
  3473
  store_klass(t2, top);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3474
  verify_oop(top);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3475
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3476
  // refill the tlab with an eden allocation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3477
  bind(do_refill);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3478
  ld_ptr(G2_thread, in_bytes(JavaThread::tlab_size_offset()), t1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3479
  sll_ptr(t1, LogHeapWordSize, t1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3480
  // add object_size ??
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3481
  eden_allocate(top, t1, 0, t2, t3, slow_case);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3482
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3483
  st_ptr(top, G2_thread, in_bytes(JavaThread::tlab_start_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3484
  st_ptr(top, G2_thread, in_bytes(JavaThread::tlab_top_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3485
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3486
  // check that tlab_size (t1) is still valid
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3487
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3488
    Label ok;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3489
    ld_ptr(G2_thread, in_bytes(JavaThread::tlab_size_offset()), t2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3490
    sll_ptr(t2, LogHeapWordSize, t2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3491
    cmp(t1, t2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3492
    br(Assembler::equal, false, Assembler::pt, ok);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3493
    delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3494
    stop("assert(t1 == tlab_size)");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3495
    should_not_reach_here();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3496
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3497
    bind(ok);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3498
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3499
#endif // ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3500
  add(top, t1, top); // t1 is tlab_size
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3501
  sub(top, ThreadLocalAllocBuffer::alignment_reserve_in_bytes(), top);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3502
  st_ptr(top, G2_thread, in_bytes(JavaThread::tlab_end_offset()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3503
  verify_tlab();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3504
  br(Assembler::always, false, Assembler::pt, retry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3505
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3506
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3507
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3508
Assembler::Condition MacroAssembler::negate_condition(Assembler::Condition cond) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3509
  switch (cond) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3510
    // Note some conditions are synonyms for others
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3511
    case Assembler::never:                return Assembler::always;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3512
    case Assembler::zero:                 return Assembler::notZero;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3513
    case Assembler::lessEqual:            return Assembler::greater;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3514
    case Assembler::less:                 return Assembler::greaterEqual;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3515
    case Assembler::lessEqualUnsigned:    return Assembler::greaterUnsigned;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3516
    case Assembler::lessUnsigned:         return Assembler::greaterEqualUnsigned;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3517
    case Assembler::negative:             return Assembler::positive;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3518
    case Assembler::overflowSet:          return Assembler::overflowClear;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3519
    case Assembler::always:               return Assembler::never;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3520
    case Assembler::notZero:              return Assembler::zero;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3521
    case Assembler::greater:              return Assembler::lessEqual;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3522
    case Assembler::greaterEqual:         return Assembler::less;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3523
    case Assembler::greaterUnsigned:      return Assembler::lessEqualUnsigned;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3524
    case Assembler::greaterEqualUnsigned: return Assembler::lessUnsigned;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3525
    case Assembler::positive:             return Assembler::negative;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3526
    case Assembler::overflowClear:        return Assembler::overflowSet;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3527
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3528
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3529
  ShouldNotReachHere(); return Assembler::overflowClear;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3530
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3531
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3532
void MacroAssembler::cond_inc(Assembler::Condition cond, address counter_ptr,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3533
                              Register Rtmp1, Register Rtmp2 /*, Register Rtmp3, Register Rtmp4 */) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3534
  Condition negated_cond = negate_condition(cond);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3535
  Label L;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3536
  brx(negated_cond, false, Assembler::pt, L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3537
  delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3538
  inc_counter(counter_ptr, Rtmp1, Rtmp2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3539
  bind(L);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3540
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3541
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3542
void MacroAssembler::inc_counter(address counter_ptr, Register Rtmp1, Register Rtmp2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3543
  Address counter_addr(Rtmp1, counter_ptr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3544
  load_contents(counter_addr, Rtmp2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3545
  inc(Rtmp2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3546
  store_contents(Rtmp2, counter_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3547
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3548
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3549
SkipIfEqual::SkipIfEqual(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3550
    MacroAssembler* masm, Register temp, const bool* flag_addr,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3551
    Assembler::Condition condition) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3552
  _masm = masm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3553
  Address flag(temp, (address)flag_addr, relocInfo::none);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3554
  _masm->sethi(flag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3555
  _masm->ldub(flag, temp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3556
  _masm->tst(temp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3557
  _masm->br(condition, false, Assembler::pt, _label);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3558
  _masm->delayed()->nop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3559
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3560
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3561
SkipIfEqual::~SkipIfEqual() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3562
  _masm->bind(_label);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3563
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3564
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3565
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3566
// Writes to stack successive pages until offset reached to check for
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3567
// stack overflow + shadow pages.  This clobbers tsp and scratch.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3568
void MacroAssembler::bang_stack_size(Register Rsize, Register Rtsp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3569
                                     Register Rscratch) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3570
  // Use stack pointer in temp stack pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3571
  mov(SP, Rtsp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3572
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3573
  // Bang stack for total size given plus stack shadow page size.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3574
  // Bang one page at a time because a large size can overflow yellow and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3575
  // red zones (the bang will fail but stack overflow handling can't tell that
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3576
  // it was a stack overflow bang vs a regular segv).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3577
  int offset = os::vm_page_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3578
  Register Roffset = Rscratch;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3579
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3580
  Label loop;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3581
  bind(loop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3582
  set((-offset)+STACK_BIAS, Rscratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3583
  st(G0, Rtsp, Rscratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3584
  set(offset, Roffset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3585
  sub(Rsize, Roffset, Rsize);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3586
  cmp(Rsize, G0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3587
  br(Assembler::greater, false, Assembler::pn, loop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3588
  delayed()->sub(Rtsp, Roffset, Rtsp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3589
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3590
  // Bang down shadow pages too.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3591
  // The -1 because we already subtracted 1 page.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3592
  for (int i = 0; i< StackShadowPages-1; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3593
    set((-i*offset)+STACK_BIAS, Rscratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3594
    st(G0, Rtsp, Rscratch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3595
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3596
}
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  3597
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3598
///////////////////////////////////////////////////////////////////////////////////
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3599
#ifndef SERIALGC
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3600
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3601
static uint num_stores = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3602
static uint num_null_pre_stores = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3603
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3604
static void count_null_pre_vals(void* pre_val) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3605
  num_stores++;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3606
  if (pre_val == NULL) num_null_pre_stores++;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3607
  if ((num_stores % 1000000) == 0) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3608
    tty->print_cr(UINT32_FORMAT " stores, " UINT32_FORMAT " (%5.2f%%) with null pre-vals.",
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3609
                  num_stores, num_null_pre_stores,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3610
                  100.0*(float)num_null_pre_stores/(float)num_stores);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3611
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3612
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3613
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3614
static address satb_log_enqueue_with_frame = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3615
static u_char* satb_log_enqueue_with_frame_end = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3616
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3617
static address satb_log_enqueue_frameless = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3618
static u_char* satb_log_enqueue_frameless_end = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3619
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3620
static int EnqueueCodeSize = 128 DEBUG_ONLY( + 256); // Instructions?
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3621
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3622
// The calls to this don't work.  We'd need to do a fair amount of work to
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3623
// make it work.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3624
static void check_index(int ind) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3625
  assert(0 <= ind && ind <= 64*K && ((ind % oopSize) == 0),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3626
         "Invariants.")
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3627
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3628
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3629
static void generate_satb_log_enqueue(bool with_frame) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3630
  BufferBlob* bb = BufferBlob::create("enqueue_with_frame", EnqueueCodeSize);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3631
  CodeBuffer buf(bb->instructions_begin(), bb->instructions_size());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3632
  MacroAssembler masm(&buf);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3633
  address start = masm.pc();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3634
  Register pre_val;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3635
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3636
  Label refill, restart;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3637
  if (with_frame) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3638
    masm.save_frame(0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3639
    pre_val = I0;  // Was O0 before the save.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3640
  } else {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3641
    pre_val = O0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3642
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3643
  int satb_q_index_byte_offset =
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3644
    in_bytes(JavaThread::satb_mark_queue_offset() +
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3645
             PtrQueue::byte_offset_of_index());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3646
  int satb_q_buf_byte_offset =
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3647
    in_bytes(JavaThread::satb_mark_queue_offset() +
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3648
             PtrQueue::byte_offset_of_buf());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3649
  assert(in_bytes(PtrQueue::byte_width_of_index()) == sizeof(intptr_t) &&
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3650
         in_bytes(PtrQueue::byte_width_of_buf()) == sizeof(intptr_t),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3651
         "check sizes in assembly below");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3652
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3653
  masm.bind(restart);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3654
  masm.ld_ptr(G2_thread, satb_q_index_byte_offset, L0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3655
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3656
  masm.br_on_reg_cond(Assembler::rc_z, /*annul*/false, Assembler::pn, L0, refill);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3657
  // If the branch is taken, no harm in executing this in the delay slot.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3658
  masm.delayed()->ld_ptr(G2_thread, satb_q_buf_byte_offset, L1);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3659
  masm.sub(L0, oopSize, L0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3660
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3661
  masm.st_ptr(pre_val, L1, L0);  // [_buf + index] := I0
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3662
  if (!with_frame) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3663
    // Use return-from-leaf
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3664
    masm.retl();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3665
    masm.delayed()->st_ptr(L0, G2_thread, satb_q_index_byte_offset);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3666
  } else {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3667
    // Not delayed.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3668
    masm.st_ptr(L0, G2_thread, satb_q_index_byte_offset);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3669
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3670
  if (with_frame) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3671
    masm.ret();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3672
    masm.delayed()->restore();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3673
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3674
  masm.bind(refill);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3675
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3676
  address handle_zero =
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3677
    CAST_FROM_FN_PTR(address,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3678
                     &SATBMarkQueueSet::handle_zero_index_for_thread);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3679
  // This should be rare enough that we can afford to save all the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3680
  // scratch registers that the calling context might be using.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3681
  masm.mov(G1_scratch, L0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3682
  masm.mov(G3_scratch, L1);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3683
  masm.mov(G4, L2);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3684
  // We need the value of O0 above (for the write into the buffer), so we
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3685
  // save and restore it.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3686
  masm.mov(O0, L3);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3687
  // Since the call will overwrite O7, we save and restore that, as well.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3688
  masm.mov(O7, L4);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3689
  masm.call_VM_leaf(L5, handle_zero, G2_thread);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3690
  masm.mov(L0, G1_scratch);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3691
  masm.mov(L1, G3_scratch);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3692
  masm.mov(L2, G4);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3693
  masm.mov(L3, O0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3694
  masm.br(Assembler::always, /*annul*/false, Assembler::pt, restart);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3695
  masm.delayed()->mov(L4, O7);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3696
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3697
  if (with_frame) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3698
    satb_log_enqueue_with_frame = start;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3699
    satb_log_enqueue_with_frame_end = masm.pc();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3700
  } else {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3701
    satb_log_enqueue_frameless = start;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3702
    satb_log_enqueue_frameless_end = masm.pc();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3703
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3704
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3705
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3706
static inline void generate_satb_log_enqueue_if_necessary(bool with_frame) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3707
  if (with_frame) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3708
    if (satb_log_enqueue_with_frame == 0) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3709
      generate_satb_log_enqueue(with_frame);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3710
      assert(satb_log_enqueue_with_frame != 0, "postcondition.");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3711
      if (G1SATBPrintStubs) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3712
        tty->print_cr("Generated with-frame satb enqueue:");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3713
        Disassembler::decode((u_char*)satb_log_enqueue_with_frame,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3714
                             satb_log_enqueue_with_frame_end,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3715
                             tty);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3716
      }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3717
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3718
  } else {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3719
    if (satb_log_enqueue_frameless == 0) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3720
      generate_satb_log_enqueue(with_frame);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3721
      assert(satb_log_enqueue_frameless != 0, "postcondition.");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3722
      if (G1SATBPrintStubs) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3723
        tty->print_cr("Generated frameless satb enqueue:");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3724
        Disassembler::decode((u_char*)satb_log_enqueue_frameless,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3725
                             satb_log_enqueue_frameless_end,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3726
                             tty);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3727
      }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3728
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3729
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3730
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3731
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3732
void MacroAssembler::g1_write_barrier_pre(Register obj, Register index, int offset, Register tmp, bool preserve_o_regs) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3733
  assert(offset == 0 || index == noreg, "choose one");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3734
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3735
  if (G1DisablePreBarrier) return;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3736
  // satb_log_barrier(tmp, obj, offset, preserve_o_regs);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3737
  Label filtered;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3738
  // satb_log_barrier_work0(tmp, filtered);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3739
  if (in_bytes(PtrQueue::byte_width_of_active()) == 4) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3740
    ld(G2,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3741
       in_bytes(JavaThread::satb_mark_queue_offset() +
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3742
                PtrQueue::byte_offset_of_active()),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3743
       tmp);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3744
  } else {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3745
    guarantee(in_bytes(PtrQueue::byte_width_of_active()) == 1,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3746
              "Assumption");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3747
    ldsb(G2,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3748
         in_bytes(JavaThread::satb_mark_queue_offset() +
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3749
                  PtrQueue::byte_offset_of_active()),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3750
         tmp);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3751
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3752
  // Check on whether to annul.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3753
  br_on_reg_cond(rc_z, /*annul*/false, Assembler::pt, tmp, filtered);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3754
  delayed() -> nop();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3755
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3756
  // satb_log_barrier_work1(tmp, offset);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3757
  if (index == noreg) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3758
    if (Assembler::is_simm13(offset)) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3759
      ld_ptr(obj, offset, tmp);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3760
    } else {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3761
      set(offset, tmp);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3762
      ld_ptr(obj, tmp, tmp);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3763
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3764
  } else {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3765
    ld_ptr(obj, index, tmp);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3766
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3767
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3768
  // satb_log_barrier_work2(obj, tmp, offset);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3769
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3770
  // satb_log_barrier_work3(tmp, filtered, preserve_o_regs);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3771
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3772
  const Register pre_val = tmp;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3773
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3774
  if (G1SATBBarrierPrintNullPreVals) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3775
    save_frame(0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3776
    mov(pre_val, O0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3777
    // Save G-regs that target may use.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3778
    mov(G1, L1);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3779
    mov(G2, L2);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3780
    mov(G3, L3);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3781
    mov(G4, L4);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3782
    mov(G5, L5);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3783
    call(CAST_FROM_FN_PTR(address, &count_null_pre_vals));
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3784
    delayed()->nop();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3785
    // Restore G-regs that target may have used.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3786
    mov(L1, G1);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3787
    mov(L2, G2);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3788
    mov(L3, G3);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3789
    mov(L4, G4);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3790
    mov(L5, G5);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3791
    restore(G0, G0, G0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3792
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3793
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3794
  // Check on whether to annul.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3795
  br_on_reg_cond(rc_z, /*annul*/false, Assembler::pt, pre_val, filtered);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3796
  delayed() -> nop();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3797
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3798
  // OK, it's not filtered, so we'll need to call enqueue.  In the normal
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3799
  // case, pre_val will be a scratch G-reg, but there's some cases in which
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3800
  // it's an O-reg.  In the first case, do a normal call.  In the latter,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3801
  // do a save here and call the frameless version.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3802
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3803
  guarantee(pre_val->is_global() || pre_val->is_out(),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3804
            "Or we need to think harder.");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3805
  if (pre_val->is_global() && !preserve_o_regs) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3806
    generate_satb_log_enqueue_if_necessary(true); // with frame.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3807
    call(satb_log_enqueue_with_frame);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3808
    delayed()->mov(pre_val, O0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3809
  } else {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3810
    generate_satb_log_enqueue_if_necessary(false); // with frameless.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3811
    save_frame(0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3812
    call(satb_log_enqueue_frameless);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3813
    delayed()->mov(pre_val->after_save(), O0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3814
    restore();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3815
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3816
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3817
  bind(filtered);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3818
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3819
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3820
static jint num_ct_writes = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3821
static jint num_ct_writes_filtered_in_hr = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3822
static jint num_ct_writes_filtered_null = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3823
static jint num_ct_writes_filtered_pop = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3824
static G1CollectedHeap* g1 = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3825
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3826
static Thread* count_ct_writes(void* filter_val, void* new_val) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3827
  Atomic::inc(&num_ct_writes);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3828
  if (filter_val == NULL) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3829
    Atomic::inc(&num_ct_writes_filtered_in_hr);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3830
  } else if (new_val == NULL) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3831
    Atomic::inc(&num_ct_writes_filtered_null);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3832
  } else {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3833
    if (g1 == NULL) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3834
      g1 = G1CollectedHeap::heap();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3835
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3836
    if ((HeapWord*)new_val < g1->popular_object_boundary()) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3837
      Atomic::inc(&num_ct_writes_filtered_pop);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3838
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3839
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3840
  if ((num_ct_writes % 1000000) == 0) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3841
    jint num_ct_writes_filtered =
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3842
      num_ct_writes_filtered_in_hr +
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3843
      num_ct_writes_filtered_null +
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3844
      num_ct_writes_filtered_pop;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3845
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3846
    tty->print_cr("%d potential CT writes: %5.2f%% filtered\n"
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3847
                  "   (%5.2f%% intra-HR, %5.2f%% null, %5.2f%% popular).",
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3848
                  num_ct_writes,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3849
                  100.0*(float)num_ct_writes_filtered/(float)num_ct_writes,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3850
                  100.0*(float)num_ct_writes_filtered_in_hr/
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3851
                  (float)num_ct_writes,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3852
                  100.0*(float)num_ct_writes_filtered_null/
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3853
                  (float)num_ct_writes,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3854
                  100.0*(float)num_ct_writes_filtered_pop/
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3855
                  (float)num_ct_writes);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3856
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3857
  return Thread::current();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3858
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3859
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3860
static address dirty_card_log_enqueue = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3861
static u_char* dirty_card_log_enqueue_end = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3862
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3863
// This gets to assume that o0 contains the object address.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3864
static void generate_dirty_card_log_enqueue(jbyte* byte_map_base) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3865
  BufferBlob* bb = BufferBlob::create("dirty_card_enqueue", EnqueueCodeSize*2);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3866
  CodeBuffer buf(bb->instructions_begin(), bb->instructions_size());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3867
  MacroAssembler masm(&buf);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3868
  address start = masm.pc();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3869
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3870
  Label not_already_dirty, restart, refill;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3871
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3872
#ifdef _LP64
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3873
  masm.srlx(O0, CardTableModRefBS::card_shift, O0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3874
#else
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3875
  masm.srl(O0, CardTableModRefBS::card_shift, O0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3876
#endif
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3877
  Address rs(O1, (address)byte_map_base);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3878
  masm.load_address(rs); // O1 := <card table base>
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3879
  masm.ldub(O0, O1, O2); // O2 := [O0 + O1]
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3880
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3881
  masm.br_on_reg_cond(Assembler::rc_nz, /*annul*/false, Assembler::pt,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3882
                      O2, not_already_dirty);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3883
  // Get O1 + O2 into a reg by itself -- useful in the take-the-branch
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3884
  // case, harmless if not.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3885
  masm.delayed()->add(O0, O1, O3);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3886
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3887
  // We didn't take the branch, so we're already dirty: return.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3888
  // Use return-from-leaf
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3889
  masm.retl();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3890
  masm.delayed()->nop();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3891
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3892
  // Not dirty.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3893
  masm.bind(not_already_dirty);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3894
  // First, dirty it.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3895
  masm.stb(G0, O3, G0);  // [cardPtr] := 0  (i.e., dirty).
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3896
  int dirty_card_q_index_byte_offset =
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3897
    in_bytes(JavaThread::dirty_card_queue_offset() +
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3898
             PtrQueue::byte_offset_of_index());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3899
  int dirty_card_q_buf_byte_offset =
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3900
    in_bytes(JavaThread::dirty_card_queue_offset() +
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3901
             PtrQueue::byte_offset_of_buf());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3902
  masm.bind(restart);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3903
  masm.ld_ptr(G2_thread, dirty_card_q_index_byte_offset, L0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3904
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3905
  masm.br_on_reg_cond(Assembler::rc_z, /*annul*/false, Assembler::pn,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3906
                      L0, refill);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3907
  // If the branch is taken, no harm in executing this in the delay slot.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3908
  masm.delayed()->ld_ptr(G2_thread, dirty_card_q_buf_byte_offset, L1);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3909
  masm.sub(L0, oopSize, L0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3910
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3911
  masm.st_ptr(O3, L1, L0);  // [_buf + index] := I0
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3912
  // Use return-from-leaf
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3913
  masm.retl();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3914
  masm.delayed()->st_ptr(L0, G2_thread, dirty_card_q_index_byte_offset);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3915
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3916
  masm.bind(refill);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3917
  address handle_zero =
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3918
    CAST_FROM_FN_PTR(address,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3919
                     &DirtyCardQueueSet::handle_zero_index_for_thread);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3920
  // This should be rare enough that we can afford to save all the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3921
  // scratch registers that the calling context might be using.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3922
  masm.mov(G1_scratch, L3);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3923
  masm.mov(G3_scratch, L5);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3924
  // We need the value of O3 above (for the write into the buffer), so we
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3925
  // save and restore it.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3926
  masm.mov(O3, L6);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3927
  // Since the call will overwrite O7, we save and restore that, as well.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3928
  masm.mov(O7, L4);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3929
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3930
  masm.call_VM_leaf(L7_thread_cache, handle_zero, G2_thread);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3931
  masm.mov(L3, G1_scratch);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3932
  masm.mov(L5, G3_scratch);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3933
  masm.mov(L6, O3);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3934
  masm.br(Assembler::always, /*annul*/false, Assembler::pt, restart);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3935
  masm.delayed()->mov(L4, O7);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3936
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3937
  dirty_card_log_enqueue = start;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3938
  dirty_card_log_enqueue_end = masm.pc();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3939
  // XXX Should have a guarantee here about not going off the end!
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3940
  // Does it already do so?  Do an experiment...
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3941
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3942
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3943
static inline void
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3944
generate_dirty_card_log_enqueue_if_necessary(jbyte* byte_map_base) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3945
  if (dirty_card_log_enqueue == 0) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3946
    generate_dirty_card_log_enqueue(byte_map_base);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3947
    assert(dirty_card_log_enqueue != 0, "postcondition.");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3948
    if (G1SATBPrintStubs) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3949
      tty->print_cr("Generated dirty_card enqueue:");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3950
      Disassembler::decode((u_char*)dirty_card_log_enqueue,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3951
                           dirty_card_log_enqueue_end,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3952
                           tty);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3953
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3954
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3955
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3956
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3957
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3958
void MacroAssembler::g1_write_barrier_post(Register store_addr, Register new_val, Register tmp) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3959
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3960
  Label filtered;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3961
  MacroAssembler* post_filter_masm = this;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3962
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3963
  if (new_val == G0) return;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3964
  if (G1DisablePostBarrier) return;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3965
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3966
  G1SATBCardTableModRefBS* bs = (G1SATBCardTableModRefBS*) Universe::heap()->barrier_set();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3967
  assert(bs->kind() == BarrierSet::G1SATBCT ||
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3968
         bs->kind() == BarrierSet::G1SATBCTLogging, "wrong barrier");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3969
  if (G1RSBarrierRegionFilter) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3970
    xor3(store_addr, new_val, tmp);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3971
#ifdef _LP64
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3972
    srlx(tmp, HeapRegion::LogOfHRGrainBytes, tmp);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3973
#else
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3974
    srl(tmp, HeapRegion::LogOfHRGrainBytes, tmp);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3975
#endif
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3976
    if (G1PrintCTFilterStats) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3977
      guarantee(tmp->is_global(), "Or stats won't work...");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3978
      // This is a sleazy hack: I'm temporarily hijacking G2, which I
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3979
      // promise to restore.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3980
      mov(new_val, G2);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3981
      save_frame(0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3982
      mov(tmp, O0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3983
      mov(G2, O1);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3984
      // Save G-regs that target may use.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3985
      mov(G1, L1);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3986
      mov(G2, L2);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3987
      mov(G3, L3);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3988
      mov(G4, L4);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3989
      mov(G5, L5);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3990
      call(CAST_FROM_FN_PTR(address, &count_ct_writes));
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3991
      delayed()->nop();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3992
      mov(O0, G2);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3993
      // Restore G-regs that target may have used.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3994
      mov(L1, G1);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3995
      mov(L3, G3);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3996
      mov(L4, G4);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3997
      mov(L5, G5);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3998
      restore(G0, G0, G0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  3999
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4000
    // XXX Should I predict this taken or not?  Does it mattern?
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4001
    br_on_reg_cond(rc_z, /*annul*/false, Assembler::pt, tmp, filtered);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4002
    delayed()->nop();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4003
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4004
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4005
  // Now we decide how to generate the card table write.  If we're
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4006
  // enqueueing, we call out to a generated function.  Otherwise, we do it
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4007
  // inline here.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4008
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4009
  if (G1RSBarrierUseQueue) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4010
    // If the "store_addr" register is an "in" or "local" register, move it to
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4011
    // a scratch reg so we can pass it as an argument.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4012
    bool use_scr = !(store_addr->is_global() || store_addr->is_out());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4013
    // Pick a scratch register different from "tmp".
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4014
    Register scr = (tmp == G1_scratch ? G3_scratch : G1_scratch);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4015
    // Make sure we use up the delay slot!
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4016
    if (use_scr) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4017
      post_filter_masm->mov(store_addr, scr);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4018
    } else {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4019
      post_filter_masm->nop();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4020
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4021
    generate_dirty_card_log_enqueue_if_necessary(bs->byte_map_base);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4022
    save_frame(0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4023
    call(dirty_card_log_enqueue);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4024
    if (use_scr) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4025
      delayed()->mov(scr, O0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4026
    } else {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4027
      delayed()->mov(store_addr->after_save(), O0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4028
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4029
    restore();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4030
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4031
  } else {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4032
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4033
#ifdef _LP64
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4034
    post_filter_masm->srlx(store_addr, CardTableModRefBS::card_shift, store_addr);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4035
#else
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4036
    post_filter_masm->srl(store_addr, CardTableModRefBS::card_shift, store_addr);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4037
#endif
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4038
    assert( tmp != store_addr, "need separate temp reg");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4039
    Address rs(tmp, (address)bs->byte_map_base);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4040
    load_address(rs);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4041
    stb(G0, rs.base(), store_addr);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4042
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4043
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4044
  bind(filtered);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4045
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4046
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4047
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4048
#endif  // SERIALGC
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4049
///////////////////////////////////////////////////////////////////////////////////
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4050
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4051
void MacroAssembler::card_write_barrier_post(Register store_addr, Register new_val, Register tmp) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4052
  // If we're writing constant NULL, we can skip the write barrier.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4053
  if (new_val == G0) return;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4054
  CardTableModRefBS* bs = (CardTableModRefBS*) Universe::heap()->barrier_set();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4055
  assert(bs->kind() == BarrierSet::CardTableModRef ||
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4056
         bs->kind() == BarrierSet::CardTableExtension, "wrong barrier");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4057
  card_table_write(bs->byte_map_base, tmp, store_addr);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4058
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  4059
590
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 371
diff changeset
  4060
void MacroAssembler::load_klass(Register src_oop, Register klass) {
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4061
  // The number of bytes in this code is used by
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4062
  // MachCallDynamicJavaNode::ret_addr_offset()
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4063
  // if this changes, change that.
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4064
  if (UseCompressedOops) {
590
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 371
diff changeset
  4065
    lduw(src_oop, oopDesc::klass_offset_in_bytes(), klass);
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 371
diff changeset
  4066
    decode_heap_oop_not_null(klass);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4067
  } else {
590
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 371
diff changeset
  4068
    ld_ptr(src_oop, oopDesc::klass_offset_in_bytes(), klass);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4069
  }
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4070
}
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4071
590
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 371
diff changeset
  4072
void MacroAssembler::store_klass(Register klass, Register dst_oop) {
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4073
  if (UseCompressedOops) {
590
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 371
diff changeset
  4074
    assert(dst_oop != klass, "not enough registers");
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 371
diff changeset
  4075
    encode_heap_oop_not_null(klass);
593
803947e176bd 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents: 590
diff changeset
  4076
    st(klass, dst_oop, 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
  4077
  } else {
590
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 371
diff changeset
  4078
    st_ptr(klass, dst_oop, 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
  4079
  }
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4080
}
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4081
593
803947e176bd 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents: 590
diff changeset
  4082
void MacroAssembler::store_klass_gap(Register s, Register d) {
803947e176bd 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents: 590
diff changeset
  4083
  if (UseCompressedOops) {
803947e176bd 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents: 590
diff changeset
  4084
    assert(s != d, "not enough registers");
803947e176bd 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents: 590
diff changeset
  4085
    st(s, d, oopDesc::klass_gap_offset_in_bytes());
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4086
  }
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4087
}
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4088
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4089
void MacroAssembler::load_heap_oop(const Address& s, Register d, int offset) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4090
  if (UseCompressedOops) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4091
    lduw(s, d, offset);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4092
    decode_heap_oop(d);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4093
  } else {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4094
    ld_ptr(s, d, offset);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4095
  }
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4096
}
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4097
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4098
void MacroAssembler::load_heap_oop(Register s1, Register s2, Register d) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4099
   if (UseCompressedOops) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4100
    lduw(s1, s2, d);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4101
    decode_heap_oop(d, d);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4102
  } else {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4103
    ld_ptr(s1, s2, d);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4104
  }
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4105
}
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4106
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4107
void MacroAssembler::load_heap_oop(Register s1, int simm13a, Register d) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4108
   if (UseCompressedOops) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4109
    lduw(s1, simm13a, d);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4110
    decode_heap_oop(d, d);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4111
  } else {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4112
    ld_ptr(s1, simm13a, d);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4113
  }
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4114
}
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4115
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4116
void MacroAssembler::store_heap_oop(Register d, Register s1, Register s2) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4117
  if (UseCompressedOops) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4118
    assert(s1 != d && s2 != d, "not enough registers");
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4119
    encode_heap_oop(d);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4120
    st(d, s1, s2);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4121
  } else {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4122
    st_ptr(d, s1, s2);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4123
  }
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4124
}
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4125
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4126
void MacroAssembler::store_heap_oop(Register d, Register s1, int simm13a) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4127
  if (UseCompressedOops) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4128
    assert(s1 != d, "not enough registers");
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4129
    encode_heap_oop(d);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4130
    st(d, s1, simm13a);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4131
  } else {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4132
    st_ptr(d, s1, simm13a);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4133
  }
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4134
}
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4135
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4136
void MacroAssembler::store_heap_oop(Register d, const Address& a, int offset) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4137
  if (UseCompressedOops) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4138
    assert(a.base() != d, "not enough registers");
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4139
    encode_heap_oop(d);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4140
    st(d, a, offset);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4141
  } else {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4142
    st_ptr(d, a, offset);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4143
  }
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4144
}
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4145
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4146
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4147
void MacroAssembler::encode_heap_oop(Register src, Register dst) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4148
  assert (UseCompressedOops, "must be compressed");
604
3967d752d79b 6695819: verify_oopx rax: broken oop in decode_heap_oop
coleenp
parents: 371
diff changeset
  4149
  verify_oop(src);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4150
  Label done;
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4151
  if (src == dst) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4152
    // optimize for frequent case src == dst
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4153
    bpr(rc_nz, true, Assembler::pt, src, done);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4154
    delayed() -> sub(src, G6_heapbase, dst); // annuled if not taken
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4155
    bind(done);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4156
    srlx(src, LogMinObjAlignmentInBytes, dst);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4157
  } else {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4158
    bpr(rc_z, false, Assembler::pn, src, done);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4159
    delayed() -> mov(G0, dst);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4160
    // could be moved before branch, and annulate delay,
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4161
    // but may add some unneeded work decoding null
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4162
    sub(src, G6_heapbase, dst);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4163
    srlx(dst, LogMinObjAlignmentInBytes, dst);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4164
    bind(done);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4165
  }
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4166
}
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4167
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4168
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4169
void MacroAssembler::encode_heap_oop_not_null(Register r) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4170
  assert (UseCompressedOops, "must be compressed");
604
3967d752d79b 6695819: verify_oopx rax: broken oop in decode_heap_oop
coleenp
parents: 371
diff changeset
  4171
  verify_oop(r);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4172
  sub(r, G6_heapbase, r);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4173
  srlx(r, LogMinObjAlignmentInBytes, r);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4174
}
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4175
371
1aacedc9db7c 6689060: Escape Analysis does not work with Compressed Oops
kvn
parents: 360
diff changeset
  4176
void MacroAssembler::encode_heap_oop_not_null(Register src, Register dst) {
1aacedc9db7c 6689060: Escape Analysis does not work with Compressed Oops
kvn
parents: 360
diff changeset
  4177
  assert (UseCompressedOops, "must be compressed");
604
3967d752d79b 6695819: verify_oopx rax: broken oop in decode_heap_oop
coleenp
parents: 371
diff changeset
  4178
  verify_oop(src);
371
1aacedc9db7c 6689060: Escape Analysis does not work with Compressed Oops
kvn
parents: 360
diff changeset
  4179
  sub(src, G6_heapbase, dst);
1aacedc9db7c 6689060: Escape Analysis does not work with Compressed Oops
kvn
parents: 360
diff changeset
  4180
  srlx(dst, LogMinObjAlignmentInBytes, dst);
1aacedc9db7c 6689060: Escape Analysis does not work with Compressed Oops
kvn
parents: 360
diff changeset
  4181
}
1aacedc9db7c 6689060: Escape Analysis does not work with Compressed Oops
kvn
parents: 360
diff changeset
  4182
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4183
// Same algorithm as oops.inline.hpp decode_heap_oop.
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4184
void  MacroAssembler::decode_heap_oop(Register src, Register dst) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4185
  assert (UseCompressedOops, "must be compressed");
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4186
  Label done;
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4187
  sllx(src, LogMinObjAlignmentInBytes, dst);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4188
  bpr(rc_nz, true, Assembler::pt, dst, done);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4189
  delayed() -> add(dst, G6_heapbase, dst); // annuled if not taken
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4190
  bind(done);
604
3967d752d79b 6695819: verify_oopx rax: broken oop in decode_heap_oop
coleenp
parents: 371
diff changeset
  4191
  verify_oop(dst);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4192
}
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4193
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4194
void  MacroAssembler::decode_heap_oop_not_null(Register r) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4195
  // Do not add assert code to this unless you change vtableStubs_sparc.cpp
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4196
  // pd_code_size_limit.
604
3967d752d79b 6695819: verify_oopx rax: broken oop in decode_heap_oop
coleenp
parents: 371
diff changeset
  4197
  // Also do not verify_oop as this is called by verify_oop.
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4198
  assert (UseCompressedOops, "must be compressed");
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4199
  sllx(r, LogMinObjAlignmentInBytes, r);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4200
  add(r, G6_heapbase, r);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4201
}
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4202
371
1aacedc9db7c 6689060: Escape Analysis does not work with Compressed Oops
kvn
parents: 360
diff changeset
  4203
void  MacroAssembler::decode_heap_oop_not_null(Register src, Register dst) {
1aacedc9db7c 6689060: Escape Analysis does not work with Compressed Oops
kvn
parents: 360
diff changeset
  4204
  // Do not add assert code to this unless you change vtableStubs_sparc.cpp
1aacedc9db7c 6689060: Escape Analysis does not work with Compressed Oops
kvn
parents: 360
diff changeset
  4205
  // pd_code_size_limit.
604
3967d752d79b 6695819: verify_oopx rax: broken oop in decode_heap_oop
coleenp
parents: 371
diff changeset
  4206
  // Also do not verify_oop as this is called by verify_oop.
371
1aacedc9db7c 6689060: Escape Analysis does not work with Compressed Oops
kvn
parents: 360
diff changeset
  4207
  assert (UseCompressedOops, "must be compressed");
1aacedc9db7c 6689060: Escape Analysis does not work with Compressed Oops
kvn
parents: 360
diff changeset
  4208
  sllx(src, LogMinObjAlignmentInBytes, dst);
1aacedc9db7c 6689060: Escape Analysis does not work with Compressed Oops
kvn
parents: 360
diff changeset
  4209
  add(dst, G6_heapbase, dst);
1aacedc9db7c 6689060: Escape Analysis does not work with Compressed Oops
kvn
parents: 360
diff changeset
  4210
}
1aacedc9db7c 6689060: Escape Analysis does not work with Compressed Oops
kvn
parents: 360
diff changeset
  4211
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4212
void MacroAssembler::reinit_heapbase() {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4213
  if (UseCompressedOops) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4214
    // call indirectly to solve generation ordering problem
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4215
    Address base(G6_heapbase, (address)Universe::heap_base_addr());
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4216
    load_ptr_contents(base, G6_heapbase);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4217
  }
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  4218
}