hotspot/src/cpu/sparc/vm/macroAssembler_sparc.hpp
author hseigel
Thu, 15 Aug 2013 20:04:10 -0400
changeset 19319 0ad35be0733a
parent 18104 590c10f73634
child 25714 87fa6860b5ae
permissions -rw-r--r--
8003424: Enable Class Data Sharing for CompressedOops 8016729: ObjectAlignmentInBytes=16 now forces the use of heap based compressed oops 8005933: The -Xshare:auto option is ignored for -server Summary: Move klass metaspace above the heap and support CDS with compressed klass ptrs. Reviewed-by: coleenp, kvn, mgerdin, tschatzl, stefank
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
14631
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
     1
/*
18104
590c10f73634 8002160: Compilation issue with adlc using latest SunStudio compilers
drchase
parents: 18097
diff changeset
     2
 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
14631
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
     4
 *
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
     7
 * published by the Free Software Foundation.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
     8
 *
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    13
 * accompanied this code).
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    14
 *
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    18
 *
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    21
 * questions.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    22
 *
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    23
 */
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    24
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    25
#ifndef CPU_SPARC_VM_MACROASSEMBLER_SPARC_HPP
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    26
#define CPU_SPARC_VM_MACROASSEMBLER_SPARC_HPP
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    27
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    28
#include "asm/assembler.hpp"
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14827
diff changeset
    29
#include "utilities/macros.hpp"
14631
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    30
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    31
// <sys/trap.h> promises that the system will not use traps 16-31
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    32
#define ST_RESERVED_FOR_USER_0 0x10
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    33
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    34
class BiasedLockingCounters;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    35
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    36
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    37
// Register aliases for parts of the system:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    38
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    39
// 64 bit values can be kept in g1-g5, o1-o5 and o7 and all 64 bits are safe
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    40
// across context switches in V8+ ABI.  Of course, there are no 64 bit regs
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    41
// in V8 ABI. All 64 bits are preserved in V9 ABI for all registers.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    42
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    43
// g2-g4 are scratch registers called "application globals".  Their
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    44
// meaning is reserved to the "compilation system"--which means us!
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    45
// They are are not supposed to be touched by ordinary C code, although
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    46
// highly-optimized C code might steal them for temps.  They are safe
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    47
// across thread switches, and the ABI requires that they be safe
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    48
// across function calls.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    49
//
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    50
// g1 and g3 are touched by more modules.  V8 allows g1 to be clobbered
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    51
// across func calls, and V8+ also allows g5 to be clobbered across
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    52
// func calls.  Also, g1 and g5 can get touched while doing shared
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    53
// library loading.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    54
//
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    55
// We must not touch g7 (it is the thread-self register) and g6 is
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    56
// reserved for certain tools.  g0, of course, is always zero.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    57
//
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    58
// (Sources:  SunSoft Compilers Group, thread library engineers.)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    59
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    60
// %%%% The interpreter should be revisited to reduce global scratch regs.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    61
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    62
// This global always holds the current JavaThread pointer:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    63
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    64
REGISTER_DECLARATION(Register, G2_thread , G2);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    65
REGISTER_DECLARATION(Register, G6_heapbase , G6);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    66
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    67
// The following globals are part of the Java calling convention:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    68
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    69
REGISTER_DECLARATION(Register, G5_method             , G5);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    70
REGISTER_DECLARATION(Register, G5_megamorphic_method , G5_method);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    71
REGISTER_DECLARATION(Register, G5_inline_cache_reg   , G5_method);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    72
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    73
// The following globals are used for the new C1 & interpreter calling convention:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    74
REGISTER_DECLARATION(Register, Gargs        , G4); // pointing to the last argument
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    75
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    76
// This local is used to preserve G2_thread in the interpreter and in stubs:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    77
REGISTER_DECLARATION(Register, L7_thread_cache , L7);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    78
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    79
// These globals are used as scratch registers in the interpreter:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    80
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    81
REGISTER_DECLARATION(Register, Gframe_size   , G1); // SAME REG as G1_scratch
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    82
REGISTER_DECLARATION(Register, G1_scratch    , G1); // also SAME
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    83
REGISTER_DECLARATION(Register, G3_scratch    , G3);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    84
REGISTER_DECLARATION(Register, G4_scratch    , G4);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    85
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    86
// These globals are used as short-lived scratch registers in the compiler:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    87
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    88
REGISTER_DECLARATION(Register, Gtemp  , G5);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    89
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    90
// JSR 292 fixed register usages:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    91
REGISTER_DECLARATION(Register, G5_method_type        , G5);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    92
REGISTER_DECLARATION(Register, G3_method_handle      , G3);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    93
REGISTER_DECLARATION(Register, L7_mh_SP_save         , L7);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    94
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    95
// The compiler requires that G5_megamorphic_method is G5_inline_cache_klass,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    96
// because a single patchable "set" instruction (NativeMovConstReg,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    97
// or NativeMovConstPatching for compiler1) instruction
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    98
// serves to set up either quantity, depending on whether the compiled
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
    99
// call site is an inline cache or is megamorphic.  See the function
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   100
// CompiledIC::set_to_megamorphic.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   101
//
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   102
// If a inline cache targets an interpreted method, then the
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   103
// G5 register will be used twice during the call.  First,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   104
// the call site will be patched to load a compiledICHolder
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   105
// into G5. (This is an ordered pair of ic_klass, method.)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   106
// The c2i adapter will first check the ic_klass, then load
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   107
// G5_method with the method part of the pair just before
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   108
// jumping into the interpreter.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   109
//
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   110
// Note that G5_method is only the method-self for the interpreter,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   111
// and is logically unrelated to G5_megamorphic_method.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   112
//
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   113
// Invariants on G2_thread (the JavaThread pointer):
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   114
//  - it should not be used for any other purpose anywhere
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   115
//  - it must be re-initialized by StubRoutines::call_stub()
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   116
//  - it must be preserved around every use of call_VM
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   117
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   118
// We can consider using g2/g3/g4 to cache more values than the
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   119
// JavaThread, such as the card-marking base or perhaps pointers into
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   120
// Eden.  It's something of a waste to use them as scratch temporaries,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   121
// since they are not supposed to be volatile.  (Of course, if we find
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   122
// that Java doesn't benefit from application globals, then we can just
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   123
// use them as ordinary temporaries.)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   124
//
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   125
// Since g1 and g5 (and/or g6) are the volatile (caller-save) registers,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   126
// it makes sense to use them routinely for procedure linkage,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   127
// whenever the On registers are not applicable.  Examples:  G5_method,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   128
// G5_inline_cache_klass, and a double handful of miscellaneous compiler
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   129
// stubs.  This means that compiler stubs, etc., should be kept to a
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   130
// maximum of two or three G-register arguments.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   131
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   132
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   133
// stub frames
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   134
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   135
REGISTER_DECLARATION(Register, Lentry_args      , L0); // pointer to args passed to callee (interpreter) not stub itself
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   136
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   137
// Interpreter frames
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   138
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   139
#ifdef CC_INTERP
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   140
REGISTER_DECLARATION(Register, Lstate           , L0); // interpreter state object pointer
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   141
REGISTER_DECLARATION(Register, L1_scratch       , L1); // scratch
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   142
REGISTER_DECLARATION(Register, Lmirror          , L1); // mirror (for native methods only)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   143
REGISTER_DECLARATION(Register, L2_scratch       , L2);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   144
REGISTER_DECLARATION(Register, L3_scratch       , L3);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   145
REGISTER_DECLARATION(Register, L4_scratch       , L4);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   146
REGISTER_DECLARATION(Register, Lscratch         , L5); // C1 uses
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   147
REGISTER_DECLARATION(Register, Lscratch2        , L6); // C1 uses
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   148
REGISTER_DECLARATION(Register, L7_scratch       , L7); // constant pool cache
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   149
REGISTER_DECLARATION(Register, O5_savedSP       , O5);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   150
REGISTER_DECLARATION(Register, I5_savedSP       , I5); // Saved SP before bumping for locals.  This is simply
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   151
                                                       // a copy SP, so in 64-bit it's a biased value.  The bias
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   152
                                                       // is added and removed as needed in the frame code.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   153
// Interface to signature handler
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   154
REGISTER_DECLARATION(Register, Llocals          , L7); // pointer to locals for signature handler
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   155
REGISTER_DECLARATION(Register, Lmethod          , L6); // Method* when calling signature handler
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   156
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   157
#else
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   158
REGISTER_DECLARATION(Register, Lesp             , L0); // expression stack pointer
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   159
REGISTER_DECLARATION(Register, Lbcp             , L1); // pointer to next bytecode
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   160
REGISTER_DECLARATION(Register, Lmethod          , L2);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   161
REGISTER_DECLARATION(Register, Llocals          , L3);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   162
REGISTER_DECLARATION(Register, Largs            , L3); // pointer to locals for signature handler
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   163
                                                       // must match Llocals in asm interpreter
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   164
REGISTER_DECLARATION(Register, Lmonitors        , L4);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   165
REGISTER_DECLARATION(Register, Lbyte_code       , L5);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   166
// When calling out from the interpreter we record SP so that we can remove any extra stack
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   167
// space allocated during adapter transitions. This register is only live from the point
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   168
// of the call until we return.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   169
REGISTER_DECLARATION(Register, Llast_SP         , L5);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   170
REGISTER_DECLARATION(Register, Lscratch         , L5);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   171
REGISTER_DECLARATION(Register, Lscratch2        , L6);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   172
REGISTER_DECLARATION(Register, LcpoolCache      , L6); // constant pool cache
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   173
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   174
REGISTER_DECLARATION(Register, O5_savedSP       , O5);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   175
REGISTER_DECLARATION(Register, I5_savedSP       , I5); // Saved SP before bumping for locals.  This is simply
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   176
                                                       // a copy SP, so in 64-bit it's a biased value.  The bias
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   177
                                                       // is added and removed as needed in the frame code.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   178
REGISTER_DECLARATION(Register, IdispatchTables  , I4); // Base address of the bytecode dispatch tables
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   179
REGISTER_DECLARATION(Register, IdispatchAddress , I3); // Register which saves the dispatch address for each bytecode
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   180
REGISTER_DECLARATION(Register, ImethodDataPtr   , I2); // Pointer to the current method data
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   181
#endif /* CC_INTERP */
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   182
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   183
// NOTE: Lscratch2 and LcpoolCache point to the same registers in
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   184
//       the interpreter code. If Lscratch2 needs to be used for some
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   185
//       purpose than LcpoolCache should be restore after that for
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   186
//       the interpreter to work right
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   187
// (These assignments must be compatible with L7_thread_cache; see above.)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   188
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   189
// Since Lbcp points into the middle of the method object,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   190
// it is temporarily converted into a "bcx" during GC.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   191
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   192
// Exception processing
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   193
// These registers are passed into exception handlers.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   194
// All exception handlers require the exception object being thrown.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   195
// In addition, an nmethod's exception handler must be passed
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   196
// the address of the call site within the nmethod, to allow
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   197
// proper selection of the applicable catch block.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   198
// (Interpreter frames use their own bcp() for this purpose.)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   199
//
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   200
// The Oissuing_pc value is not always needed.  When jumping to a
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   201
// handler that is known to be interpreted, the Oissuing_pc value can be
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   202
// omitted.  An actual catch block in compiled code receives (from its
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   203
// nmethod's exception handler) the thrown exception in the Oexception,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   204
// but it doesn't need the Oissuing_pc.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   205
//
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   206
// If an exception handler (either interpreted or compiled)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   207
// discovers there is no applicable catch block, it updates
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   208
// the Oissuing_pc to the continuation PC of its own caller,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   209
// pops back to that caller's stack frame, and executes that
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   210
// caller's exception handler.  Obviously, this process will
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   211
// iterate until the control stack is popped back to a method
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   212
// containing an applicable catch block.  A key invariant is
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   213
// that the Oissuing_pc value is always a value local to
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   214
// the method whose exception handler is currently executing.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   215
//
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   216
// Note:  The issuing PC value is __not__ a raw return address (I7 value).
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   217
// It is a "return pc", the address __following__ the call.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   218
// Raw return addresses are converted to issuing PCs by frame::pc(),
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   219
// or by stubs.  Issuing PCs can be used directly with PC range tables.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   220
//
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   221
REGISTER_DECLARATION(Register, Oexception  , O0); // exception being thrown
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   222
REGISTER_DECLARATION(Register, Oissuing_pc , O1); // where the exception is coming from
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   223
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   224
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   225
// These must occur after the declarations above
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   226
#ifndef DONT_USE_REGISTER_DEFINES
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   227
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   228
#define Gthread             AS_REGISTER(Register, Gthread)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   229
#define Gmethod             AS_REGISTER(Register, Gmethod)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   230
#define Gmegamorphic_method AS_REGISTER(Register, Gmegamorphic_method)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   231
#define Ginline_cache_reg   AS_REGISTER(Register, Ginline_cache_reg)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   232
#define Gargs               AS_REGISTER(Register, Gargs)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   233
#define Lthread_cache       AS_REGISTER(Register, Lthread_cache)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   234
#define Gframe_size         AS_REGISTER(Register, Gframe_size)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   235
#define Gtemp               AS_REGISTER(Register, Gtemp)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   236
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   237
#ifdef CC_INTERP
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   238
#define Lstate              AS_REGISTER(Register, Lstate)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   239
#define Lesp                AS_REGISTER(Register, Lesp)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   240
#define L1_scratch          AS_REGISTER(Register, L1_scratch)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   241
#define Lmirror             AS_REGISTER(Register, Lmirror)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   242
#define L2_scratch          AS_REGISTER(Register, L2_scratch)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   243
#define L3_scratch          AS_REGISTER(Register, L3_scratch)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   244
#define L4_scratch          AS_REGISTER(Register, L4_scratch)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   245
#define Lscratch            AS_REGISTER(Register, Lscratch)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   246
#define Lscratch2           AS_REGISTER(Register, Lscratch2)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   247
#define L7_scratch          AS_REGISTER(Register, L7_scratch)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   248
#define Ostate              AS_REGISTER(Register, Ostate)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   249
#else
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   250
#define Lesp                AS_REGISTER(Register, Lesp)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   251
#define Lbcp                AS_REGISTER(Register, Lbcp)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   252
#define Lmethod             AS_REGISTER(Register, Lmethod)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   253
#define Llocals             AS_REGISTER(Register, Llocals)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   254
#define Lmonitors           AS_REGISTER(Register, Lmonitors)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   255
#define Lbyte_code          AS_REGISTER(Register, Lbyte_code)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   256
#define Lscratch            AS_REGISTER(Register, Lscratch)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   257
#define Lscratch2           AS_REGISTER(Register, Lscratch2)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   258
#define LcpoolCache         AS_REGISTER(Register, LcpoolCache)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   259
#endif /* ! CC_INTERP */
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   260
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   261
#define Lentry_args         AS_REGISTER(Register, Lentry_args)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   262
#define I5_savedSP          AS_REGISTER(Register, I5_savedSP)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   263
#define O5_savedSP          AS_REGISTER(Register, O5_savedSP)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   264
#define IdispatchAddress    AS_REGISTER(Register, IdispatchAddress)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   265
#define ImethodDataPtr      AS_REGISTER(Register, ImethodDataPtr)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   266
#define IdispatchTables     AS_REGISTER(Register, IdispatchTables)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   267
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   268
#define Oexception          AS_REGISTER(Register, Oexception)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   269
#define Oissuing_pc         AS_REGISTER(Register, Oissuing_pc)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   270
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   271
#endif
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   272
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   273
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   274
// Address is an abstraction used to represent a memory location.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   275
//
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   276
// Note: A register location is represented via a Register, not
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   277
//       via an address for efficiency & simplicity reasons.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   278
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   279
class Address VALUE_OBJ_CLASS_SPEC {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   280
 private:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   281
  Register           _base;           // Base register.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   282
  RegisterOrConstant _index_or_disp;  // Index register or constant displacement.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   283
  RelocationHolder   _rspec;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   284
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   285
 public:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   286
  Address() : _base(noreg), _index_or_disp(noreg) {}
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   287
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   288
  Address(Register base, RegisterOrConstant index_or_disp)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   289
    : _base(base),
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   290
      _index_or_disp(index_or_disp) {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   291
  }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   292
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   293
  Address(Register base, Register index)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   294
    : _base(base),
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   295
      _index_or_disp(index) {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   296
  }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   297
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   298
  Address(Register base, int disp)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   299
    : _base(base),
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   300
      _index_or_disp(disp) {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   301
  }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   302
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   303
#ifdef ASSERT
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   304
  // ByteSize is only a class when ASSERT is defined, otherwise it's an int.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   305
  Address(Register base, ByteSize disp)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   306
    : _base(base),
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   307
      _index_or_disp(in_bytes(disp)) {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   308
  }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   309
#endif
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   310
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   311
  // accessors
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   312
  Register base()             const { return _base; }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   313
  Register index()            const { return _index_or_disp.as_register(); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   314
  int      disp()             const { return _index_or_disp.as_constant(); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   315
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   316
  bool     has_index()        const { return _index_or_disp.is_register(); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   317
  bool     has_disp()         const { return _index_or_disp.is_constant(); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   318
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   319
  bool     uses(Register reg) const { return base() == reg || (has_index() && index() == reg); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   320
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   321
  const relocInfo::relocType rtype() { return _rspec.type(); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   322
  const RelocationHolder&    rspec() { return _rspec; }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   323
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   324
  RelocationHolder rspec(int offset) const {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   325
    return offset == 0 ? _rspec : _rspec.plus(offset);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   326
  }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   327
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   328
  inline bool is_simm13(int offset = 0);  // check disp+offset for overflow
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   329
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   330
  Address plus_disp(int plusdisp) const {     // bump disp by a small amount
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   331
    assert(_index_or_disp.is_constant(), "must have a displacement");
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   332
    Address a(base(), disp() + plusdisp);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   333
    return a;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   334
  }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   335
  bool is_same_address(Address a) const {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   336
    // disregard _rspec
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   337
    return base() == a.base() && (has_index() ? index() == a.index() : disp() == a.disp());
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   338
  }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   339
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   340
  Address after_save() const {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   341
    Address a = (*this);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   342
    a._base = a._base->after_save();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   343
    return a;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   344
  }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   345
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   346
  Address after_restore() const {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   347
    Address a = (*this);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   348
    a._base = a._base->after_restore();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   349
    return a;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   350
  }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   351
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   352
  // Convert the raw encoding form into the form expected by the
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   353
  // constructor for Address.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   354
  static Address make_raw(int base, int index, int scale, int disp, relocInfo::relocType disp_reloc);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   355
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   356
  friend class Assembler;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   357
};
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   358
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   359
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   360
class AddressLiteral VALUE_OBJ_CLASS_SPEC {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   361
 private:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   362
  address          _address;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   363
  RelocationHolder _rspec;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   364
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   365
  RelocationHolder rspec_from_rtype(relocInfo::relocType rtype, address addr) {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   366
    switch (rtype) {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   367
    case relocInfo::external_word_type:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   368
      return external_word_Relocation::spec(addr);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   369
    case relocInfo::internal_word_type:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   370
      return internal_word_Relocation::spec(addr);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   371
#ifdef _LP64
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   372
    case relocInfo::opt_virtual_call_type:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   373
      return opt_virtual_call_Relocation::spec();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   374
    case relocInfo::static_call_type:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   375
      return static_call_Relocation::spec();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   376
    case relocInfo::runtime_call_type:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   377
      return runtime_call_Relocation::spec();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   378
#endif
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   379
    case relocInfo::none:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   380
      return RelocationHolder();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   381
    default:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   382
      ShouldNotReachHere();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   383
      return RelocationHolder();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   384
    }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   385
  }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   386
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   387
 protected:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   388
  // creation
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   389
  AddressLiteral() : _address(NULL), _rspec(NULL) {}
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   390
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   391
 public:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   392
  AddressLiteral(address addr, RelocationHolder const& rspec)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   393
    : _address(addr),
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   394
      _rspec(rspec) {}
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   395
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   396
  // Some constructors to avoid casting at the call site.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   397
  AddressLiteral(jobject obj, RelocationHolder const& rspec)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   398
    : _address((address) obj),
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   399
      _rspec(rspec) {}
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   400
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   401
  AddressLiteral(intptr_t value, RelocationHolder const& rspec)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   402
    : _address((address) value),
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   403
      _rspec(rspec) {}
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   404
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   405
  AddressLiteral(address addr, relocInfo::relocType rtype = relocInfo::none)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   406
    : _address((address) addr),
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   407
    _rspec(rspec_from_rtype(rtype, (address) addr)) {}
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   408
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   409
  // Some constructors to avoid casting at the call site.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   410
  AddressLiteral(address* addr, relocInfo::relocType rtype = relocInfo::none)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   411
    : _address((address) addr),
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   412
    _rspec(rspec_from_rtype(rtype, (address) addr)) {}
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   413
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   414
  AddressLiteral(bool* addr, relocInfo::relocType rtype = relocInfo::none)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   415
    : _address((address) addr),
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   416
      _rspec(rspec_from_rtype(rtype, (address) addr)) {}
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   417
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   418
  AddressLiteral(const bool* addr, relocInfo::relocType rtype = relocInfo::none)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   419
    : _address((address) addr),
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   420
      _rspec(rspec_from_rtype(rtype, (address) addr)) {}
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   421
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   422
  AddressLiteral(signed char* addr, relocInfo::relocType rtype = relocInfo::none)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   423
    : _address((address) addr),
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   424
      _rspec(rspec_from_rtype(rtype, (address) addr)) {}
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   425
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   426
  AddressLiteral(int* addr, relocInfo::relocType rtype = relocInfo::none)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   427
    : _address((address) addr),
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   428
      _rspec(rspec_from_rtype(rtype, (address) addr)) {}
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   429
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   430
  AddressLiteral(intptr_t addr, relocInfo::relocType rtype = relocInfo::none)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   431
    : _address((address) addr),
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   432
      _rspec(rspec_from_rtype(rtype, (address) addr)) {}
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   433
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   434
#ifdef _LP64
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   435
  // 32-bit complains about a multiple declaration for int*.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   436
  AddressLiteral(intptr_t* addr, relocInfo::relocType rtype = relocInfo::none)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   437
    : _address((address) addr),
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   438
      _rspec(rspec_from_rtype(rtype, (address) addr)) {}
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   439
#endif
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   440
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   441
  AddressLiteral(Metadata* addr, relocInfo::relocType rtype = relocInfo::none)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   442
    : _address((address) addr),
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   443
      _rspec(rspec_from_rtype(rtype, (address) addr)) {}
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   444
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   445
  AddressLiteral(Metadata** addr, relocInfo::relocType rtype = relocInfo::none)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   446
    : _address((address) addr),
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   447
      _rspec(rspec_from_rtype(rtype, (address) addr)) {}
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   448
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   449
  AddressLiteral(float* addr, relocInfo::relocType rtype = relocInfo::none)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   450
    : _address((address) addr),
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   451
      _rspec(rspec_from_rtype(rtype, (address) addr)) {}
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   452
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   453
  AddressLiteral(double* addr, relocInfo::relocType rtype = relocInfo::none)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   454
    : _address((address) addr),
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   455
      _rspec(rspec_from_rtype(rtype, (address) addr)) {}
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   456
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   457
  intptr_t value() const { return (intptr_t) _address; }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   458
  int      low10() const;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   459
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   460
  const relocInfo::relocType rtype() const { return _rspec.type(); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   461
  const RelocationHolder&    rspec() const { return _rspec; }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   462
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   463
  RelocationHolder rspec(int offset) const {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   464
    return offset == 0 ? _rspec : _rspec.plus(offset);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   465
  }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   466
};
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   467
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   468
// Convenience classes
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   469
class ExternalAddress: public AddressLiteral {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   470
 private:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   471
  static relocInfo::relocType reloc_for_target(address target) {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   472
    // Sometimes ExternalAddress is used for values which aren't
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   473
    // exactly addresses, like the card table base.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   474
    // external_word_type can't be used for values in the first page
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   475
    // so just skip the reloc in that case.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   476
    return external_word_Relocation::can_be_relocated(target) ? relocInfo::external_word_type : relocInfo::none;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   477
  }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   478
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   479
 public:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   480
  ExternalAddress(address target) : AddressLiteral(target, reloc_for_target(          target)) {}
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   481
  ExternalAddress(Metadata** target) : AddressLiteral(target, reloc_for_target((address) target)) {}
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   482
};
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   483
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   484
inline Address RegisterImpl::address_in_saved_window() const {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   485
   return (Address(SP, (sp_offset_in_saved_window() * wordSize) + STACK_BIAS));
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   486
}
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   487
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   488
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   489
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   490
// Argument is an abstraction used to represent an outgoing
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   491
// actual argument or an incoming formal parameter, whether
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   492
// it resides in memory or in a register, in a manner consistent
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   493
// with the SPARC Application Binary Interface, or ABI.  This is
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   494
// often referred to as the native or C calling convention.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   495
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   496
class Argument VALUE_OBJ_CLASS_SPEC {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   497
 private:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   498
  int _number;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   499
  bool _is_in;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   500
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   501
 public:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   502
#ifdef _LP64
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   503
  enum {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   504
    n_register_parameters = 6,          // only 6 registers may contain integer parameters
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   505
    n_float_register_parameters = 16    // Can have up to 16 floating registers
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   506
  };
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   507
#else
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   508
  enum {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   509
    n_register_parameters = 6           // only 6 registers may contain integer parameters
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   510
  };
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   511
#endif
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   512
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   513
  // creation
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   514
  Argument(int number, bool is_in) : _number(number), _is_in(is_in) {}
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   515
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   516
  int  number() const  { return _number;  }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   517
  bool is_in()  const  { return _is_in;   }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   518
  bool is_out() const  { return !is_in(); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   519
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   520
  Argument successor() const  { return Argument(number() + 1, is_in()); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   521
  Argument as_in()     const  { return Argument(number(), true ); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   522
  Argument as_out()    const  { return Argument(number(), false); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   523
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   524
  // locating register-based arguments:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   525
  bool is_register() const { return _number < n_register_parameters; }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   526
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   527
#ifdef _LP64
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   528
  // locating Floating Point register-based arguments:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   529
  bool is_float_register() const { return _number < n_float_register_parameters; }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   530
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   531
  FloatRegister as_float_register() const {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   532
    assert(is_float_register(), "must be a register argument");
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   533
    return as_FloatRegister(( number() *2 ) + 1);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   534
  }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   535
  FloatRegister as_double_register() const {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   536
    assert(is_float_register(), "must be a register argument");
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   537
    return as_FloatRegister(( number() *2 ));
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   538
  }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   539
#endif
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   540
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   541
  Register as_register() const {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   542
    assert(is_register(), "must be a register argument");
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   543
    return is_in() ? as_iRegister(number()) : as_oRegister(number());
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   544
  }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   545
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   546
  // locating memory-based arguments
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   547
  Address as_address() const {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   548
    assert(!is_register(), "must be a memory argument");
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   549
    return address_in_frame();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   550
  }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   551
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   552
  // When applied to a register-based argument, give the corresponding address
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   553
  // into the 6-word area "into which callee may store register arguments"
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   554
  // (This is a different place than the corresponding register-save area location.)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   555
  Address address_in_frame() const;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   556
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   557
  // debugging
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   558
  const char* name() const;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   559
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   560
  friend class Assembler;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   561
};
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   562
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   563
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   564
class RegistersForDebugging : public StackObj {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   565
 public:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   566
  intptr_t i[8], l[8], o[8], g[8];
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   567
  float    f[32];
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   568
  double   d[32];
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   569
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   570
  void print(outputStream* s);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   571
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   572
  static int i_offset(int j) { return offset_of(RegistersForDebugging, i[j]); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   573
  static int l_offset(int j) { return offset_of(RegistersForDebugging, l[j]); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   574
  static int o_offset(int j) { return offset_of(RegistersForDebugging, o[j]); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   575
  static int g_offset(int j) { return offset_of(RegistersForDebugging, g[j]); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   576
  static int f_offset(int j) { return offset_of(RegistersForDebugging, f[j]); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   577
  static int d_offset(int j) { return offset_of(RegistersForDebugging, d[j / 2]); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   578
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   579
  // gen asm code to save regs
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   580
  static void save_registers(MacroAssembler* a);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   581
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   582
  // restore global registers in case C code disturbed them
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   583
  static void restore_registers(MacroAssembler* a, Register r);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   584
};
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   585
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   586
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   587
// MacroAssembler extends Assembler by a few frequently used macros.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   588
//
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   589
// Most of the standard SPARC synthetic ops are defined here.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   590
// Instructions for which a 'better' code sequence exists depending
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   591
// on arguments should also go in here.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   592
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   593
#define JMP2(r1, r2) jmp(r1, r2, __FILE__, __LINE__)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   594
#define JMP(r1, off) jmp(r1, off, __FILE__, __LINE__)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   595
#define JUMP(a, temp, off)     jump(a, temp, off, __FILE__, __LINE__)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   596
#define JUMPL(a, temp, d, off) jumpl(a, temp, d, off, __FILE__, __LINE__)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   597
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   598
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   599
class MacroAssembler : public Assembler {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   600
  // code patchers need various routines like inv_wdisp()
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   601
  friend class NativeInstruction;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   602
  friend class NativeGeneralJump;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   603
  friend class Relocation;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   604
  friend class Label;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   605
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   606
 protected:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   607
  static int  patched_branch(int dest_pos, int inst, int inst_pos);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   608
  static int  branch_destination(int inst, int pos);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   609
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   610
  // Support for VM calls
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   611
  // This is the base routine called by the different versions of call_VM_leaf. The interpreter
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   612
  // may customize this version by overriding it for its purposes (e.g., to save/restore
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   613
  // additional registers when doing a VM call).
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   614
#ifdef CC_INTERP
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   615
  #define VIRTUAL
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   616
#else
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   617
  #define VIRTUAL virtual
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   618
#endif
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   619
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   620
  VIRTUAL void call_VM_leaf_base(Register thread_cache, address entry_point, int number_of_arguments);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   621
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   622
  //
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   623
  // It is imperative that all calls into the VM are handled via the call_VM macros.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   624
  // They make sure that the stack linkage is setup correctly. call_VM's correspond
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   625
  // to ENTRY/ENTRY_X entry points while call_VM_leaf's correspond to LEAF entry points.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   626
  //
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   627
  // This is the base routine called by the different versions of call_VM. The interpreter
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   628
  // may customize this version by overriding it for its purposes (e.g., to save/restore
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   629
  // additional registers when doing a VM call).
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   630
  //
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   631
  // A non-volatile java_thread_cache register should be specified so
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   632
  // that the G2_thread value can be preserved across the call.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   633
  // (If java_thread_cache is noreg, then a slow get_thread call
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   634
  // will re-initialize the G2_thread.) call_VM_base returns the register that contains the
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   635
  // thread.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   636
  //
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   637
  // If no last_java_sp is specified (noreg) than SP will be used instead.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   638
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   639
  virtual void call_VM_base(
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   640
    Register        oop_result,             // where an oop-result ends up if any; use noreg otherwise
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   641
    Register        java_thread_cache,      // the thread if computed before     ; use noreg otherwise
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   642
    Register        last_java_sp,           // to set up last_Java_frame in stubs; use noreg otherwise
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   643
    address         entry_point,            // the entry point
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   644
    int             number_of_arguments,    // the number of arguments (w/o thread) to pop after call
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   645
    bool            check_exception=true    // flag which indicates if exception should be checked
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   646
  );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   647
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   648
  // This routine should emit JVMTI PopFrame and ForceEarlyReturn handling code.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   649
  // The implementation is only non-empty for the InterpreterMacroAssembler,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   650
  // as only the interpreter handles and ForceEarlyReturn PopFrame requests.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   651
  virtual void check_and_handle_popframe(Register scratch_reg);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   652
  virtual void check_and_handle_earlyret(Register scratch_reg);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   653
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   654
 public:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   655
  MacroAssembler(CodeBuffer* code) : Assembler(code) {}
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   656
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   657
  // Support for NULL-checks
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   658
  //
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   659
  // Generates code that causes a NULL OS exception if the content of reg is NULL.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   660
  // If the accessed location is M[reg + offset] and the offset is known, provide the
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   661
  // offset.  No explicit code generation is needed if the offset is within a certain
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   662
  // range (0 <= offset <= page_size).
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   663
  //
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   664
  // %%%%%% Currently not done for SPARC
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   665
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   666
  void null_check(Register reg, int offset = -1);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   667
  static bool needs_explicit_null_check(intptr_t offset);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   668
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   669
  // support for delayed instructions
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   670
  MacroAssembler* delayed() { Assembler::delayed();  return this; }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   671
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   672
  // branches that use right instruction for v8 vs. v9
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   673
  inline void br( Condition c, bool a, Predict p, address d, relocInfo::relocType rt = relocInfo::none );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   674
  inline void br( Condition c, bool a, Predict p, Label& L );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   675
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   676
  inline void fb( Condition c, bool a, Predict p, address d, relocInfo::relocType rt = relocInfo::none );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   677
  inline void fb( Condition c, bool a, Predict p, Label& L );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   678
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   679
  // compares register with zero (32 bit) and branches (V9 and V8 instructions)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   680
  void cmp_zero_and_br( Condition c, Register s1, Label& L, bool a = false, Predict p = pn );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   681
  // Compares a pointer register with zero and branches on (not)null.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   682
  // Does a test & branch on 32-bit systems and a register-branch on 64-bit.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   683
  void br_null   ( Register s1, bool a, Predict p, Label& L );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   684
  void br_notnull( Register s1, bool a, Predict p, Label& L );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   685
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   686
  //
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   687
  // Compare registers and branch with nop in delay slot or cbcond without delay slot.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   688
  //
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   689
  // ATTENTION: use these instructions with caution because cbcond instruction
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   690
  //            has very short distance: 512 instructions (2Kbyte).
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   691
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   692
  // Compare integer (32 bit) values (icc only).
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   693
  void cmp_and_br_short(Register s1, Register s2, Condition c, Predict p, Label& L);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   694
  void cmp_and_br_short(Register s1, int simm13a, Condition c, Predict p, Label& L);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   695
  // Platform depending version for pointer compare (icc on !LP64 and xcc on LP64).
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   696
  void cmp_and_brx_short(Register s1, Register s2, Condition c, Predict p, Label& L);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   697
  void cmp_and_brx_short(Register s1, int simm13a, Condition c, Predict p, Label& L);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   698
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   699
  // Short branch version for compares a pointer pwith zero.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   700
  void br_null_short   ( Register s1, Predict p, Label& L );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   701
  void br_notnull_short( Register s1, Predict p, Label& L );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   702
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   703
  // unconditional short branch
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   704
  void ba_short(Label& L);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   705
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   706
  inline void bp( Condition c, bool a, CC cc, Predict p, address d, relocInfo::relocType rt = relocInfo::none );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   707
  inline void bp( Condition c, bool a, CC cc, Predict p, Label& L );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   708
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   709
  // Branch that tests xcc in LP64 and icc in !LP64
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   710
  inline void brx( Condition c, bool a, Predict p, address d, relocInfo::relocType rt = relocInfo::none );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   711
  inline void brx( Condition c, bool a, Predict p, Label& L );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   712
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   713
  // unconditional branch
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   714
  inline void ba( Label& L );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   715
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   716
  // Branch that tests fp condition codes
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   717
  inline void fbp( Condition c, bool a, CC cc, Predict p, address d, relocInfo::relocType rt = relocInfo::none );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   718
  inline void fbp( Condition c, bool a, CC cc, Predict p, Label& L );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   719
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   720
  // get PC the best way
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   721
  inline int get_pc( Register d );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   722
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   723
  // Sparc shorthands(pp 85, V8 manual, pp 289 V9 manual)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   724
  inline void cmp(  Register s1, Register s2 ) { subcc( s1, s2, G0 ); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   725
  inline void cmp(  Register s1, int simm13a ) { subcc( s1, simm13a, G0 ); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   726
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   727
  inline void jmp( Register s1, Register s2 );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   728
  inline void jmp( Register s1, int simm13a, RelocationHolder const& rspec = RelocationHolder() );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   729
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   730
  // Check if the call target is out of wdisp30 range (relative to the code cache)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   731
  static inline bool is_far_target(address d);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   732
  inline void call( address d,  relocInfo::relocType rt = relocInfo::runtime_call_type );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   733
  inline void call( Label& L,   relocInfo::relocType rt = relocInfo::runtime_call_type );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   734
  inline void callr( Register s1, Register s2 );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   735
  inline void callr( Register s1, int simm13a, RelocationHolder const& rspec = RelocationHolder() );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   736
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   737
  // Emits nothing on V8
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   738
  inline void iprefetch( address d, relocInfo::relocType rt = relocInfo::none );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   739
  inline void iprefetch( Label& L);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   740
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   741
  inline void tst( Register s ) { orcc( G0, s, G0 ); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   742
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   743
#ifdef PRODUCT
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   744
  inline void ret(  bool trace = TraceJumps )   { if (trace) {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   745
                                                    mov(I7, O7); // traceable register
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   746
                                                    JMP(O7, 2 * BytesPerInstWord);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   747
                                                  } else {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   748
                                                    jmpl( I7, 2 * BytesPerInstWord, G0 );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   749
                                                  }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   750
                                                }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   751
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   752
  inline void retl( bool trace = TraceJumps )  { if (trace) JMP(O7, 2 * BytesPerInstWord);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   753
                                                 else jmpl( O7, 2 * BytesPerInstWord, G0 ); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   754
#else
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   755
  void ret(  bool trace = TraceJumps );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   756
  void retl( bool trace = TraceJumps );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   757
#endif /* PRODUCT */
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   758
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   759
  // Required platform-specific helpers for Label::patch_instructions.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   760
  // They _shadow_ the declarations in AbstractAssembler, which are undefined.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   761
  void pd_patch_instruction(address branch, address target);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   762
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   763
  // sethi Macro handles optimizations and relocations
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   764
private:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   765
  void internal_sethi(const AddressLiteral& addrlit, Register d, bool ForceRelocatable);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   766
public:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   767
  void sethi(const AddressLiteral& addrlit, Register d);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   768
  void patchable_sethi(const AddressLiteral& addrlit, Register d);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   769
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   770
  // compute the number of instructions for a sethi/set
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   771
  static int  insts_for_sethi( address a, bool worst_case = false );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   772
  static int  worst_case_insts_for_set();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   773
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   774
  // set may be either setsw or setuw (high 32 bits may be zero or sign)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   775
private:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   776
  void internal_set(const AddressLiteral& al, Register d, bool ForceRelocatable);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   777
  static int insts_for_internal_set(intptr_t value);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   778
public:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   779
  void set(const AddressLiteral& addrlit, Register d);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   780
  void set(intptr_t value, Register d);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   781
  void set(address addr, Register d, RelocationHolder const& rspec);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   782
  static int insts_for_set(intptr_t value) { return insts_for_internal_set(value); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   783
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   784
  void patchable_set(const AddressLiteral& addrlit, Register d);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   785
  void patchable_set(intptr_t value, Register d);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   786
  void set64(jlong value, Register d, Register tmp);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   787
  static int insts_for_set64(jlong value);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   788
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   789
  // sign-extend 32 to 64
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   790
  inline void signx( Register s, Register d ) { sra( s, G0, d); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   791
  inline void signx( Register d )             { sra( d, G0, d); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   792
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   793
  inline void not1( Register s, Register d ) { xnor( s, G0, d ); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   794
  inline void not1( Register d )             { xnor( d, G0, d ); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   795
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   796
  inline void neg( Register s, Register d ) { sub( G0, s, d ); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   797
  inline void neg( Register d )             { sub( G0, d, d ); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   798
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   799
  inline void cas(  Register s1, Register s2, Register d) { casa( s1, s2, d, ASI_PRIMARY); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   800
  inline void casx( Register s1, Register s2, Register d) { casxa(s1, s2, d, ASI_PRIMARY); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   801
  // Functions for isolating 64 bit atomic swaps for LP64
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   802
  // cas_ptr will perform cas for 32 bit VM's and casx for 64 bit VM's
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   803
  inline void cas_ptr(  Register s1, Register s2, Register d) {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   804
#ifdef _LP64
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   805
    casx( s1, s2, d );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   806
#else
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   807
    cas( s1, s2, d );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   808
#endif
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   809
  }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   810
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   811
  // Functions for isolating 64 bit shifts for LP64
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   812
  inline void sll_ptr( Register s1, Register s2, Register d );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   813
  inline void sll_ptr( Register s1, int imm6a,   Register d );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   814
  inline void sll_ptr( Register s1, RegisterOrConstant s2, Register d );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   815
  inline void srl_ptr( Register s1, Register s2, Register d );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   816
  inline void srl_ptr( Register s1, int imm6a,   Register d );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   817
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   818
  // little-endian
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   819
  inline void casl(  Register s1, Register s2, Register d) { casa( s1, s2, d, ASI_PRIMARY_LITTLE); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   820
  inline void casxl( Register s1, Register s2, Register d) { casxa(s1, s2, d, ASI_PRIMARY_LITTLE); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   821
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   822
  inline void inc(   Register d,  int const13 = 1 ) { add(   d, const13, d); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   823
  inline void inccc( Register d,  int const13 = 1 ) { addcc( d, const13, d); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   824
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   825
  inline void dec(   Register d,  int const13 = 1 ) { sub(   d, const13, d); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   826
  inline void deccc( Register d,  int const13 = 1 ) { subcc( d, const13, d); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   827
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   828
  using Assembler::add;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   829
  inline void add(Register s1, int simm13a, Register d, relocInfo::relocType rtype);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   830
  inline void add(Register s1, int simm13a, Register d, RelocationHolder const& rspec);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   831
  inline void add(Register s1, RegisterOrConstant s2, Register d, int offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   832
  inline void add(const Address& a, Register d, int offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   833
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   834
  using Assembler::andn;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   835
  inline void andn(  Register s1, RegisterOrConstant s2, Register d);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   836
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   837
  inline void btst( Register s1,  Register s2 ) { andcc( s1, s2, G0 ); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   838
  inline void btst( int simm13a,  Register s )  { andcc( s,  simm13a, G0 ); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   839
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   840
  inline void bset( Register s1,  Register s2 ) { or3( s1, s2, s2 ); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   841
  inline void bset( int simm13a,  Register s )  { or3( s,  simm13a, s ); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   842
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   843
  inline void bclr( Register s1,  Register s2 ) { andn( s1, s2, s2 ); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   844
  inline void bclr( int simm13a,  Register s )  { andn( s,  simm13a, s ); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   845
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   846
  inline void btog( Register s1,  Register s2 ) { xor3( s1, s2, s2 ); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   847
  inline void btog( int simm13a,  Register s )  { xor3( s,  simm13a, s ); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   848
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   849
  inline void clr( Register d ) { or3( G0, G0, d ); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   850
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   851
  inline void clrb( Register s1, Register s2);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   852
  inline void clrh( Register s1, Register s2);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   853
  inline void clr(  Register s1, Register s2);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   854
  inline void clrx( Register s1, Register s2);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   855
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   856
  inline void clrb( Register s1, int simm13a);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   857
  inline void clrh( Register s1, int simm13a);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   858
  inline void clr(  Register s1, int simm13a);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   859
  inline void clrx( Register s1, int simm13a);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   860
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   861
  // copy & clear upper word
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   862
  inline void clruw( Register s, Register d ) { srl( s, G0, d); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   863
  // clear upper word
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   864
  inline void clruwu( Register d ) { srl( d, G0, d); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   865
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   866
  using Assembler::ldsb;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   867
  using Assembler::ldsh;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   868
  using Assembler::ldsw;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   869
  using Assembler::ldub;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   870
  using Assembler::lduh;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   871
  using Assembler::lduw;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   872
  using Assembler::ldx;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   873
  using Assembler::ldd;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   874
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   875
#ifdef ASSERT
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   876
  // ByteSize is only a class when ASSERT is defined, otherwise it's an int.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   877
  inline void ld(Register s1, ByteSize simm13a, Register d);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   878
#endif
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   879
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   880
  inline void ld(Register s1, Register s2, Register d);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   881
  inline void ld(Register s1, int simm13a, Register d);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   882
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   883
  inline void ldsb(const Address& a, Register d, int offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   884
  inline void ldsh(const Address& a, Register d, int offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   885
  inline void ldsw(const Address& a, Register d, int offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   886
  inline void ldub(const Address& a, Register d, int offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   887
  inline void lduh(const Address& a, Register d, int offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   888
  inline void lduw(const Address& a, Register d, int offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   889
  inline void ldx( const Address& a, Register d, int offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   890
  inline void ld(  const Address& a, Register d, int offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   891
  inline void ldd( const Address& a, Register d, int offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   892
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   893
  inline void ldub(Register s1, RegisterOrConstant s2, Register d );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   894
  inline void ldsb(Register s1, RegisterOrConstant s2, Register d );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   895
  inline void lduh(Register s1, RegisterOrConstant s2, Register d );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   896
  inline void ldsh(Register s1, RegisterOrConstant s2, Register d );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   897
  inline void lduw(Register s1, RegisterOrConstant s2, Register d );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   898
  inline void ldsw(Register s1, RegisterOrConstant s2, Register d );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   899
  inline void ldx( Register s1, RegisterOrConstant s2, Register d );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   900
  inline void ld(  Register s1, RegisterOrConstant s2, Register d );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   901
  inline void ldd( Register s1, RegisterOrConstant s2, Register d );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   902
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   903
  using Assembler::ldf;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   904
  inline void ldf(FloatRegisterImpl::Width w, Register s1, RegisterOrConstant s2, FloatRegister d);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   905
  inline void ldf(FloatRegisterImpl::Width w, const Address& a, FloatRegister d, int offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   906
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   907
  // membar psuedo instruction.  takes into account target memory model.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   908
  inline void membar( Assembler::Membar_mask_bits const7a );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   909
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   910
  // returns if membar generates anything.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   911
  inline bool membar_has_effect( Assembler::Membar_mask_bits const7a );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   912
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   913
  // mov pseudo instructions
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   914
  inline void mov( Register s,  Register d) {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   915
    if ( s != d )    or3( G0, s, d);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   916
    else             assert_not_delayed();  // Put something useful in the delay slot!
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   917
  }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   918
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   919
  inline void mov_or_nop( Register s,  Register d) {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   920
    if ( s != d )    or3( G0, s, d);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   921
    else             nop();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   922
  }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   923
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   924
  inline void mov( int simm13a, Register d) { or3( G0, simm13a, d); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   925
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   926
  using Assembler::prefetch;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   927
  inline void prefetch(const Address& a, PrefetchFcn F, int offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   928
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   929
  using Assembler::stb;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   930
  using Assembler::sth;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   931
  using Assembler::stw;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   932
  using Assembler::stx;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   933
  using Assembler::std;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   934
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   935
#ifdef ASSERT
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   936
  // ByteSize is only a class when ASSERT is defined, otherwise it's an int.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   937
  inline void st(Register d, Register s1, ByteSize simm13a);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   938
#endif
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   939
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   940
  inline void st(Register d, Register s1, Register s2);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   941
  inline void st(Register d, Register s1, int simm13a);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   942
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   943
  inline void stb(Register d, const Address& a, int offset = 0 );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   944
  inline void sth(Register d, const Address& a, int offset = 0 );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   945
  inline void stw(Register d, const Address& a, int offset = 0 );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   946
  inline void stx(Register d, const Address& a, int offset = 0 );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   947
  inline void st( Register d, const Address& a, int offset = 0 );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   948
  inline void std(Register d, const Address& a, int offset = 0 );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   949
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   950
  inline void stb(Register d, Register s1, RegisterOrConstant s2 );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   951
  inline void sth(Register d, Register s1, RegisterOrConstant s2 );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   952
  inline void stw(Register d, Register s1, RegisterOrConstant s2 );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   953
  inline void stx(Register d, Register s1, RegisterOrConstant s2 );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   954
  inline void std(Register d, Register s1, RegisterOrConstant s2 );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   955
  inline void st( Register d, Register s1, RegisterOrConstant s2 );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   956
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   957
  using Assembler::stf;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   958
  inline void stf(FloatRegisterImpl::Width w, FloatRegister d, Register s1, RegisterOrConstant s2);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   959
  inline void stf(FloatRegisterImpl::Width w, FloatRegister d, const Address& a, int offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   960
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   961
  // Note: offset is added to s2.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   962
  using Assembler::sub;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   963
  inline void sub(Register s1, RegisterOrConstant s2, Register d, int offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   964
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   965
  using Assembler::swap;
18104
590c10f73634 8002160: Compilation issue with adlc using latest SunStudio compilers
drchase
parents: 18097
diff changeset
   966
  inline void swap(const Address& a, Register d, int offset = 0);
14631
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   967
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   968
  // address pseudos: make these names unlike instruction names to avoid confusion
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   969
  inline intptr_t load_pc_address( Register reg, int bytes_to_skip );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   970
  inline void load_contents(const AddressLiteral& addrlit, Register d, int offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   971
  inline void load_bool_contents(const AddressLiteral& addrlit, Register d, int offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   972
  inline void load_ptr_contents(const AddressLiteral& addrlit, Register d, int offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   973
  inline void store_contents(Register s, const AddressLiteral& addrlit, Register temp, int offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   974
  inline void store_ptr_contents(Register s, const AddressLiteral& addrlit, Register temp, int offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   975
  inline void jumpl_to(const AddressLiteral& addrlit, Register temp, Register d, int offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   976
  inline void jump_to(const AddressLiteral& addrlit, Register temp, int offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   977
  inline void jump_indirect_to(Address& a, Register temp, int ld_offset = 0, int jmp_offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   978
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   979
  // ring buffer traceable jumps
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   980
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   981
  void jmp2( Register r1, Register r2, const char* file, int line );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   982
  void jmp ( Register r1, int offset,  const char* file, int line );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   983
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   984
  void jumpl(const AddressLiteral& addrlit, Register temp, Register d, int offset, const char* file, int line);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   985
  void jump (const AddressLiteral& addrlit, Register temp,             int offset, const char* file, int line);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   986
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   987
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   988
  // argument pseudos:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   989
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   990
  inline void load_argument( Argument& a, Register  d );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   991
  inline void store_argument( Register s, Argument& a );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   992
  inline void store_ptr_argument( Register s, Argument& a );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   993
  inline void store_float_argument( FloatRegister s, Argument& a );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   994
  inline void store_double_argument( FloatRegister s, Argument& a );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   995
  inline void store_long_argument( Register s, Argument& a );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   996
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   997
  // handy macros:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   998
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
   999
  inline void round_to( Register r, int modulus ) {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1000
    assert_not_delayed();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1001
    inc( r, modulus - 1 );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1002
    and3( r, -modulus, r );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1003
  }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1004
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1005
  // --------------------------------------------------
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1006
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1007
  // Functions for isolating 64 bit loads for LP64
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1008
  // ld_ptr will perform ld for 32 bit VM's and ldx for 64 bit VM's
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1009
  // st_ptr will perform st for 32 bit VM's and stx for 64 bit VM's
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1010
  inline void ld_ptr(Register s1, Register s2, Register d);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1011
  inline void ld_ptr(Register s1, int simm13a, Register d);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1012
  inline void ld_ptr(Register s1, RegisterOrConstant s2, Register d);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1013
  inline void ld_ptr(const Address& a, Register d, int offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1014
  inline void st_ptr(Register d, Register s1, Register s2);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1015
  inline void st_ptr(Register d, Register s1, int simm13a);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1016
  inline void st_ptr(Register d, Register s1, RegisterOrConstant s2);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1017
  inline void st_ptr(Register d, const Address& a, int offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1018
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1019
#ifdef ASSERT
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1020
  // ByteSize is only a class when ASSERT is defined, otherwise it's an int.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1021
  inline void ld_ptr(Register s1, ByteSize simm13a, Register d);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1022
  inline void st_ptr(Register d, Register s1, ByteSize simm13a);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1023
#endif
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1024
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1025
  // ld_long will perform ldd for 32 bit VM's and ldx for 64 bit VM's
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1026
  // st_long will perform std for 32 bit VM's and stx for 64 bit VM's
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1027
  inline void ld_long(Register s1, Register s2, Register d);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1028
  inline void ld_long(Register s1, int simm13a, Register d);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1029
  inline void ld_long(Register s1, RegisterOrConstant s2, Register d);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1030
  inline void ld_long(const Address& a, Register d, int offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1031
  inline void st_long(Register d, Register s1, Register s2);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1032
  inline void st_long(Register d, Register s1, int simm13a);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1033
  inline void st_long(Register d, Register s1, RegisterOrConstant s2);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1034
  inline void st_long(Register d, const Address& a, int offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1035
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1036
  // Helpers for address formation.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1037
  // - They emit only a move if s2 is a constant zero.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1038
  // - If dest is a constant and either s1 or s2 is a register, the temp argument is required and becomes the result.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1039
  // - If dest is a register and either s1 or s2 is a non-simm13 constant, the temp argument is required and used to materialize the constant.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1040
  RegisterOrConstant regcon_andn_ptr(RegisterOrConstant s1, RegisterOrConstant s2, RegisterOrConstant d, Register temp = noreg);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1041
  RegisterOrConstant regcon_inc_ptr( RegisterOrConstant s1, RegisterOrConstant s2, RegisterOrConstant d, Register temp = noreg);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1042
  RegisterOrConstant regcon_sll_ptr( RegisterOrConstant s1, RegisterOrConstant s2, RegisterOrConstant d, Register temp = noreg);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1043
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1044
  RegisterOrConstant ensure_simm13_or_reg(RegisterOrConstant src, Register temp) {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1045
    if (is_simm13(src.constant_or_zero()))
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1046
      return src;               // register or short constant
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1047
    guarantee(temp != noreg, "constant offset overflow");
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1048
    set(src.as_constant(), temp);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1049
    return temp;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1050
  }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1051
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1052
  // --------------------------------------------------
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1053
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1054
 public:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1055
  // traps as per trap.h (SPARC ABI?)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1056
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1057
  void breakpoint_trap();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1058
  void breakpoint_trap(Condition c, CC cc);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1059
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1060
  // Support for serializing memory accesses between threads
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1061
  void serialize_memory(Register thread, Register tmp1, Register tmp2);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1062
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1063
  // Stack frame creation/removal
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1064
  void enter();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1065
  void leave();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1066
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1067
  // Manipulation of C++ bools
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1068
  // These are idioms to flag the need for care with accessing bools but on
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1069
  // this platform we assume byte size
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1070
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1071
  inline void stbool(Register d, const Address& a) { stb(d, a); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1072
  inline void ldbool(const Address& a, Register d) { ldub(a, d); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1073
  inline void movbool( bool boolconst, Register d) { mov( (int) boolconst, d); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1074
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1075
  // klass oop manipulations if compressed
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1076
  void load_klass(Register src_oop, Register klass);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1077
  void store_klass(Register klass, Register dst_oop);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1078
  void store_klass_gap(Register s, Register dst_oop);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1079
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1080
   // oop manipulations
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1081
  void load_heap_oop(const Address& s, Register d);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1082
  void load_heap_oop(Register s1, Register s2, Register d);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1083
  void load_heap_oop(Register s1, int simm13a, Register d);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1084
  void load_heap_oop(Register s1, RegisterOrConstant s2, Register d);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1085
  void store_heap_oop(Register d, Register s1, Register s2);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1086
  void store_heap_oop(Register d, Register s1, int simm13a);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1087
  void store_heap_oop(Register d, const Address& a, int offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1088
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1089
  void encode_heap_oop(Register src, Register dst);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1090
  void encode_heap_oop(Register r) {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1091
    encode_heap_oop(r, r);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1092
  }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1093
  void decode_heap_oop(Register src, Register dst);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1094
  void decode_heap_oop(Register r) {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1095
    decode_heap_oop(r, r);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1096
  }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1097
  void encode_heap_oop_not_null(Register r);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1098
  void decode_heap_oop_not_null(Register r);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1099
  void encode_heap_oop_not_null(Register src, Register dst);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1100
  void decode_heap_oop_not_null(Register src, Register dst);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1101
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1102
  void encode_klass_not_null(Register r);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1103
  void decode_klass_not_null(Register r);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1104
  void encode_klass_not_null(Register src, Register dst);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1105
  void decode_klass_not_null(Register src, Register dst);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1106
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1107
  // Support for managing the JavaThread pointer (i.e.; the reference to
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1108
  // thread-local information).
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1109
  void get_thread();                                // load G2_thread
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1110
  void verify_thread();                             // verify G2_thread contents
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1111
  void save_thread   (const Register threache); // save to cache
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1112
  void restore_thread(const Register thread_cache); // restore from cache
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1113
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1114
  // Support for last Java frame (but use call_VM instead where possible)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1115
  void set_last_Java_frame(Register last_java_sp, Register last_Java_pc);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1116
  void reset_last_Java_frame(void);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1117
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1118
  // Call into the VM.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1119
  // Passes the thread pointer (in O0) as a prepended argument.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1120
  // Makes sure oop return values are visible to the GC.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1121
  void call_VM(Register oop_result, address entry_point, int number_of_arguments = 0, bool check_exceptions = true);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1122
  void call_VM(Register oop_result, address entry_point, Register arg_1, bool check_exceptions = true);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1123
  void call_VM(Register oop_result, address entry_point, Register arg_1, Register arg_2, bool check_exceptions = true);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1124
  void call_VM(Register oop_result, address entry_point, Register arg_1, Register arg_2, Register arg_3, bool check_exceptions = true);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1125
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1126
  // these overloadings are not presently used on SPARC:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1127
  void call_VM(Register oop_result, Register last_java_sp, address entry_point, int number_of_arguments = 0, bool check_exceptions = true);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1128
  void call_VM(Register oop_result, Register last_java_sp, address entry_point, Register arg_1, bool check_exceptions = true);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1129
  void call_VM(Register oop_result, Register last_java_sp, address entry_point, Register arg_1, Register arg_2, bool check_exceptions = true);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1130
  void call_VM(Register oop_result, Register last_java_sp, address entry_point, Register arg_1, Register arg_2, Register arg_3, bool check_exceptions = true);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1131
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1132
  void call_VM_leaf(Register thread_cache, address entry_point, int number_of_arguments = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1133
  void call_VM_leaf(Register thread_cache, address entry_point, Register arg_1);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1134
  void call_VM_leaf(Register thread_cache, address entry_point, Register arg_1, Register arg_2);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1135
  void call_VM_leaf(Register thread_cache, address entry_point, Register arg_1, Register arg_2, Register arg_3);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1136
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1137
  void get_vm_result  (Register oop_result);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1138
  void get_vm_result_2(Register metadata_result);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1139
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1140
  // vm result is currently getting hijacked to for oop preservation
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1141
  void set_vm_result(Register oop_result);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1142
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1143
  // Emit the CompiledIC call idiom
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1144
  void ic_call(address entry, bool emit_delay = true);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1145
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1146
  // if call_VM_base was called with check_exceptions=false, then call
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1147
  // check_and_forward_exception to handle exceptions when it is safe
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1148
  void check_and_forward_exception(Register scratch_reg);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1149
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1150
  // Write to card table for - register is destroyed afterwards.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1151
  void card_table_write(jbyte* byte_map_base, Register tmp, Register obj);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1152
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1153
  void card_write_barrier_post(Register store_addr, Register new_val, Register tmp);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1154
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14827
diff changeset
  1155
#if INCLUDE_ALL_GCS
14631
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1156
  // General G1 pre-barrier generator.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1157
  void g1_write_barrier_pre(Register obj, Register index, int offset, Register pre_val, Register tmp, bool preserve_o_regs);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1158
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1159
  // General G1 post-barrier generator
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1160
  void g1_write_barrier_post(Register store_addr, Register new_val, Register tmp);
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14827
diff changeset
  1161
#endif // INCLUDE_ALL_GCS
14631
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1162
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1163
  // pushes double TOS element of FPU stack on CPU stack; pops from FPU stack
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1164
  void push_fTOS();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1165
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1166
  // pops double TOS element from CPU stack and pushes on FPU stack
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1167
  void pop_fTOS();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1168
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1169
  void empty_FPU_stack();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1170
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1171
  void push_IU_state();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1172
  void pop_IU_state();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1173
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1174
  void push_FPU_state();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1175
  void pop_FPU_state();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1176
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1177
  void push_CPU_state();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1178
  void pop_CPU_state();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1179
19319
0ad35be0733a 8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents: 18104
diff changeset
  1180
  // Returns the byte size of the instructions generated by decode_klass_not_null().
0ad35be0733a 8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents: 18104
diff changeset
  1181
  static int instr_size_for_decode_klass_not_null();
0ad35be0733a 8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents: 18104
diff changeset
  1182
14631
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1183
  // if heap base register is used - reinit it with the correct value
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1184
  void reinit_heapbase();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1185
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1186
  // Debugging
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1187
  void _verify_oop(Register reg, const char * msg, const char * file, int line);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1188
  void _verify_oop_addr(Address addr, const char * msg, const char * file, int line);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1189
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1190
  // TODO: verify_method and klass metadata (compare against vptr?)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1191
  void _verify_method_ptr(Register reg, const char * msg, const char * file, int line) {}
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1192
  void _verify_klass_ptr(Register reg, const char * msg, const char * file, int line){}
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1193
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1194
#define verify_oop(reg) _verify_oop(reg, "broken oop " #reg, __FILE__, __LINE__)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1195
#define verify_oop_addr(addr) _verify_oop_addr(addr, "broken oop addr ", __FILE__, __LINE__)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1196
#define verify_method_ptr(reg) _verify_method_ptr(reg, "broken method " #reg, __FILE__, __LINE__)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1197
#define verify_klass_ptr(reg) _verify_klass_ptr(reg, "broken klass " #reg, __FILE__, __LINE__)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1198
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1199
        // only if +VerifyOops
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1200
  void verify_FPU(int stack_depth, const char* s = "illegal FPU state");
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1201
        // only if +VerifyFPU
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1202
  void stop(const char* msg);                          // prints msg, dumps registers and stops execution
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1203
  void warn(const char* msg);                          // prints msg, but don't stop
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1204
  void untested(const char* what = "");
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1205
  void unimplemented(const char* what = "")      { char* b = new char[1024];  jio_snprintf(b, 1024, "unimplemented: %s", what);  stop(b); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1206
  void should_not_reach_here()                   { stop("should not reach here"); }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1207
  void print_CPU_state();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1208
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1209
  // oops in code
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1210
  AddressLiteral allocate_oop_address(jobject obj);                          // allocate_index
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1211
  AddressLiteral constant_oop_address(jobject obj);                          // find_index
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1212
  inline void    set_oop             (jobject obj, Register d);              // uses allocate_oop_address
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1213
  inline void    set_oop_constant    (jobject obj, Register d);              // uses constant_oop_address
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1214
  inline void    set_oop             (const AddressLiteral& obj_addr, Register d); // same as load_address
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1215
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1216
  // metadata in code that we have to keep track of
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1217
  AddressLiteral allocate_metadata_address(Metadata* obj); // allocate_index
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1218
  AddressLiteral constant_metadata_address(Metadata* obj); // find_index
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1219
  inline void    set_metadata             (Metadata* obj, Register d);              // uses allocate_metadata_address
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1220
  inline void    set_metadata_constant    (Metadata* obj, Register d);              // uses constant_metadata_address
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1221
  inline void    set_metadata             (const AddressLiteral& obj_addr, Register d); // same as load_address
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1222
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1223
  void set_narrow_oop( jobject obj, Register d );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1224
  void set_narrow_klass( Klass* k, Register d );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1225
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1226
  // nop padding
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1227
  void align(int modulus);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1228
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1229
  // declare a safepoint
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1230
  void safepoint();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1231
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1232
  // factor out part of stop into subroutine to save space
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1233
  void stop_subroutine();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1234
  // factor out part of verify_oop into subroutine to save space
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1235
  void verify_oop_subroutine();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1236
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1237
  // side-door communication with signalHandler in os_solaris.cpp
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1238
  static address _verify_oop_implicit_branch[3];
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1239
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1240
  int total_frame_size_in_bytes(int extraWords);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1241
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1242
  // used when extraWords known statically
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1243
  void save_frame(int extraWords = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1244
  void save_frame_c1(int size_in_bytes);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1245
  // make a frame, and simultaneously pass up one or two register value
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1246
  // into the new register window
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1247
  void save_frame_and_mov(int extraWords, Register s1, Register d1, Register s2 = Register(), Register d2 = Register());
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1248
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1249
  // give no. (outgoing) params, calc # of words will need on frame
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1250
  void calc_mem_param_words(Register Rparam_words, Register Rresult);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1251
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1252
  // used to calculate frame size dynamically
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1253
  // result is in bytes and must be negated for save inst
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1254
  void calc_frame_size(Register extraWords, Register resultReg);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1255
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1256
  // calc and also save
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1257
  void calc_frame_size_and_save(Register extraWords, Register resultReg);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1258
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1259
  static void debug(char* msg, RegistersForDebugging* outWindow);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1260
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1261
  // implementations of bytecodes used by both interpreter and compiler
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1262
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1263
  void lcmp( Register Ra_hi, Register Ra_low,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1264
             Register Rb_hi, Register Rb_low,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1265
             Register Rresult);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1266
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1267
  void lneg( Register Rhi, Register Rlow );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1268
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1269
  void lshl(  Register Rin_high,  Register Rin_low,  Register Rcount,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1270
              Register Rout_high, Register Rout_low, Register Rtemp );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1271
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1272
  void lshr(  Register Rin_high,  Register Rin_low,  Register Rcount,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1273
              Register Rout_high, Register Rout_low, Register Rtemp );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1274
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1275
  void lushr( Register Rin_high,  Register Rin_low,  Register Rcount,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1276
              Register Rout_high, Register Rout_low, Register Rtemp );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1277
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1278
#ifdef _LP64
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1279
  void lcmp( Register Ra, Register Rb, Register Rresult);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1280
#endif
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1281
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1282
  // Load and store values by size and signed-ness
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1283
  void load_sized_value( Address src, Register dst, size_t size_in_bytes, bool is_signed);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1284
  void store_sized_value(Register src, Address dst, size_t size_in_bytes);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1285
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1286
  void float_cmp( bool is_float, int unordered_result,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1287
                  FloatRegister Fa, FloatRegister Fb,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1288
                  Register Rresult);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1289
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1290
  void save_all_globals_into_locals();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1291
  void restore_globals_from_locals();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1292
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1293
  // These set the icc condition code to equal if the lock succeeded
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1294
  // and notEqual if it failed and requires a slow case
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1295
  void compiler_lock_object(Register Roop, Register Rmark, Register Rbox,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1296
                            Register Rscratch,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1297
                            BiasedLockingCounters* counters = NULL,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1298
                            bool try_bias = UseBiasedLocking);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1299
  void compiler_unlock_object(Register Roop, Register Rmark, Register Rbox,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1300
                              Register Rscratch,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1301
                              bool try_bias = UseBiasedLocking);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1302
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1303
  // Biased locking support
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1304
  // Upon entry, lock_reg must point to the lock record on the stack,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1305
  // obj_reg must contain the target object, and mark_reg must contain
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1306
  // the target object's header.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1307
  // Destroys mark_reg if an attempt is made to bias an anonymously
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1308
  // biased lock. In this case a failure will go either to the slow
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1309
  // case or fall through with the notEqual condition code set with
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1310
  // the expectation that the slow case in the runtime will be called.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1311
  // In the fall-through case where the CAS-based lock is done,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1312
  // mark_reg is not destroyed.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1313
  void biased_locking_enter(Register obj_reg, Register mark_reg, Register temp_reg,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1314
                            Label& done, Label* slow_case = NULL,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1315
                            BiasedLockingCounters* counters = NULL);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1316
  // Upon entry, the base register of mark_addr must contain the oop.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1317
  // Destroys temp_reg.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1318
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1319
  // If allow_delay_slot_filling is set to true, the next instruction
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1320
  // emitted after this one will go in an annulled delay slot if the
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1321
  // biased locking exit case failed.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1322
  void biased_locking_exit(Address mark_addr, Register temp_reg, Label& done, bool allow_delay_slot_filling = false);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1323
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1324
  // allocation
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1325
  void eden_allocate(
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1326
    Register obj,                      // result: pointer to object after successful allocation
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1327
    Register var_size_in_bytes,        // object size in bytes if unknown at compile time; invalid otherwise
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1328
    int      con_size_in_bytes,        // object size in bytes if   known at compile time
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1329
    Register t1,                       // temp register
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1330
    Register t2,                       // temp register
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1331
    Label&   slow_case                 // continuation point if fast allocation fails
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1332
  );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1333
  void tlab_allocate(
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1334
    Register obj,                      // result: pointer to object after successful allocation
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1335
    Register var_size_in_bytes,        // object size in bytes if unknown at compile time; invalid otherwise
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1336
    int      con_size_in_bytes,        // object size in bytes if   known at compile time
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1337
    Register t1,                       // temp register
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1338
    Label&   slow_case                 // continuation point if fast allocation fails
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1339
  );
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1340
  void tlab_refill(Label& retry_tlab, Label& try_eden, Label& slow_case);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1341
  void incr_allocated_bytes(RegisterOrConstant size_in_bytes,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1342
                            Register t1, Register t2);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1343
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1344
  // interface method calling
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1345
  void lookup_interface_method(Register recv_klass,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1346
                               Register intf_klass,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1347
                               RegisterOrConstant itable_index,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1348
                               Register method_result,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1349
                               Register temp_reg, Register temp2_reg,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1350
                               Label& no_such_interface);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1351
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1352
  // virtual method calling
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1353
  void lookup_virtual_method(Register recv_klass,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1354
                             RegisterOrConstant vtable_index,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1355
                             Register method_result);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1356
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1357
  // Test sub_klass against super_klass, with fast and slow paths.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1358
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1359
  // The fast path produces a tri-state answer: yes / no / maybe-slow.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1360
  // One of the three labels can be NULL, meaning take the fall-through.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1361
  // If super_check_offset is -1, the value is loaded up from super_klass.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1362
  // No registers are killed, except temp_reg and temp2_reg.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1363
  // If super_check_offset is not -1, temp2_reg is not used and can be noreg.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1364
  void check_klass_subtype_fast_path(Register sub_klass,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1365
                                     Register super_klass,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1366
                                     Register temp_reg,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1367
                                     Register temp2_reg,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1368
                                     Label* L_success,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1369
                                     Label* L_failure,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1370
                                     Label* L_slow_path,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1371
                RegisterOrConstant super_check_offset = RegisterOrConstant(-1));
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1372
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1373
  // The rest of the type check; must be wired to a corresponding fast path.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1374
  // It does not repeat the fast path logic, so don't use it standalone.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1375
  // The temp_reg can be noreg, if no temps are available.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1376
  // It can also be sub_klass or super_klass, meaning it's OK to kill that one.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1377
  // Updates the sub's secondary super cache as necessary.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1378
  void check_klass_subtype_slow_path(Register sub_klass,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1379
                                     Register super_klass,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1380
                                     Register temp_reg,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1381
                                     Register temp2_reg,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1382
                                     Register temp3_reg,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1383
                                     Register temp4_reg,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1384
                                     Label* L_success,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1385
                                     Label* L_failure);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1386
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1387
  // Simplified, combined version, good for typical uses.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1388
  // Falls through on failure.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1389
  void check_klass_subtype(Register sub_klass,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1390
                           Register super_klass,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1391
                           Register temp_reg,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1392
                           Register temp2_reg,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1393
                           Label& L_success);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1394
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1395
  // method handles (JSR 292)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1396
  // offset relative to Gargs of argument at tos[arg_slot].
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1397
  // (arg_slot == 0 means the last argument, not the first).
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1398
  RegisterOrConstant argument_offset(RegisterOrConstant arg_slot,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1399
                                     Register temp_reg,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1400
                                     int extra_slot_offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1401
  // Address of Gargs and argument_offset.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1402
  Address            argument_address(RegisterOrConstant arg_slot,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1403
                                      Register temp_reg = noreg,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1404
                                      int extra_slot_offset = 0);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1405
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1406
  // Stack overflow checking
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1407
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1408
  // Note: this clobbers G3_scratch
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1409
  void bang_stack_with_offset(int offset) {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1410
    // stack grows down, caller passes positive offset
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1411
    assert(offset > 0, "must bang with negative offset");
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1412
    set((-offset)+STACK_BIAS, G3_scratch);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1413
    st(G0, SP, G3_scratch);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1414
  }
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1415
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1416
  // Writes to stack successive pages until offset reached to check for
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1417
  // stack overflow + shadow pages.  Clobbers tsp and scratch registers.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1418
  void bang_stack_size(Register Rsize, Register Rtsp, Register Rscratch);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1419
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1420
  virtual RegisterOrConstant delayed_value_impl(intptr_t* delayed_value_addr, Register tmp, int offset);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1421
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1422
  void verify_tlab();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1423
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1424
  Condition negate_condition(Condition cond);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1425
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1426
  // Helper functions for statistics gathering.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1427
  // Conditionally (non-atomically) increments passed counter address, preserving condition codes.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1428
  void cond_inc(Condition cond, address counter_addr, Register Rtemp1, Register Rtemp2);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1429
  // Unconditional increment.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1430
  void inc_counter(address counter_addr, Register Rtmp1, Register Rtmp2);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1431
  void inc_counter(int*    counter_addr, Register Rtmp1, Register Rtmp2);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1432
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1433
  // Compare char[] arrays aligned to 4 bytes.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1434
  void char_arrays_equals(Register ary1, Register ary2,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1435
                          Register limit, Register result,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1436
                          Register chr1, Register chr2, Label& Ldone);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1437
  // Use BIS for zeroing
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1438
  void bis_zeroing(Register to, Register count, Register temp, Label& Ldone);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1439
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1440
#undef VIRTUAL
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1441
};
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1442
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1443
/**
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1444
 * class SkipIfEqual:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1445
 *
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1446
 * Instantiating this class will result in assembly code being output that will
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1447
 * jump around any code emitted between the creation of the instance and it's
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1448
 * automatic destruction at the end of a scope block, depending on the value of
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1449
 * the flag passed to the constructor, which will be checked at run-time.
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1450
 */
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1451
class SkipIfEqual : public StackObj {
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1452
 private:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1453
  MacroAssembler* _masm;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1454
  Label _label;
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1455
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1456
 public:
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1457
   // 'temp' is a temp register that this object can use (and trash)
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1458
   SkipIfEqual(MacroAssembler*, Register temp,
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1459
               const bool* flag_addr, Assembler::Condition condition);
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1460
   ~SkipIfEqual();
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1461
};
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1462
526804361522 8003250: SPARC: move MacroAssembler into separate file
twisti
parents:
diff changeset
  1463
#endif // CPU_SPARC_VM_MACROASSEMBLER_SPARC_HPP