hotspot/src/share/vm/c1/c1_Instruction.hpp
author roland
Fri, 23 Dec 2011 09:36:23 +0100
changeset 11433 2a2e375199de
parent 11192 ff37c2093a0d
child 11886 feebf5c9f40c
permissions -rw-r--r--
7123253: C1: in store check code, usage of registers may be incorrect Summary: fix usage of input register in assembly code for store check. Reviewed-by: never
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
8065
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
     2
 * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5334
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5334
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5334
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7100
diff changeset
    25
#ifndef SHARE_VM_C1_C1_INSTRUCTION_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7100
diff changeset
    26
#define SHARE_VM_C1_C1_INSTRUCTION_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7100
diff changeset
    27
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7100
diff changeset
    28
#include "c1/c1_Compilation.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7100
diff changeset
    29
#include "c1/c1_LIR.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7100
diff changeset
    30
#include "c1/c1_ValueType.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7100
diff changeset
    31
#include "ci/ciField.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7100
diff changeset
    32
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
// Predefined classes
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
class ciField;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
class ValueStack;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
class InstructionPrinter;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
class IRScope;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
class LIR_OprDesc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
typedef LIR_OprDesc* LIR_Opr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
// Instruction class hierarchy
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
// All leaf classes in the class hierarchy are concrete classes
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
// (i.e., are instantiated). All other classes are abstract and
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
// serve factoring.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
class Instruction;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
class   Phi;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
class   Local;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
class   Constant;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
class   AccessField;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
class     LoadField;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
class     StoreField;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
class   AccessArray;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
class     ArrayLength;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
class     AccessIndexed;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
class       LoadIndexed;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
class       StoreIndexed;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
class   NegateOp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
class   Op2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
class     ArithmeticOp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
class     ShiftOp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
class     LogicOp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
class     CompareOp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
class     IfOp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
class   Convert;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
class   NullCheck;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
class   OsrEntry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
class   ExceptionObject;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
class   StateSplit;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
class     Invoke;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
class     NewInstance;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
class     NewArray;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
class       NewTypeArray;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
class       NewObjectArray;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
class       NewMultiArray;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
class     TypeCheck;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
class       CheckCast;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
class       InstanceOf;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
class     AccessMonitor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
class       MonitorEnter;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
class       MonitorExit;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
class     Intrinsic;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
class     BlockBegin;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
class     BlockEnd;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
class       Goto;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
class       If;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
class       IfInstanceOf;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
class       Switch;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
class         TableSwitch;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
class         LookupSwitch;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
class       Return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
class       Throw;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
class       Base;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
class   RoundFP;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
class   UnsafeOp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
class     UnsafeRawOp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
class       UnsafeGetRaw;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
class       UnsafePutRaw;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
class     UnsafeObjectOp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
class       UnsafeGetObject;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
class       UnsafePutObject;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
class       UnsafePrefetch;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
class         UnsafePrefetchRead;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
class         UnsafePrefetchWrite;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
class   ProfileCall;
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
   108
class   ProfileInvoke;
8065
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
   109
class   RuntimeCall;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
// A Value is a reference to the instruction creating the value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
typedef Instruction* Value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
define_array(ValueArray, Value)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
define_stack(Values, ValueArray)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
define_array(ValueStackArray, ValueStack*)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
define_stack(ValueStackStack, ValueStackArray)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
// BlockClosure is the base class for block traversal/iteration.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
class BlockClosure: public CompilationResourceObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  virtual void block_do(BlockBegin* block)       = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   127
// A simple closure class for visiting the values of an Instruction
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   128
class ValueVisitor: public StackObj {
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   129
 public:
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   130
  virtual void visit(Value* v) = 0;
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   131
};
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   132
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   133
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
// Some array and list classes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
define_array(BlockBeginArray, BlockBegin*)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
define_stack(_BlockList, BlockBeginArray)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
class BlockList: public _BlockList {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  BlockList(): _BlockList() {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
  BlockList(const int size): _BlockList(size) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  BlockList(const int size, BlockBegin* init): _BlockList(size, init) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  void iterate_forward(BlockClosure* closure);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  void iterate_backward(BlockClosure* closure);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  void blocks_do(void f(BlockBegin*));
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   147
  void values_do(ValueVisitor* f);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  void print(bool cfg_only = false, bool live_only = false) PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
// InstructionVisitors provide type-based dispatch for instructions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
// For each concrete Instruction class X, a virtual function do_X is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
// provided. Functionality that needs to be implemented for all classes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
// (e.g., printing, code generation) is factored out into a specialised
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
// visitor instead of added to the Instruction classes itself.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
class InstructionVisitor: public StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  virtual void do_Phi            (Phi*             x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  virtual void do_Local          (Local*           x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  virtual void do_Constant       (Constant*        x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  virtual void do_LoadField      (LoadField*       x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  virtual void do_StoreField     (StoreField*      x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  virtual void do_ArrayLength    (ArrayLength*     x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
  virtual void do_LoadIndexed    (LoadIndexed*     x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
  virtual void do_StoreIndexed   (StoreIndexed*    x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  virtual void do_NegateOp       (NegateOp*        x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
  virtual void do_ArithmeticOp   (ArithmeticOp*    x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
  virtual void do_ShiftOp        (ShiftOp*         x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  virtual void do_LogicOp        (LogicOp*         x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  virtual void do_CompareOp      (CompareOp*       x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  virtual void do_IfOp           (IfOp*            x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  virtual void do_Convert        (Convert*         x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  virtual void do_NullCheck      (NullCheck*       x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  virtual void do_Invoke         (Invoke*          x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  virtual void do_NewInstance    (NewInstance*     x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  virtual void do_NewTypeArray   (NewTypeArray*    x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  virtual void do_NewObjectArray (NewObjectArray*  x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  virtual void do_NewMultiArray  (NewMultiArray*   x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  virtual void do_CheckCast      (CheckCast*       x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  virtual void do_InstanceOf     (InstanceOf*      x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  virtual void do_MonitorEnter   (MonitorEnter*    x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  virtual void do_MonitorExit    (MonitorExit*     x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
  virtual void do_Intrinsic      (Intrinsic*       x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
  virtual void do_BlockBegin     (BlockBegin*      x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  virtual void do_Goto           (Goto*            x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  virtual void do_If             (If*              x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
  virtual void do_IfInstanceOf   (IfInstanceOf*    x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  virtual void do_TableSwitch    (TableSwitch*     x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  virtual void do_LookupSwitch   (LookupSwitch*    x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  virtual void do_Return         (Return*          x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  virtual void do_Throw          (Throw*           x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  virtual void do_Base           (Base*            x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  virtual void do_OsrEntry       (OsrEntry*        x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
  virtual void do_ExceptionObject(ExceptionObject* x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  virtual void do_RoundFP        (RoundFP*         x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  virtual void do_UnsafeGetRaw   (UnsafeGetRaw*    x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  virtual void do_UnsafePutRaw   (UnsafePutRaw*    x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
  virtual void do_UnsafeGetObject(UnsafeGetObject* x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  virtual void do_UnsafePutObject(UnsafePutObject* x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
  virtual void do_UnsafePrefetchRead (UnsafePrefetchRead*  x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
  virtual void do_UnsafePrefetchWrite(UnsafePrefetchWrite* x) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  virtual void do_ProfileCall    (ProfileCall*     x) = 0;
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
   205
  virtual void do_ProfileInvoke  (ProfileInvoke*   x) = 0;
8065
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
   206
  virtual void do_RuntimeCall    (RuntimeCall*     x) = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
// Hashing support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
// Note: This hash functions affect the performance
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
//       of ValueMap - make changes carefully!
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
#define HASH1(x1            )                    ((intx)(x1))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
#define HASH2(x1, x2        )                    ((HASH1(x1        ) << 7) ^ HASH1(x2))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
#define HASH3(x1, x2, x3    )                    ((HASH2(x1, x2    ) << 7) ^ HASH1(x3))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
#define HASH4(x1, x2, x3, x4)                    ((HASH3(x1, x2, x3) << 7) ^ HASH1(x4))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
// The following macros are used to implement instruction-specific hashing.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
// By default, each instruction implements hash() and is_equal(Value), used
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
// for value numbering/common subexpression elimination. The default imple-
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
// mentation disables value numbering. Each instruction which can be value-
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
// numbered, should define corresponding hash() and is_equal(Value) functions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
// via the macros below. The f arguments specify all the values/op codes, etc.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
// that need to be identical for two instructions to be identical.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
// Note: The default implementation of hash() returns 0 in order to indicate
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
//       that the instruction should not be considered for value numbering.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
//       The currently used hash functions do not guarantee that never a 0
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
//       is produced. While this is still correct, it may be a performance
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
//       bug (no value numbering for that node). However, this situation is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
//       so unlikely, that we are not going to handle it specially.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
#define HASHING1(class_name, enabled, f1)             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
  virtual intx hash() const {                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
    return (enabled) ? HASH2(name(), f1) : 0;         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  }                                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
  virtual bool is_equal(Value v) const {              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
    if (!(enabled)  ) return false;                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
    class_name* _v = v->as_##class_name();            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
    if (_v == NULL  ) return false;                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
    if (f1 != _v->f1) return false;                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
    return true;                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
  }                                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
#define HASHING2(class_name, enabled, f1, f2)         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
  virtual intx hash() const {                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
    return (enabled) ? HASH3(name(), f1, f2) : 0;     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
  }                                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
  virtual bool is_equal(Value v) const {              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
    if (!(enabled)  ) return false;                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
    class_name* _v = v->as_##class_name();            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
    if (_v == NULL  ) return false;                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
    if (f1 != _v->f1) return false;                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
    if (f2 != _v->f2) return false;                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
    return true;                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
  }                                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
#define HASHING3(class_name, enabled, f1, f2, f3)     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
  virtual intx hash() const {                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
    return (enabled) ? HASH4(name(), f1, f2, f3) : 0; \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
  }                                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
  virtual bool is_equal(Value v) const {              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
    if (!(enabled)  ) return false;                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
    class_name* _v = v->as_##class_name();            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
    if (_v == NULL  ) return false;                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
    if (f1 != _v->f1) return false;                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
    if (f2 != _v->f2) return false;                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
    if (f3 != _v->f3) return false;                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
    return true;                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
  }                                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
// The mother of all instructions...
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
class Instruction: public CompilationResourceObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
  int          _id;                              // the unique instruction id
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   283
#ifndef PRODUCT
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   284
  int          _printable_bci;                   // the bci of the instruction for printing
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   285
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
  int          _use_count;                       // the number of instructions refering to this value (w/o prev/next); only roots can have use count = 0 or > 1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
  int          _pin_state;                       // set of PinReason describing the reason for pinning
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
  ValueType*   _type;                            // the instruction value type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
  Instruction* _next;                            // the next instruction if any (NULL for BlockEnd instructions)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
  Instruction* _subst;                           // the substitution instruction if any
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
  LIR_Opr      _operand;                         // LIR specific information
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
  unsigned int _flags;                           // Flag bits
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   294
  ValueStack*  _state_before;                    // Copy of state with input operands still on stack (or NULL)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   295
  ValueStack*  _exception_state;                 // Copy of state for exception handling
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
  XHandlers*   _exception_handlers;              // Flat list of exception handlers covering this instruction
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
  friend class UseCountComputer;
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   299
  friend class BlockBegin;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   301
  void update_exception_state(ValueStack* state);
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   302
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   303
  bool has_printable_bci() const                 { return NOT_PRODUCT(_printable_bci != -99) PRODUCT_ONLY(false); }
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   304
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  void set_type(ValueType* type) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
    assert(type != NULL, "type must exist");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
    _type = type;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
 public:
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   312
  void* operator new(size_t size) {
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   313
    Compilation* c = Compilation::current();
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   314
    void* res = c->arena()->Amalloc(size);
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   315
    ((Instruction*)res)->_id = c->get_next_id();
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   316
    return res;
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   317
  }
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   318
8107
78e5bd944384 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 8065
diff changeset
   319
  static const int no_bci = -99;
78e5bd944384 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 8065
diff changeset
   320
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  enum InstructionFlag {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
    NeedsNullCheckFlag = 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
    CanTrapFlag,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
    DirectCompareFlag,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
    IsEliminatedFlag,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
    IsSafepointFlag,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
    IsStaticFlag,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
    IsStrictfpFlag,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
    NeedsStoreCheckFlag,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
    NeedsWriteBarrierFlag,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
    PreservesStateFlag,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
    TargetIsFinalFlag,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
    TargetIsLoadedFlag,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
    TargetIsStrictfpFlag,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
    UnorderedIsTrueFlag,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
    NeedsPatchingFlag,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
    ThrowIncompatibleClassChangeErrorFlag,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
    ProfileMDOFlag,
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   339
    IsLinkedInBlockFlag,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
    InstructionLastFlag
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  bool check_flag(InstructionFlag id) const      { return (_flags & (1 << id)) != 0;    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  void set_flag(InstructionFlag id, bool f)      { _flags = f ? (_flags | (1 << id)) : (_flags & ~(1 << id)); };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
  // 'globally' used condition values
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
  enum Condition {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
    eql, neq, lss, leq, gtr, geq
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
  // Instructions may be pinned for many reasons and under certain conditions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
  // with enough knowledge it's possible to safely unpin them.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
  enum PinReason {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
      PinUnknown           = 1 << 0
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
    , PinExplicitNullCheck = 1 << 3
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
    , PinStackForStateSplit= 1 << 12
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
    , PinStateSplitConstructor= 1 << 13
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
    , PinGlobalValueNumbering= 1 << 14
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
  static Condition mirror(Condition cond);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
  static Condition negate(Condition cond);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
  // initialization
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   366
  static int number_of_instructions() {
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   367
    return Compilation::current()->number_of_instructions();
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   368
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
  // creation
6750
b84813b41757 6988303: 6986046 breaks build with recent gcc
roland
parents: 6745
diff changeset
   371
  Instruction(ValueType* type, ValueStack* state_before = NULL, bool type_is_constant = false)
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   372
  : _use_count(0)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   373
#ifndef PRODUCT
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   374
  , _printable_bci(-99)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   375
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
  , _pin_state(0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
  , _type(type)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
  , _next(NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
  , _subst(NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
  , _flags(0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
  , _operand(LIR_OprFact::illegalOpr)
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   382
  , _state_before(state_before)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
  , _exception_handlers(NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
  {
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   385
    check_state(state_before);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
    assert(type != NULL && (!type->is_constant() || type_is_constant), "type must exist");
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   387
    update_exception_state(_state_before);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  int id() const                                 { return _id; }
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   392
#ifndef PRODUCT
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   393
  int printable_bci() const                      { assert(has_printable_bci(), "_printable_bci should have been set"); return _printable_bci; }
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   394
  void set_printable_bci(int bci)                { NOT_PRODUCT(_printable_bci = bci;) }
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   395
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
  int use_count() const                          { return _use_count; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
  int pin_state() const                          { return _pin_state; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  bool is_pinned() const                         { return _pin_state != 0 || PinAllInstructions; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
  ValueType* type() const                        { return _type; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
  Instruction* prev(BlockBegin* block);          // use carefully, expensive operation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
  Instruction* next() const                      { return _next; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
  bool has_subst() const                         { return _subst != NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
  Instruction* subst()                           { return _subst == NULL ? this : _subst->subst(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
  LIR_Opr operand() const                        { return _operand; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
  void set_needs_null_check(bool f)              { set_flag(NeedsNullCheckFlag, f); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
  bool needs_null_check() const                  { return check_flag(NeedsNullCheckFlag); }
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   408
  bool is_linked() const                         { return check_flag(IsLinkedInBlockFlag); }
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   409
  bool can_be_linked()                           { return as_Local() == NULL && as_Phi() == NULL; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
  bool has_uses() const                          { return use_count() > 0; }
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   412
  ValueStack* state_before() const               { return _state_before; }
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   413
  ValueStack* exception_state() const            { return _exception_state; }
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   414
  virtual bool needs_exception_state() const     { return true; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
  XHandlers* exception_handlers() const          { return _exception_handlers; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  // manipulation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
  void pin(PinReason reason)                     { _pin_state |= reason; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
  void pin()                                     { _pin_state |= PinUnknown; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
  // DANGEROUS: only used by EliminateStores
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
  void unpin(PinReason reason)                   { assert((reason & PinUnknown) == 0, "can't unpin unknown state"); _pin_state &= ~reason; }
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   422
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   423
  Instruction* set_next(Instruction* next) {
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   424
    assert(next->has_printable_bci(), "_printable_bci should have been set");
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   425
    assert(next != NULL, "must not be NULL");
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   426
    assert(as_BlockEnd() == NULL, "BlockEnd instructions must have no next");
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   427
    assert(next->can_be_linked(), "shouldn't link these instructions into list");
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   428
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   429
    next->set_flag(Instruction::IsLinkedInBlockFlag, true);
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   430
    _next = next;
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   431
    return next;
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   432
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
  Instruction* set_next(Instruction* next, int bci) {
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   435
#ifndef PRODUCT
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   436
    next->set_printable_bci(bci);
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   437
#endif
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   438
    return set_next(next);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
  void set_subst(Instruction* subst)             {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
    assert(subst == NULL ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
           type()->base() == subst->type()->base() ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
           subst->type()->base() == illegalType, "type can't change");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
    _subst = subst;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  void set_exception_handlers(XHandlers *xhandlers) { _exception_handlers = xhandlers; }
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   448
  void set_exception_state(ValueStack* s)        { check_state(s); _exception_state = s; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
  // machine-specifics
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
  void set_operand(LIR_Opr operand)              { assert(operand != LIR_OprFact::illegalOpr, "operand must exist"); _operand = operand; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
  void clear_operand()                           { _operand = LIR_OprFact::illegalOpr; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
  // generic
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
  virtual Instruction*      as_Instruction()     { return this; } // to satisfy HASHING1 macro
7100
6bcf9255d470 6991577: add IfOp optimization to C1
roland
parents: 6751
diff changeset
   456
  virtual Phi*              as_Phi()             { return NULL; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
  virtual Local*            as_Local()           { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
  virtual Constant*         as_Constant()        { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
  virtual AccessField*      as_AccessField()     { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
  virtual LoadField*        as_LoadField()       { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
  virtual StoreField*       as_StoreField()      { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
  virtual AccessArray*      as_AccessArray()     { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
  virtual ArrayLength*      as_ArrayLength()     { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
  virtual AccessIndexed*    as_AccessIndexed()   { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
  virtual LoadIndexed*      as_LoadIndexed()     { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
  virtual StoreIndexed*     as_StoreIndexed()    { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
  virtual NegateOp*         as_NegateOp()        { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
  virtual Op2*              as_Op2()             { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
  virtual ArithmeticOp*     as_ArithmeticOp()    { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
  virtual ShiftOp*          as_ShiftOp()         { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
  virtual LogicOp*          as_LogicOp()         { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
  virtual CompareOp*        as_CompareOp()       { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
  virtual IfOp*             as_IfOp()            { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
  virtual Convert*          as_Convert()         { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
  virtual NullCheck*        as_NullCheck()       { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
  virtual OsrEntry*         as_OsrEntry()        { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
  virtual StateSplit*       as_StateSplit()      { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
  virtual Invoke*           as_Invoke()          { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
  virtual NewInstance*      as_NewInstance()     { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
  virtual NewArray*         as_NewArray()        { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
  virtual NewTypeArray*     as_NewTypeArray()    { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
  virtual NewObjectArray*   as_NewObjectArray()  { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
  virtual NewMultiArray*    as_NewMultiArray()   { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
  virtual TypeCheck*        as_TypeCheck()       { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  virtual CheckCast*        as_CheckCast()       { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
  virtual InstanceOf*       as_InstanceOf()      { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
  virtual AccessMonitor*    as_AccessMonitor()   { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
  virtual MonitorEnter*     as_MonitorEnter()    { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
  virtual MonitorExit*      as_MonitorExit()     { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
  virtual Intrinsic*        as_Intrinsic()       { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
  virtual BlockBegin*       as_BlockBegin()      { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
  virtual BlockEnd*         as_BlockEnd()        { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
  virtual Goto*             as_Goto()            { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
  virtual If*               as_If()              { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
  virtual IfInstanceOf*     as_IfInstanceOf()    { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
  virtual TableSwitch*      as_TableSwitch()     { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
  virtual LookupSwitch*     as_LookupSwitch()    { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
  virtual Return*           as_Return()          { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
  virtual Throw*            as_Throw()           { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
  virtual Base*             as_Base()            { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
  virtual RoundFP*          as_RoundFP()         { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
  virtual ExceptionObject*  as_ExceptionObject() { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
  virtual UnsafeOp*         as_UnsafeOp()        { return NULL; }
11192
ff37c2093a0d 7112085: assert(fr.interpreter_frame_expression_stack_size()==0) failed: only handle empty stacks
iveresov
parents: 10509
diff changeset
   504
  virtual ProfileInvoke*    as_ProfileInvoke()   { return NULL; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
  virtual void visit(InstructionVisitor* v)      = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
  virtual bool can_trap() const                  { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   510
  virtual void input_values_do(ValueVisitor* f)   = 0;
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   511
  virtual void state_values_do(ValueVisitor* f);
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   512
  virtual void other_values_do(ValueVisitor* f)   { /* usually no other - override on demand */ }
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   513
          void       values_do(ValueVisitor* f)   { input_values_do(f); state_values_do(f); other_values_do(f); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
  virtual ciType* exact_type() const             { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
  virtual ciType* declared_type() const          { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
  // hashing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
  virtual const char* name() const               = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
  HASHING1(Instruction, false, id())             // hashing disabled by default
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
  // debugging
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   523
  static void check_state(ValueStack* state)     PRODUCT_RETURN;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
  void print()                                   PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
  void print_line()                              PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
  void print(InstructionPrinter& ip)             PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
// The following macros are used to define base (i.e., non-leaf)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
// and leaf instruction classes. They define class-name related
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
// generic functionality in one place.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
#define BASE(class_name, super_class_name)       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
  class class_name: public super_class_name {    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
   public:                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
    virtual class_name* as_##class_name()        { return this; }              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
#define LEAF(class_name, super_class_name)       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
  BASE(class_name, super_class_name)             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
   public:                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
    virtual const char* name() const             { return #class_name; }       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
    virtual void visit(InstructionVisitor* v)    { v->do_##class_name(this); } \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
// Debugging support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   549
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
#ifdef ASSERT
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   551
class AssertValues: public ValueVisitor {
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   552
  void visit(Value* x)             { assert((*x) != NULL, "value must exist"); }
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   553
};
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   554
  #define ASSERT_VALUES                          { AssertValues assert_value; values_do(&assert_value); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  #define ASSERT_VALUES
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
#endif // ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
// A Phi is a phi function in the sense of SSA form. It stands for
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
// the value of a local variable at the beginning of a join block.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
// A Phi consists of n operands, one for every incoming branch.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
LEAF(Phi, Instruction)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
  BlockBegin* _block;    // the block to which the phi function belongs
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
  int         _pf_flags; // the flags of the phi function
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
  int         _index;    // to value on operand stack (index < 0) or to local
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
  // creation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
  Phi(ValueType* type, BlockBegin* b, int index)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
  : Instruction(type->base())
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
  , _pf_flags(0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
  , _block(b)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
  , _index(index)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
    if (type->is_illegal()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
      make_illegal();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
  // flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
  enum Flag {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
    no_flag         = 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
    visited         = 1 << 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
    cannot_simplify = 1 << 1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
  bool  is_local() const          { return _index >= 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
  bool  is_on_stack() const       { return !is_local(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
  int   local_index() const       { assert(is_local(), ""); return _index; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
  int   stack_index() const       { assert(is_on_stack(), ""); return -(_index+1); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
  Value operand_at(int i) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
  int   operand_count() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
  BlockBegin* block() const       { return _block; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
  void   set(Flag f)              { _pf_flags |=  f; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
  void   clear(Flag f)            { _pf_flags &= ~f; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
  bool   is_set(Flag f) const     { return (_pf_flags & f) != 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
  // Invalidates phis corresponding to merges of locals of two different types
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
  // (these should never be referenced, otherwise the bytecodes are illegal)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
  void   make_illegal() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
    set(cannot_simplify);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
    set_type(illegalType);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
  bool is_illegal() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
    return type()->is_illegal();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
  // generic
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   616
  virtual void input_values_do(ValueVisitor* f) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
// A local is a placeholder for an incoming argument to a function call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
LEAF(Local, Instruction)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
  int      _java_index;                          // the local index within the method to which the local belongs
9102
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
   625
  ciType*  _declared_type;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
  // creation
9102
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
   628
  Local(ciType* declared, ValueType* type, int index)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
    : Instruction(type)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
    , _java_index(index)
9102
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
   631
    , _declared_type(declared)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
  {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
  int java_index() const                         { return _java_index; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
9102
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
   637
  ciType* declared_type() const                  { return _declared_type; }
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
   638
  ciType* exact_type() const;
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
   639
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
  // generic
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   641
  virtual void input_values_do(ValueVisitor* f)   { /* no values */ }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
LEAF(Constant, Instruction)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
  // creation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
  Constant(ValueType* type):
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   649
      Instruction(type, NULL, true)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   650
  {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
    assert(type->is_constant(), "must be a constant");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   654
  Constant(ValueType* type, ValueStack* state_before):
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   655
    Instruction(type, state_before, true)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   656
  {
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   657
    assert(state_before != NULL, "only used for constants which need patching");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
    assert(type->is_constant(), "must be a constant");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
    // since it's patching it needs to be pinned
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
    pin();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   663
  virtual bool can_trap() const                  { return state_before() != NULL; }
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   664
  virtual void input_values_do(ValueVisitor* f)   { /* no values */ }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
  virtual intx hash() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
  virtual bool is_equal(Value v) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
7100
6bcf9255d470 6991577: add IfOp optimization to C1
roland
parents: 6751
diff changeset
   669
6bcf9255d470 6991577: add IfOp optimization to C1
roland
parents: 6751
diff changeset
   670
  enum CompareResult { not_comparable = -1, cond_false, cond_true };
6bcf9255d470 6991577: add IfOp optimization to C1
roland
parents: 6751
diff changeset
   671
6bcf9255d470 6991577: add IfOp optimization to C1
roland
parents: 6751
diff changeset
   672
  virtual CompareResult compare(Instruction::Condition condition, Value right) const;
6bcf9255d470 6991577: add IfOp optimization to C1
roland
parents: 6751
diff changeset
   673
  BlockBegin* compare(Instruction::Condition cond, Value right,
6bcf9255d470 6991577: add IfOp optimization to C1
roland
parents: 6751
diff changeset
   674
                      BlockBegin* true_sux, BlockBegin* false_sux) const {
6bcf9255d470 6991577: add IfOp optimization to C1
roland
parents: 6751
diff changeset
   675
    switch (compare(cond, right)) {
6bcf9255d470 6991577: add IfOp optimization to C1
roland
parents: 6751
diff changeset
   676
    case not_comparable:
6bcf9255d470 6991577: add IfOp optimization to C1
roland
parents: 6751
diff changeset
   677
      return NULL;
6bcf9255d470 6991577: add IfOp optimization to C1
roland
parents: 6751
diff changeset
   678
    case cond_false:
6bcf9255d470 6991577: add IfOp optimization to C1
roland
parents: 6751
diff changeset
   679
      return false_sux;
6bcf9255d470 6991577: add IfOp optimization to C1
roland
parents: 6751
diff changeset
   680
    case cond_true:
6bcf9255d470 6991577: add IfOp optimization to C1
roland
parents: 6751
diff changeset
   681
      return true_sux;
6bcf9255d470 6991577: add IfOp optimization to C1
roland
parents: 6751
diff changeset
   682
    default:
6bcf9255d470 6991577: add IfOp optimization to C1
roland
parents: 6751
diff changeset
   683
      ShouldNotReachHere();
6bcf9255d470 6991577: add IfOp optimization to C1
roland
parents: 6751
diff changeset
   684
      return NULL;
6bcf9255d470 6991577: add IfOp optimization to C1
roland
parents: 6751
diff changeset
   685
    }
6bcf9255d470 6991577: add IfOp optimization to C1
roland
parents: 6751
diff changeset
   686
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
BASE(AccessField, Instruction)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
  Value       _obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
  int         _offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
  ciField*    _field;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
  NullCheck*  _explicit_null_check;              // For explicit null check elimination
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
  // creation
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   699
  AccessField(Value obj, int offset, ciField* field, bool is_static,
8671
13ffa40a2f0a 6965570: assert(!needs_patching && x->is_loaded(),"how do we know it's volatile if it's not loaded")
never
parents: 8107
diff changeset
   700
              ValueStack* state_before, bool needs_patching)
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   701
  : Instruction(as_ValueType(field->type()->basic_type()), state_before)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
  , _obj(obj)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
  , _offset(offset)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
  , _field(field)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
  , _explicit_null_check(NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
    set_needs_null_check(!is_static);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
    set_flag(IsStaticFlag, is_static);
8671
13ffa40a2f0a 6965570: assert(!needs_patching && x->is_loaded(),"how do we know it's volatile if it's not loaded")
never
parents: 8107
diff changeset
   709
    set_flag(NeedsPatchingFlag, needs_patching);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
    ASSERT_VALUES
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
    // pin of all instructions with memory access
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
    pin();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
  Value obj() const                              { return _obj; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
  int offset() const                             { return _offset; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
  ciField* field() const                         { return _field; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
  BasicType field_type() const                   { return _field->type()->basic_type(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
  bool is_static() const                         { return check_flag(IsStaticFlag); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
  NullCheck* explicit_null_check() const         { return _explicit_null_check; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
  bool needs_patching() const                    { return check_flag(NeedsPatchingFlag); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
8671
13ffa40a2f0a 6965570: assert(!needs_patching && x->is_loaded(),"how do we know it's volatile if it's not loaded")
never
parents: 8107
diff changeset
   724
  // Unresolved getstatic and putstatic can cause initialization.
13ffa40a2f0a 6965570: assert(!needs_patching && x->is_loaded(),"how do we know it's volatile if it's not loaded")
never
parents: 8107
diff changeset
   725
  // Technically it occurs at the Constant that materializes the base
13ffa40a2f0a 6965570: assert(!needs_patching && x->is_loaded(),"how do we know it's volatile if it's not loaded")
never
parents: 8107
diff changeset
   726
  // of the static fields but it's simpler to model it here.
13ffa40a2f0a 6965570: assert(!needs_patching && x->is_loaded(),"how do we know it's volatile if it's not loaded")
never
parents: 8107
diff changeset
   727
  bool is_init_point() const                     { return is_static() && (needs_patching() || !_field->holder()->is_initialized()); }
13ffa40a2f0a 6965570: assert(!needs_patching && x->is_loaded(),"how do we know it's volatile if it's not loaded")
never
parents: 8107
diff changeset
   728
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
  // manipulation
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   730
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
  // Under certain circumstances, if a previous NullCheck instruction
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
  // proved the target object non-null, we can eliminate the explicit
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
  // null check and do an implicit one, simply specifying the debug
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
  // information from the NullCheck. This field should only be consulted
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
  // if needs_null_check() is true.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
  void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
  // generic
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
  virtual bool can_trap() const                  { return needs_null_check() || needs_patching(); }
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   740
  virtual void input_values_do(ValueVisitor* f)   { f->visit(&_obj); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
LEAF(LoadField, AccessField)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
  // creation
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   747
  LoadField(Value obj, int offset, ciField* field, bool is_static,
8671
13ffa40a2f0a 6965570: assert(!needs_patching && x->is_loaded(),"how do we know it's volatile if it's not loaded")
never
parents: 8107
diff changeset
   748
            ValueStack* state_before, bool needs_patching)
13ffa40a2f0a 6965570: assert(!needs_patching && x->is_loaded(),"how do we know it's volatile if it's not loaded")
never
parents: 8107
diff changeset
   749
  : AccessField(obj, offset, field, is_static, state_before, needs_patching)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
  {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
  ciType* declared_type() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
  ciType* exact_type() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
  // generic
8671
13ffa40a2f0a 6965570: assert(!needs_patching && x->is_loaded(),"how do we know it's volatile if it's not loaded")
never
parents: 8107
diff changeset
   756
  HASHING2(LoadField, !needs_patching() && !field()->is_volatile(), obj()->subst(), offset())  // cannot be eliminated if needs patching or if volatile
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
LEAF(StoreField, AccessField)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
  Value _value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
  // creation
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   766
  StoreField(Value obj, int offset, ciField* field, Value value, bool is_static,
8671
13ffa40a2f0a 6965570: assert(!needs_patching && x->is_loaded(),"how do we know it's volatile if it's not loaded")
never
parents: 8107
diff changeset
   767
             ValueStack* state_before, bool needs_patching)
13ffa40a2f0a 6965570: assert(!needs_patching && x->is_loaded(),"how do we know it's volatile if it's not loaded")
never
parents: 8107
diff changeset
   768
  : AccessField(obj, offset, field, is_static, state_before, needs_patching)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
  , _value(value)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
    set_flag(NeedsWriteBarrierFlag, as_ValueType(field_type())->is_object());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
    ASSERT_VALUES
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
    pin();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
  Value value() const                            { return _value; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
  bool needs_write_barrier() const               { return check_flag(NeedsWriteBarrierFlag); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
  // generic
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   781
  virtual void input_values_do(ValueVisitor* f)   { AccessField::input_values_do(f); f->visit(&_value); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
BASE(AccessArray, Instruction)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
  Value       _array;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
  // creation
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   791
  AccessArray(ValueType* type, Value array, ValueStack* state_before)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   792
  : Instruction(type, state_before)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
  , _array(array)
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   794
  {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
    set_needs_null_check(true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
    ASSERT_VALUES
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
    pin(); // instruction with side effect (null exception or range check throwing)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
  Value array() const                            { return _array; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
  // generic
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
  virtual bool can_trap() const                  { return needs_null_check(); }
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   804
  virtual void input_values_do(ValueVisitor* f)   { f->visit(&_array); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
LEAF(ArrayLength, AccessArray)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
  NullCheck*  _explicit_null_check;              // For explicit null check elimination
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
  // creation
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   814
  ArrayLength(Value array, ValueStack* state_before)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   815
  : AccessArray(intType, array, state_before)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
  , _explicit_null_check(NULL) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
  NullCheck* explicit_null_check() const         { return _explicit_null_check; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
  // setters
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
  // See LoadField::set_explicit_null_check for documentation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
  void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
  // generic
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
  HASHING1(ArrayLength, true, array()->subst())
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
BASE(AccessIndexed, AccessArray)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
  Value     _index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
  Value     _length;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
  BasicType _elt_type;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
  // creation
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   838
  AccessIndexed(Value array, Value index, Value length, BasicType elt_type, ValueStack* state_before)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   839
  : AccessArray(as_ValueType(elt_type), array, state_before)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
  , _index(index)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
  , _length(length)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
  , _elt_type(elt_type)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
    ASSERT_VALUES
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
  Value index() const                            { return _index; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
  Value length() const                           { return _length; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
  BasicType elt_type() const                     { return _elt_type; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
  // perform elimination of range checks involving constants
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
  bool compute_needs_range_check();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
  // generic
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   856
  virtual void input_values_do(ValueVisitor* f)   { AccessArray::input_values_do(f); f->visit(&_index); if (_length != NULL) f->visit(&_length); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
LEAF(LoadIndexed, AccessIndexed)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
  NullCheck*  _explicit_null_check;              // For explicit null check elimination
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
  // creation
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   866
  LoadIndexed(Value array, Value index, Value length, BasicType elt_type, ValueStack* state_before)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   867
  : AccessIndexed(array, index, length, elt_type, state_before)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
  , _explicit_null_check(NULL) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
  NullCheck* explicit_null_check() const         { return _explicit_null_check; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
  // setters
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
  // See LoadField::set_explicit_null_check for documentation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
  void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
  ciType* exact_type() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
  ciType* declared_type() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
  // generic
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
  HASHING2(LoadIndexed, true, array()->subst(), index()->subst())
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
LEAF(StoreIndexed, AccessIndexed)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
  Value       _value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
6461
cfc616b49f58 6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents: 6453
diff changeset
   889
  ciMethod* _profiled_method;
cfc616b49f58 6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents: 6453
diff changeset
   890
  int       _profiled_bci;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
  // creation
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   893
  StoreIndexed(Value array, Value index, Value length, BasicType elt_type, Value value, ValueStack* state_before)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   894
  : AccessIndexed(array, index, length, elt_type, state_before)
6461
cfc616b49f58 6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents: 6453
diff changeset
   895
  , _value(value), _profiled_method(NULL), _profiled_bci(0)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
    set_flag(NeedsWriteBarrierFlag, (as_ValueType(elt_type)->is_object()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
    set_flag(NeedsStoreCheckFlag, (as_ValueType(elt_type)->is_object()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
    ASSERT_VALUES
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
    pin();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
  Value value() const                            { return _value; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
  bool needs_write_barrier() const               { return check_flag(NeedsWriteBarrierFlag); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
  bool needs_store_check() const                 { return check_flag(NeedsStoreCheckFlag); }
6461
cfc616b49f58 6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents: 6453
diff changeset
   907
  // Helpers for methodDataOop profiling
cfc616b49f58 6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents: 6453
diff changeset
   908
  void set_should_profile(bool value)                { set_flag(ProfileMDOFlag, value); }
cfc616b49f58 6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents: 6453
diff changeset
   909
  void set_profiled_method(ciMethod* method)         { _profiled_method = method;   }
cfc616b49f58 6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents: 6453
diff changeset
   910
  void set_profiled_bci(int bci)                     { _profiled_bci = bci;         }
cfc616b49f58 6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents: 6453
diff changeset
   911
  bool      should_profile() const                   { return check_flag(ProfileMDOFlag); }
cfc616b49f58 6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents: 6453
diff changeset
   912
  ciMethod* profiled_method() const                  { return _profiled_method;     }
cfc616b49f58 6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents: 6453
diff changeset
   913
  int       profiled_bci() const                     { return _profiled_bci;        }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
  // generic
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   915
  virtual void input_values_do(ValueVisitor* f)   { AccessIndexed::input_values_do(f); f->visit(&_value); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
489c9b5090e2 Initial load
duke
parents:
diff changeset
   919
LEAF(NegateOp, Instruction)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
  Value _x;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
  // creation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
  NegateOp(Value x) : Instruction(x->type()->base()), _x(x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
    ASSERT_VALUES
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
  Value x() const                                { return _x; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
  // generic
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   933
  virtual void input_values_do(ValueVisitor* f)   { f->visit(&_x); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
489c9b5090e2 Initial load
duke
parents:
diff changeset
   937
BASE(Op2, Instruction)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   938
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   939
  Bytecodes::Code _op;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
  Value           _x;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
  Value           _y;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   944
  // creation
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   945
  Op2(ValueType* type, Bytecodes::Code op, Value x, Value y, ValueStack* state_before = NULL)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   946
  : Instruction(type, state_before)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   947
  , _op(op)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   948
  , _x(x)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   949
  , _y(y)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   950
  {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
    ASSERT_VALUES
489c9b5090e2 Initial load
duke
parents:
diff changeset
   952
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   953
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   955
  Bytecodes::Code op() const                     { return _op; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   956
  Value x() const                                { return _x; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
  Value y() const                                { return _y; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
  // manipulators
489c9b5090e2 Initial load
duke
parents:
diff changeset
   960
  void swap_operands() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
    assert(is_commutative(), "operation must be commutative");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
    Value t = _x; _x = _y; _y = t;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
  // generic
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
  virtual bool is_commutative() const            { return false; }
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
   967
  virtual void input_values_do(ValueVisitor* f)   { f->visit(&_x); f->visit(&_y); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
LEAF(ArithmeticOp, Op2)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
  // creation
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   974
  ArithmeticOp(Bytecodes::Code op, Value x, Value y, bool is_strictfp, ValueStack* state_before)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   975
  : Op2(x->type()->meet(y->type()), op, x, y, state_before)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
   976
  {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
    set_flag(IsStrictfpFlag, is_strictfp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
    if (can_trap()) pin();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
  bool        is_strictfp() const                { return check_flag(IsStrictfpFlag); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
  // generic
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
  virtual bool is_commutative() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
  virtual bool can_trap() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
  HASHING3(Op2, true, op(), x()->subst(), y()->subst())
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
LEAF(ShiftOp, Op2)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
  // creation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
  ShiftOp(Bytecodes::Code op, Value x, Value s) : Op2(x->type()->base(), op, x, s) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
  // generic
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
  HASHING3(Op2, true, op(), x()->subst(), y()->subst())
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
LEAF(LogicOp, Op2)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
  // creation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
  LogicOp(Bytecodes::Code op, Value x, Value y) : Op2(x->type()->meet(y->type()), op, x, y) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
  // generic
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
  virtual bool is_commutative() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
  HASHING3(Op2, true, op(), x()->subst(), y()->subst())
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
LEAF(CompareOp, Op2)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
  // creation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1015
  CompareOp(Bytecodes::Code op, Value x, Value y, ValueStack* state_before)
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1016
  : Op2(intType, op, x, y, state_before)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
  {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
  // generic
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1020
  HASHING3(Op2, true, op(), x()->subst(), y()->subst())
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1021
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
LEAF(IfOp, Op2)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
  Value _tval;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
  Value _fval;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
  // creation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
  IfOp(Value x, Condition cond, Value y, Value tval, Value fval)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
  : Op2(tval->type()->meet(fval->type()), (Bytecodes::Code)cond, x, y)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
  , _tval(tval)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
  , _fval(fval)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
    ASSERT_VALUES
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
    assert(tval->type()->tag() == fval->type()->tag(), "types must match");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
  virtual bool is_commutative() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
  Bytecodes::Code op() const                     { ShouldNotCallThis(); return Bytecodes::_illegal; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1043
  Condition cond() const                         { return (Condition)Op2::op(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
  Value tval() const                             { return _tval; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
  Value fval() const                             { return _fval; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1046
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1047
  // generic
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1048
  virtual void input_values_do(ValueVisitor* f)   { Op2::input_values_do(f); f->visit(&_tval); f->visit(&_fval); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1049
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1050
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1051
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
LEAF(Convert, Instruction)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1054
  Bytecodes::Code _op;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1055
  Value           _value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1056
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
  // creation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
  Convert(Bytecodes::Code op, Value value, ValueType* to_type) : Instruction(to_type), _op(op), _value(value) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
    ASSERT_VALUES
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
  Bytecodes::Code op() const                     { return _op; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1065
  Value value() const                            { return _value; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1067
  // generic
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1068
  virtual void input_values_do(ValueVisitor* f)   { f->visit(&_value); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1069
  HASHING2(Convert, true, op(), value()->subst())
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1070
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1071
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1072
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1073
LEAF(NullCheck, Instruction)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1074
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
  Value       _obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1077
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
  // creation
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1079
  NullCheck(Value obj, ValueStack* state_before)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1080
  : Instruction(obj->type()->base(), state_before)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1081
  , _obj(obj)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1082
  {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1083
    ASSERT_VALUES
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1084
    set_can_trap(true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1085
    assert(_obj->type()->is_object(), "null check must be applied to objects only");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1086
    pin(Instruction::PinExplicitNullCheck);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1087
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1089
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
  Value obj() const                              { return _obj; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
  // setters
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
  void set_can_trap(bool can_trap)               { set_flag(CanTrapFlag, can_trap); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1095
  // generic
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1096
  virtual bool can_trap() const                  { return check_flag(CanTrapFlag); /* null-check elimination sets to false */ }
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1097
  virtual void input_values_do(ValueVisitor* f)   { f->visit(&_obj); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1098
  HASHING1(NullCheck, true, obj()->subst())
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1099
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1100
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1101
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1102
BASE(StateSplit, Instruction)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1103
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1104
  ValueStack* _state;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1105
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1106
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
  static void substitute(BlockList& list, BlockBegin* old_block, BlockBegin* new_block);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1108
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1109
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1110
  // creation
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1111
  StateSplit(ValueType* type, ValueStack* state_before = NULL)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1112
  : Instruction(type, state_before)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1113
  , _state(NULL)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1114
  {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1115
    pin(PinStateSplitConstructor);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1116
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1117
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1118
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1119
  ValueStack* state() const                      { return _state; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1120
  IRScope* scope() const;                        // the state's scope
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1121
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1122
  // manipulation
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1123
  void set_state(ValueStack* state)              { assert(_state == NULL, "overwriting existing state"); check_state(state); _state = state; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1124
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1125
  // generic
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1126
  virtual void input_values_do(ValueVisitor* f)   { /* no values */ }
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1127
  virtual void state_values_do(ValueVisitor* f);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1128
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1129
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1130
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1131
LEAF(Invoke, StateSplit)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1132
 private:
5046
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 1
diff changeset
  1133
  Bytecodes::Code _code;
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 1
diff changeset
  1134
  Value           _recv;
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 1
diff changeset
  1135
  Values*         _args;
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 1
diff changeset
  1136
  BasicTypeList*  _signature;
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 1
diff changeset
  1137
  int             _vtable_index;
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 1
diff changeset
  1138
  ciMethod*       _target;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1139
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1140
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1141
  // creation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1142
  Invoke(Bytecodes::Code code, ValueType* result_type, Value recv, Values* args,
5046
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 1
diff changeset
  1143
         int vtable_index, ciMethod* target, ValueStack* state_before);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1144
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1145
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1146
  Bytecodes::Code code() const                   { return _code; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1147
  Value receiver() const                         { return _recv; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1148
  bool has_receiver() const                      { return receiver() != NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1149
  int number_of_arguments() const                { return _args->length(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1150
  Value argument_at(int i) const                 { return _args->at(i); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1151
  int vtable_index() const                       { return _vtable_index; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1152
  BasicTypeList* signature() const               { return _signature; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1153
  ciMethod* target() const                       { return _target; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1154
9102
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
  1155
  ciType* declared_type() const;
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
  1156
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1157
  // Returns false if target is not loaded
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1158
  bool target_is_final() const                   { return check_flag(TargetIsFinalFlag); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1159
  bool target_is_loaded() const                  { return check_flag(TargetIsLoadedFlag); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1160
  // Returns false if target is not loaded
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1161
  bool target_is_strictfp() const                { return check_flag(TargetIsStrictfpFlag); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1162
5046
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 1
diff changeset
  1163
  // JSR 292 support
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 1
diff changeset
  1164
  bool is_invokedynamic() const                  { return code() == Bytecodes::_invokedynamic; }
27e801a857cb 6919934: JSR 292 needs to support x86 C1
twisti
parents: 1
diff changeset
  1165
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1166
  virtual bool needs_exception_state() const     { return false; }
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1167
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1168
  // generic
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1169
  virtual bool can_trap() const                  { return true; }
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1170
  virtual void input_values_do(ValueVisitor* f) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1171
    StateSplit::input_values_do(f);
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1172
    if (has_receiver()) f->visit(&_recv);
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1173
    for (int i = 0; i < _args->length(); i++) f->visit(_args->adr_at(i));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1174
  }
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1175
  virtual void state_values_do(ValueVisitor *f);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1176
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1177
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1178
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1179
LEAF(NewInstance, StateSplit)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1180
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1181
  ciInstanceKlass* _klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1182
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1183
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1184
  // creation
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1185
  NewInstance(ciInstanceKlass* klass, ValueStack* state_before)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1186
  : StateSplit(instanceType, state_before)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1187
  , _klass(klass)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1188
  {}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1189
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1190
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1191
  ciInstanceKlass* klass() const                 { return _klass; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1192
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1193
  virtual bool needs_exception_state() const     { return false; }
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1194
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1195
  // generic
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1196
  virtual bool can_trap() const                  { return true; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1197
  ciType* exact_type() const;
9102
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
  1198
  ciType* declared_type() const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1199
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1200
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1201
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1202
BASE(NewArray, StateSplit)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1203
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1204
  Value       _length;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1205
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1206
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1207
  // creation
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1208
  NewArray(Value length, ValueStack* state_before)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1209
  : StateSplit(objectType, state_before)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1210
  , _length(length)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1211
  {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1212
    // Do not ASSERT_VALUES since length is NULL for NewMultiArray
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1213
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1214
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1215
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1216
  Value length() const                           { return _length; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1217
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1218
  virtual bool needs_exception_state() const     { return false; }
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1219
9102
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
  1220
  ciType* declared_type() const;
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
  1221
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1222
  // generic
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1223
  virtual bool can_trap() const                  { return true; }
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1224
  virtual void input_values_do(ValueVisitor* f)   { StateSplit::input_values_do(f); f->visit(&_length); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1225
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1226
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1227
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1228
LEAF(NewTypeArray, NewArray)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1229
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1230
  BasicType _elt_type;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1231
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1232
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1233
  // creation
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1234
  NewTypeArray(Value length, BasicType elt_type, ValueStack* state_before)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1235
  : NewArray(length, state_before)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1236
  , _elt_type(elt_type)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1237
  {}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1238
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1239
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1240
  BasicType elt_type() const                     { return _elt_type; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1241
  ciType* exact_type() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1242
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1243
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1244
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1245
LEAF(NewObjectArray, NewArray)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1246
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1247
  ciKlass* _klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1248
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1249
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1250
  // creation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1251
  NewObjectArray(ciKlass* klass, Value length, ValueStack* state_before) : NewArray(length, state_before), _klass(klass) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1252
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1253
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1254
  ciKlass* klass() const                         { return _klass; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1255
  ciType* exact_type() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1256
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1257
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1258
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1259
LEAF(NewMultiArray, NewArray)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1260
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1261
  ciKlass* _klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1262
  Values*  _dims;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1263
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1264
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1265
  // creation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1266
  NewMultiArray(ciKlass* klass, Values* dims, ValueStack* state_before) : NewArray(NULL, state_before), _klass(klass), _dims(dims) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1267
    ASSERT_VALUES
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1268
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1269
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1270
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1271
  ciKlass* klass() const                         { return _klass; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1272
  Values* dims() const                           { return _dims; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1273
  int rank() const                               { return dims()->length(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1274
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1275
  // generic
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1276
  virtual void input_values_do(ValueVisitor* f) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1277
    // NOTE: we do not call NewArray::input_values_do since "length"
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1278
    // is meaningless for a multi-dimensional array; passing the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1279
    // zeroth element down to NewArray as its length is a bad idea
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1280
    // since there will be a copy in the "dims" array which doesn't
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1281
    // get updated, and the value must not be traversed twice. Was bug
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1282
    // - kbr 4/10/2001
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1283
    StateSplit::input_values_do(f);
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1284
    for (int i = 0; i < _dims->length(); i++) f->visit(_dims->adr_at(i));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1285
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1286
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1287
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1288
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1289
BASE(TypeCheck, StateSplit)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1290
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1291
  ciKlass*    _klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1292
  Value       _obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1293
6461
cfc616b49f58 6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents: 6453
diff changeset
  1294
  ciMethod* _profiled_method;
cfc616b49f58 6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents: 6453
diff changeset
  1295
  int       _profiled_bci;
cfc616b49f58 6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents: 6453
diff changeset
  1296
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1297
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1298
  // creation
6461
cfc616b49f58 6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents: 6453
diff changeset
  1299
  TypeCheck(ciKlass* klass, Value obj, ValueType* type, ValueStack* state_before)
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1300
  : StateSplit(type, state_before), _klass(klass), _obj(obj),
6461
cfc616b49f58 6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents: 6453
diff changeset
  1301
    _profiled_method(NULL), _profiled_bci(0) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1302
    ASSERT_VALUES
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1303
    set_direct_compare(false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1304
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1305
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1306
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1307
  ciKlass* klass() const                         { return _klass; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1308
  Value obj() const                              { return _obj; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1309
  bool is_loaded() const                         { return klass() != NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1310
  bool direct_compare() const                    { return check_flag(DirectCompareFlag); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1311
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1312
  // manipulation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1313
  void set_direct_compare(bool flag)             { set_flag(DirectCompareFlag, flag); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1314
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1315
  // generic
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1316
  virtual bool can_trap() const                  { return true; }
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1317
  virtual void input_values_do(ValueVisitor* f)   { StateSplit::input_values_do(f); f->visit(&_obj); }
6461
cfc616b49f58 6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents: 6453
diff changeset
  1318
cfc616b49f58 6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents: 6453
diff changeset
  1319
  // Helpers for methodDataOop profiling
cfc616b49f58 6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents: 6453
diff changeset
  1320
  void set_should_profile(bool value)                { set_flag(ProfileMDOFlag, value); }
cfc616b49f58 6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents: 6453
diff changeset
  1321
  void set_profiled_method(ciMethod* method)         { _profiled_method = method;   }
cfc616b49f58 6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents: 6453
diff changeset
  1322
  void set_profiled_bci(int bci)                     { _profiled_bci = bci;         }
cfc616b49f58 6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents: 6453
diff changeset
  1323
  bool      should_profile() const                   { return check_flag(ProfileMDOFlag); }
cfc616b49f58 6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents: 6453
diff changeset
  1324
  ciMethod* profiled_method() const                  { return _profiled_method;     }
cfc616b49f58 6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents: 6453
diff changeset
  1325
  int       profiled_bci() const                     { return _profiled_bci;        }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1326
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1327
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1328
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1329
LEAF(CheckCast, TypeCheck)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1330
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1331
  // creation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1332
  CheckCast(ciKlass* klass, Value obj, ValueStack* state_before)
6461
cfc616b49f58 6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents: 6453
diff changeset
  1333
  : TypeCheck(klass, obj, objectType, state_before) {}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1334
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1335
  void set_incompatible_class_change_check() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1336
    set_flag(ThrowIncompatibleClassChangeErrorFlag, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1337
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1338
  bool is_incompatible_class_change_check() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1339
    return check_flag(ThrowIncompatibleClassChangeErrorFlag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1340
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1341
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1342
  ciType* declared_type() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1343
  ciType* exact_type() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1344
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1345
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1346
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1347
LEAF(InstanceOf, TypeCheck)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1348
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1349
  // creation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1350
  InstanceOf(ciKlass* klass, Value obj, ValueStack* state_before) : TypeCheck(klass, obj, intType, state_before) {}
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1351
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1352
  virtual bool needs_exception_state() const     { return false; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1353
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1354
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1355
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1356
BASE(AccessMonitor, StateSplit)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1357
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1358
  Value       _obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1359
  int         _monitor_no;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1360
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1361
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1362
  // creation
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1363
  AccessMonitor(Value obj, int monitor_no, ValueStack* state_before = NULL)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1364
  : StateSplit(illegalType, state_before)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1365
  , _obj(obj)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1366
  , _monitor_no(monitor_no)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1367
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1368
    set_needs_null_check(true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1369
    ASSERT_VALUES
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1370
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1371
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1372
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1373
  Value obj() const                              { return _obj; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1374
  int monitor_no() const                         { return _monitor_no; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1375
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1376
  // generic
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1377
  virtual void input_values_do(ValueVisitor* f)   { StateSplit::input_values_do(f); f->visit(&_obj); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1378
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1379
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1380
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1381
LEAF(MonitorEnter, AccessMonitor)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1382
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1383
  // creation
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1384
  MonitorEnter(Value obj, int monitor_no, ValueStack* state_before)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1385
  : AccessMonitor(obj, monitor_no, state_before)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1386
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1387
    ASSERT_VALUES
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1388
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1389
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1390
  // generic
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1391
  virtual bool can_trap() const                  { return true; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1392
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1393
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1394
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1395
LEAF(MonitorExit, AccessMonitor)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1396
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1397
  // creation
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1398
  MonitorExit(Value obj, int monitor_no)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1399
  : AccessMonitor(obj, monitor_no, NULL)
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1400
  {
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1401
    ASSERT_VALUES
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1402
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1403
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1404
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1405
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1406
LEAF(Intrinsic, StateSplit)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1407
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1408
  vmIntrinsics::ID _id;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1409
  Values*          _args;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1410
  Value            _recv;
9102
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
  1411
  int              _nonnull_state; // mask identifying which args are nonnull
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1412
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1413
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1414
  // preserves_state can be set to true for Intrinsics
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1415
  // which are guaranteed to preserve register state across any slow
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1416
  // cases; setting it to true does not mean that the Intrinsic can
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1417
  // not trap, only that if we continue execution in the same basic
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1418
  // block after the Intrinsic, all of the registers are intact. This
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1419
  // allows load elimination and common expression elimination to be
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1420
  // performed across the Intrinsic.  The default value is false.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1421
  Intrinsic(ValueType* type,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1422
            vmIntrinsics::ID id,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1423
            Values* args,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1424
            bool has_receiver,
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1425
            ValueStack* state_before,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1426
            bool preserves_state,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1427
            bool cantrap = true)
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1428
  : StateSplit(type, state_before)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1429
  , _id(id)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1430
  , _args(args)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1431
  , _recv(NULL)
9102
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
  1432
  , _nonnull_state(AllBits)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1433
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1434
    assert(args != NULL, "args must exist");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1435
    ASSERT_VALUES
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1436
    set_flag(PreservesStateFlag, preserves_state);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1437
    set_flag(CanTrapFlag,        cantrap);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1438
    if (has_receiver) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1439
      _recv = argument_at(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1440
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1441
    set_needs_null_check(has_receiver);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1442
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1443
    // some intrinsics can't trap, so don't force them to be pinned
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1444
    if (!can_trap()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1445
      unpin(PinStateSplitConstructor);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1446
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1447
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1448
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1449
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1450
  vmIntrinsics::ID id() const                    { return _id; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1451
  int number_of_arguments() const                { return _args->length(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1452
  Value argument_at(int i) const                 { return _args->at(i); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1453
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1454
  bool has_receiver() const                      { return (_recv != NULL); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1455
  Value receiver() const                         { assert(has_receiver(), "must have receiver"); return _recv; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1456
  bool preserves_state() const                   { return check_flag(PreservesStateFlag); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1457
9102
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
  1458
  bool arg_needs_null_check(int i) {
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
  1459
    if (i >= 0 && i < (int)sizeof(_nonnull_state) * BitsPerByte) {
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
  1460
      return is_set_nth_bit(_nonnull_state, i);
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
  1461
    }
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
  1462
    return true;
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
  1463
  }
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
  1464
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
  1465
  void set_arg_needs_null_check(int i, bool check) {
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
  1466
    if (i >= 0 && i < (int)sizeof(_nonnull_state) * BitsPerByte) {
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
  1467
      if (check) {
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
  1468
        _nonnull_state |= nth_bit(i);
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
  1469
      } else {
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
  1470
        _nonnull_state &= ~(nth_bit(i));
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
  1471
      }
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
  1472
    }
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
  1473
  }
4708a4aefb33 7033154: Improve C1 arraycopy performance
roland
parents: 8671
diff changeset
  1474
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1475
  // generic
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1476
  virtual bool can_trap() const                  { return check_flag(CanTrapFlag); }
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1477
  virtual void input_values_do(ValueVisitor* f) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1478
    StateSplit::input_values_do(f);
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1479
    for (int i = 0; i < _args->length(); i++) f->visit(_args->adr_at(i));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1480
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1481
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1482
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1483
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1484
class LIR_List;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1485
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1486
LEAF(BlockBegin, StateSplit)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1487
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1488
  int        _block_id;                          // the unique block id
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1489
  int        _bci;                               // start-bci of block
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1490
  int        _depth_first_number;                // number of this block in a depth-first ordering
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1491
  int        _linear_scan_number;                // number of this block in linear-scan ordering
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1492
  int        _loop_depth;                        // the loop nesting level of this block
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1493
  int        _loop_index;                        // number of the innermost loop of this block
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1494
  int        _flags;                             // the flags associated with this block
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1495
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1496
  // fields used by BlockListBuilder
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1497
  int        _total_preds;                       // number of predecessors found by BlockListBuilder
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1498
  BitMap     _stores_to_locals;                  // bit is set when a local variable is stored in the block
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1499
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1500
  // SSA specific fields: (factor out later)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1501
  BlockList   _successors;                       // the successors of this block
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1502
  BlockList   _predecessors;                     // the predecessors of this block
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1503
  BlockBegin* _dominator;                        // the dominator of this block
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1504
  // SSA specific ends
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1505
  BlockEnd*  _end;                               // the last instruction of this block
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1506
  BlockList  _exception_handlers;                // the exception handlers potentially invoked by this block
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1507
  ValueStackStack* _exception_states;            // only for xhandler entries: states of all instructions that have an edge to this xhandler
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1508
  int        _exception_handler_pco;             // if this block is the start of an exception handler,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1509
                                                 // this records the PC offset in the assembly code of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1510
                                                 // first instruction in this block
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1511
  Label      _label;                             // the label associated with this block
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1512
  LIR_List*  _lir;                               // the low level intermediate representation for this block
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1513
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1514
  BitMap      _live_in;                          // set of live LIR_Opr registers at entry to this block
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1515
  BitMap      _live_out;                         // set of live LIR_Opr registers at exit from this block
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1516
  BitMap      _live_gen;                         // set of registers used before any redefinition in this block
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1517
  BitMap      _live_kill;                        // set of registers defined in this block
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1518
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1519
  BitMap      _fpu_register_usage;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1520
  intArray*   _fpu_stack_state;                  // For x86 FPU code generation with UseLinearScan
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1521
  int         _first_lir_instruction_id;         // ID of first LIR instruction in this block
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1522
  int         _last_lir_instruction_id;          // ID of last LIR instruction in this block
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1523
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1524
  void iterate_preorder (boolArray& mark, BlockClosure* closure);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1525
  void iterate_postorder(boolArray& mark, BlockClosure* closure);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1526
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1527
  friend class SuxAndWeightAdjuster;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1528
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1529
 public:
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1530
   void* operator new(size_t size) {
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1531
    Compilation* c = Compilation::current();
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1532
    void* res = c->arena()->Amalloc(size);
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1533
    ((BlockBegin*)res)->_id = c->get_next_id();
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1534
    ((BlockBegin*)res)->_block_id = c->get_next_block_id();
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1535
    return res;
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1536
  }
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1537
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1538
  // initialization/counting
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1539
  static int  number_of_blocks() {
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1540
    return Compilation::current()->number_of_blocks();
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1541
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1542
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1543
  // creation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1544
  BlockBegin(int bci)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1545
  : StateSplit(illegalType)
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1546
  , _bci(bci)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1547
  , _depth_first_number(-1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1548
  , _linear_scan_number(-1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1549
  , _loop_depth(0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1550
  , _flags(0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1551
  , _dominator(NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1552
  , _end(NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1553
  , _predecessors(2)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1554
  , _successors(2)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1555
  , _exception_handlers(1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1556
  , _exception_states(NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1557
  , _exception_handler_pco(-1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1558
  , _lir(NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1559
  , _loop_index(-1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1560
  , _live_in()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1561
  , _live_out()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1562
  , _live_gen()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1563
  , _live_kill()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1564
  , _fpu_register_usage()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1565
  , _fpu_stack_state(NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1566
  , _first_lir_instruction_id(-1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1567
  , _last_lir_instruction_id(-1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1568
  , _total_preds(0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1569
  , _stores_to_locals()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1570
  {
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1571
#ifndef PRODUCT
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1572
    set_printable_bci(bci);
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1573
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1574
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1575
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1576
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1577
  int block_id() const                           { return _block_id; }
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1578
  int bci() const                                { return _bci; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1579
  BlockList* successors()                        { return &_successors; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1580
  BlockBegin* dominator() const                  { return _dominator; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1581
  int loop_depth() const                         { return _loop_depth; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1582
  int depth_first_number() const                 { return _depth_first_number; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1583
  int linear_scan_number() const                 { return _linear_scan_number; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1584
  BlockEnd* end() const                          { return _end; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1585
  Label* label()                                 { return &_label; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1586
  LIR_List* lir() const                          { return _lir; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1587
  int exception_handler_pco() const              { return _exception_handler_pco; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1588
  BitMap& live_in()                              { return _live_in;        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1589
  BitMap& live_out()                             { return _live_out;       }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1590
  BitMap& live_gen()                             { return _live_gen;       }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1591
  BitMap& live_kill()                            { return _live_kill;      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1592
  BitMap& fpu_register_usage()                   { return _fpu_register_usage; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1593
  intArray* fpu_stack_state() const              { return _fpu_stack_state;    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1594
  int first_lir_instruction_id() const           { return _first_lir_instruction_id; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1595
  int last_lir_instruction_id() const            { return _last_lir_instruction_id; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1596
  int total_preds() const                        { return _total_preds; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1597
  BitMap& stores_to_locals()                     { return _stores_to_locals; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1598
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1599
  // manipulation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1600
  void set_dominator(BlockBegin* dom)            { _dominator = dom; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1601
  void set_loop_depth(int d)                     { _loop_depth = d; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1602
  void set_depth_first_number(int dfn)           { _depth_first_number = dfn; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1603
  void set_linear_scan_number(int lsn)           { _linear_scan_number = lsn; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1604
  void set_end(BlockEnd* end);
10509
43d670e5701e 7079673: JSR 292: C1 should inline bytecoded method handle adapters
twisti
parents: 9102
diff changeset
  1605
  void clear_end();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1606
  void disconnect_from_graph();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1607
  static void disconnect_edge(BlockBegin* from, BlockBegin* to);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1608
  BlockBegin* insert_block_between(BlockBegin* sux);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1609
  void substitute_sux(BlockBegin* old_sux, BlockBegin* new_sux);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1610
  void set_lir(LIR_List* lir)                    { _lir = lir; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1611
  void set_exception_handler_pco(int pco)        { _exception_handler_pco = pco; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1612
  void set_live_in       (BitMap map)            { _live_in = map;        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1613
  void set_live_out      (BitMap map)            { _live_out = map;       }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1614
  void set_live_gen      (BitMap map)            { _live_gen = map;       }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1615
  void set_live_kill     (BitMap map)            { _live_kill = map;      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1616
  void set_fpu_register_usage(BitMap map)        { _fpu_register_usage = map; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1617
  void set_fpu_stack_state(intArray* state)      { _fpu_stack_state = state;  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1618
  void set_first_lir_instruction_id(int id)      { _first_lir_instruction_id = id;  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1619
  void set_last_lir_instruction_id(int id)       { _last_lir_instruction_id = id;  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1620
  void increment_total_preds(int n = 1)          { _total_preds += n; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1621
  void init_stores_to_locals(int locals_count)   { _stores_to_locals = BitMap(locals_count); _stores_to_locals.clear(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1622
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1623
  // generic
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1624
  virtual void state_values_do(ValueVisitor* f);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1625
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1626
  // successors and predecessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1627
  int number_of_sux() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1628
  BlockBegin* sux_at(int i) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1629
  void add_successor(BlockBegin* sux);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1630
  void remove_successor(BlockBegin* pred);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1631
  bool is_successor(BlockBegin* sux) const       { return _successors.contains(sux); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1632
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1633
  void add_predecessor(BlockBegin* pred);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1634
  void remove_predecessor(BlockBegin* pred);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1635
  bool is_predecessor(BlockBegin* pred) const    { return _predecessors.contains(pred); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1636
  int number_of_preds() const                    { return _predecessors.length(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1637
  BlockBegin* pred_at(int i) const               { return _predecessors[i]; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1638
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1639
  // exception handlers potentially invoked by this block
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1640
  void add_exception_handler(BlockBegin* b);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1641
  bool is_exception_handler(BlockBegin* b) const { return _exception_handlers.contains(b); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1642
  int  number_of_exception_handlers() const      { return _exception_handlers.length(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1643
  BlockBegin* exception_handler_at(int i) const  { return _exception_handlers.at(i); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1644
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1645
  // states of the instructions that have an edge to this exception handler
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1646
  int number_of_exception_states()               { assert(is_set(exception_entry_flag), "only for xhandlers"); return _exception_states == NULL ? 0 : _exception_states->length(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1647
  ValueStack* exception_state_at(int idx) const  { assert(is_set(exception_entry_flag), "only for xhandlers"); return _exception_states->at(idx); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1648
  int add_exception_state(ValueStack* state);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1649
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1650
  // flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1651
  enum Flag {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1652
    no_flag                       = 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1653
    std_entry_flag                = 1 << 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1654
    osr_entry_flag                = 1 << 1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1655
    exception_entry_flag          = 1 << 2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1656
    subroutine_entry_flag         = 1 << 3,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1657
    backward_branch_target_flag   = 1 << 4,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1658
    is_on_work_list_flag          = 1 << 5,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1659
    was_visited_flag              = 1 << 6,
5334
b2d040a8d375 6939930: exception unwind changes in 6919934 hurts compilation speed
never
parents: 5046
diff changeset
  1660
    parser_loop_header_flag       = 1 << 7,  // set by parser to identify blocks where phi functions can not be created on demand
b2d040a8d375 6939930: exception unwind changes in 6919934 hurts compilation speed
never
parents: 5046
diff changeset
  1661
    critical_edge_split_flag      = 1 << 8, // set for all blocks that are introduced when critical edges are split
b2d040a8d375 6939930: exception unwind changes in 6919934 hurts compilation speed
never
parents: 5046
diff changeset
  1662
    linear_scan_loop_header_flag  = 1 << 9, // set during loop-detection for LinearScan
b2d040a8d375 6939930: exception unwind changes in 6919934 hurts compilation speed
never
parents: 5046
diff changeset
  1663
    linear_scan_loop_end_flag     = 1 << 10  // set during loop-detection for LinearScan
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1664
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1665
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1666
  void set(Flag f)                               { _flags |= f; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1667
  void clear(Flag f)                             { _flags &= ~f; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1668
  bool is_set(Flag f) const                      { return (_flags & f) != 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1669
  bool is_entry_block() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1670
    const int entry_mask = std_entry_flag | osr_entry_flag | exception_entry_flag;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1671
    return (_flags & entry_mask) != 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1672
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1673
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1674
  // iteration
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1675
  void iterate_preorder   (BlockClosure* closure);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1676
  void iterate_postorder  (BlockClosure* closure);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1677
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1678
  void block_values_do(ValueVisitor* f);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1679
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1680
  // loops
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1681
  void set_loop_index(int ix)                    { _loop_index = ix;        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1682
  int  loop_index() const                        { return _loop_index;      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1683
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1684
  // merging
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1685
  bool try_merge(ValueStack* state);             // try to merge states at block begin
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1686
  void merge(ValueStack* state)                  { bool b = try_merge(state); assert(b, "merge failed"); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1687
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1688
  // debugging
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1689
  void print_block()                             PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1690
  void print_block(InstructionPrinter& ip, bool live_only = false) PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1691
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1692
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1693
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1694
BASE(BlockEnd, StateSplit)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1695
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1696
  BlockBegin* _begin;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1697
  BlockList*  _sux;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1698
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1699
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1700
  BlockList* sux() const                         { return _sux; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1701
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1702
  void set_sux(BlockList* sux) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1703
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1704
    assert(sux != NULL, "sux must exist");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1705
    for (int i = sux->length() - 1; i >= 0; i--) assert(sux->at(i) != NULL, "sux must exist");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1706
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1707
    _sux = sux;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1708
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1709
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1710
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1711
  // creation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1712
  BlockEnd(ValueType* type, ValueStack* state_before, bool is_safepoint)
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1713
  : StateSplit(type, state_before)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1714
  , _begin(NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1715
  , _sux(NULL)
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1716
  {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1717
    set_flag(IsSafepointFlag, is_safepoint);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1718
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1719
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1720
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1721
  bool is_safepoint() const                      { return check_flag(IsSafepointFlag); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1722
  BlockBegin* begin() const                      { return _begin; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1723
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1724
  // manipulation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1725
  void set_begin(BlockBegin* begin);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1726
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1727
  // successors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1728
  int number_of_sux() const                      { return _sux != NULL ? _sux->length() : 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1729
  BlockBegin* sux_at(int i) const                { return _sux->at(i); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1730
  BlockBegin* default_sux() const                { return sux_at(number_of_sux() - 1); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1731
  BlockBegin** addr_sux_at(int i) const          { return _sux->adr_at(i); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1732
  int sux_index(BlockBegin* sux) const           { return _sux->find(sux); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1733
  void substitute_sux(BlockBegin* old_sux, BlockBegin* new_sux);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1734
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1735
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1736
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1737
LEAF(Goto, BlockEnd)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1738
 public:
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1739
  enum Direction {
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1740
    none,            // Just a regular goto
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1741
    taken, not_taken // Goto produced from If
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1742
  };
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1743
 private:
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1744
  ciMethod*   _profiled_method;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1745
  int         _profiled_bci;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1746
  Direction   _direction;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1747
 public:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1748
  // creation
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1749
  Goto(BlockBegin* sux, ValueStack* state_before, bool is_safepoint = false)
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1750
    : BlockEnd(illegalType, state_before, is_safepoint)
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1751
    , _direction(none)
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1752
    , _profiled_method(NULL)
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1753
    , _profiled_bci(0) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1754
    BlockList* s = new BlockList(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1755
    s->append(sux);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1756
    set_sux(s);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1757
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1758
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1759
  Goto(BlockBegin* sux, bool is_safepoint) : BlockEnd(illegalType, NULL, is_safepoint)
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1760
                                           , _direction(none)
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1761
                                           , _profiled_method(NULL)
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1762
                                           , _profiled_bci(0) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1763
    BlockList* s = new BlockList(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1764
    s->append(sux);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1765
    set_sux(s);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1766
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1767
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1768
  bool should_profile() const                    { return check_flag(ProfileMDOFlag); }
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1769
  ciMethod* profiled_method() const              { return _profiled_method; } // set only for profiled branches
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1770
  int profiled_bci() const                       { return _profiled_bci; }
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1771
  Direction direction() const                    { return _direction; }
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1772
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1773
  void set_should_profile(bool value)            { set_flag(ProfileMDOFlag, value); }
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1774
  void set_profiled_method(ciMethod* method)     { _profiled_method = method; }
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1775
  void set_profiled_bci(int bci)                 { _profiled_bci = bci; }
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1776
  void set_direction(Direction d)                { _direction = d; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1777
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1778
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1779
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1780
LEAF(If, BlockEnd)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1781
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1782
  Value       _x;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1783
  Condition   _cond;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1784
  Value       _y;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1785
  ciMethod*   _profiled_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1786
  int         _profiled_bci; // Canonicalizer may alter bci of If node
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1787
  bool        _swapped;      // Is the order reversed with respect to the original If in the
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1788
                             // bytecode stream?
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1789
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1790
  // creation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1791
  // unordered_is_true is valid for float/double compares only
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1792
  If(Value x, Condition cond, bool unordered_is_true, Value y, BlockBegin* tsux, BlockBegin* fsux, ValueStack* state_before, bool is_safepoint)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1793
    : BlockEnd(illegalType, state_before, is_safepoint)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1794
  , _x(x)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1795
  , _cond(cond)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1796
  , _y(y)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1797
  , _profiled_method(NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1798
  , _profiled_bci(0)
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1799
  , _swapped(false)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1800
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1801
    ASSERT_VALUES
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1802
    set_flag(UnorderedIsTrueFlag, unordered_is_true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1803
    assert(x->type()->tag() == y->type()->tag(), "types must match");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1804
    BlockList* s = new BlockList(2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1805
    s->append(tsux);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1806
    s->append(fsux);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1807
    set_sux(s);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1808
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1809
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1810
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1811
  Value x() const                                { return _x; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1812
  Condition cond() const                         { return _cond; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1813
  bool unordered_is_true() const                 { return check_flag(UnorderedIsTrueFlag); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1814
  Value y() const                                { return _y; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1815
  BlockBegin* sux_for(bool is_true) const        { return sux_at(is_true ? 0 : 1); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1816
  BlockBegin* tsux() const                       { return sux_for(true); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1817
  BlockBegin* fsux() const                       { return sux_for(false); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1818
  BlockBegin* usux() const                       { return sux_for(unordered_is_true()); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1819
  bool should_profile() const                    { return check_flag(ProfileMDOFlag); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1820
  ciMethod* profiled_method() const              { return _profiled_method; } // set only for profiled branches
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1821
  int profiled_bci() const                       { return _profiled_bci; }    // set for profiled branches and tiered
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1822
  bool is_swapped() const                        { return _swapped; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1823
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1824
  // manipulation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1825
  void swap_operands() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1826
    Value t = _x; _x = _y; _y = t;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1827
    _cond = mirror(_cond);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1828
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1829
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1830
  void swap_sux() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1831
    assert(number_of_sux() == 2, "wrong number of successors");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1832
    BlockList* s = sux();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1833
    BlockBegin* t = s->at(0); s->at_put(0, s->at(1)); s->at_put(1, t);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1834
    _cond = negate(_cond);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1835
    set_flag(UnorderedIsTrueFlag, !check_flag(UnorderedIsTrueFlag));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1836
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1837
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1838
  void set_should_profile(bool value)             { set_flag(ProfileMDOFlag, value); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1839
  void set_profiled_method(ciMethod* method)      { _profiled_method = method; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1840
  void set_profiled_bci(int bci)                  { _profiled_bci = bci;       }
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  1841
  void set_swapped(bool value)                    { _swapped = value;         }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1842
  // generic
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1843
  virtual void input_values_do(ValueVisitor* f)   { BlockEnd::input_values_do(f); f->visit(&_x); f->visit(&_y); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1844
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1845
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1846
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1847
LEAF(IfInstanceOf, BlockEnd)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1848
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1849
  ciKlass* _klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1850
  Value    _obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1851
  bool     _test_is_instance;                    // jump if instance
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1852
  int      _instanceof_bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1853
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1854
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1855
  IfInstanceOf(ciKlass* klass, Value obj, bool test_is_instance, int instanceof_bci, BlockBegin* tsux, BlockBegin* fsux)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1856
  : BlockEnd(illegalType, NULL, false) // temporary set to false
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1857
  , _klass(klass)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1858
  , _obj(obj)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1859
  , _test_is_instance(test_is_instance)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1860
  , _instanceof_bci(instanceof_bci)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1861
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1862
    ASSERT_VALUES
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1863
    assert(instanceof_bci >= 0, "illegal bci");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1864
    BlockList* s = new BlockList(2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1865
    s->append(tsux);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1866
    s->append(fsux);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1867
    set_sux(s);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1868
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1869
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1870
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1871
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1872
  // Note 1: If test_is_instance() is true, IfInstanceOf tests if obj *is* an
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1873
  //         instance of klass; otherwise it tests if it is *not* and instance
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1874
  //         of klass.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1875
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1876
  // Note 2: IfInstanceOf instructions are created by combining an InstanceOf
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1877
  //         and an If instruction. The IfInstanceOf bci() corresponds to the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1878
  //         bci that the If would have had; the (this->) instanceof_bci() is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1879
  //         the bci of the original InstanceOf instruction.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1880
  ciKlass* klass() const                         { return _klass; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1881
  Value obj() const                              { return _obj; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1882
  int instanceof_bci() const                     { return _instanceof_bci; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1883
  bool test_is_instance() const                  { return _test_is_instance; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1884
  BlockBegin* sux_for(bool is_true) const        { return sux_at(is_true ? 0 : 1); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1885
  BlockBegin* tsux() const                       { return sux_for(true); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1886
  BlockBegin* fsux() const                       { return sux_for(false); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1887
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1888
  // manipulation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1889
  void swap_sux() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1890
    assert(number_of_sux() == 2, "wrong number of successors");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1891
    BlockList* s = sux();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1892
    BlockBegin* t = s->at(0); s->at_put(0, s->at(1)); s->at_put(1, t);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1893
    _test_is_instance = !_test_is_instance;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1894
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1895
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1896
  // generic
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1897
  virtual void input_values_do(ValueVisitor* f)   { BlockEnd::input_values_do(f); f->visit(&_obj); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1898
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1899
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1900
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1901
BASE(Switch, BlockEnd)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1902
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1903
  Value       _tag;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1904
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1905
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1906
  // creation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1907
  Switch(Value tag, BlockList* sux, ValueStack* state_before, bool is_safepoint)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1908
  : BlockEnd(illegalType, state_before, is_safepoint)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1909
  , _tag(tag) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1910
    ASSERT_VALUES
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1911
    set_sux(sux);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1912
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1913
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1914
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1915
  Value tag() const                              { return _tag; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1916
  int length() const                             { return number_of_sux() - 1; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1917
6745
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1918
  virtual bool needs_exception_state() const     { return false; }
a34ef8968a84 6986046: C1 valuestack cleanup
roland
parents: 6461
diff changeset
  1919
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1920
  // generic
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1921
  virtual void input_values_do(ValueVisitor* f)   { BlockEnd::input_values_do(f); f->visit(&_tag); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1922
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1923
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1924
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1925
LEAF(TableSwitch, Switch)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1926
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1927
  int _lo_key;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1928
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1929
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1930
  // creation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1931
  TableSwitch(Value tag, BlockList* sux, int lo_key, ValueStack* state_before, bool is_safepoint)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1932
    : Switch(tag, sux, state_before, is_safepoint)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1933
  , _lo_key(lo_key) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1934
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1935
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1936
  int lo_key() const                             { return _lo_key; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1937
  int hi_key() const                             { return _lo_key + length() - 1; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1938
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1939
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1940
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1941
LEAF(LookupSwitch, Switch)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1942
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1943
  intArray* _keys;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1944
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1945
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1946
  // creation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1947
  LookupSwitch(Value tag, BlockList* sux, intArray* keys, ValueStack* state_before, bool is_safepoint)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1948
  : Switch(tag, sux, state_before, is_safepoint)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1949
  , _keys(keys) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1950
    assert(keys != NULL, "keys must exist");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1951
    assert(keys->length() == length(), "sux & keys have incompatible lengths");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1952
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1953
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1954
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1955
  int key_at(int i) const                        { return _keys->at(i); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1956
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1957
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1958
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1959
LEAF(Return, BlockEnd)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1960
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1961
  Value _result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1962
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1963
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1964
  // creation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1965
  Return(Value result) :
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1966
    BlockEnd(result == NULL ? voidType : result->type()->base(), NULL, true),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1967
    _result(result) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1968
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1969
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1970
  Value result() const                           { return _result; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1971
  bool has_result() const                        { return result() != NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1972
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1973
  // generic
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1974
  virtual void input_values_do(ValueVisitor* f) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1975
    BlockEnd::input_values_do(f);
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1976
    if (has_result()) f->visit(&_result);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1977
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1978
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1979
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1980
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1981
LEAF(Throw, BlockEnd)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1982
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1983
  Value _exception;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1984
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1985
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1986
  // creation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1987
  Throw(Value exception, ValueStack* state_before) : BlockEnd(illegalType, state_before, true), _exception(exception) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1988
    ASSERT_VALUES
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1989
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1990
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1991
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1992
  Value exception() const                        { return _exception; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1993
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1994
  // generic
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1995
  virtual bool can_trap() const                  { return true; }
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  1996
  virtual void input_values_do(ValueVisitor* f)   { BlockEnd::input_values_do(f); f->visit(&_exception); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1997
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1998
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1999
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2000
LEAF(Base, BlockEnd)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2001
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2002
  // creation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2003
  Base(BlockBegin* std_entry, BlockBegin* osr_entry) : BlockEnd(illegalType, NULL, false) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2004
    assert(std_entry->is_set(BlockBegin::std_entry_flag), "std entry must be flagged");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2005
    assert(osr_entry == NULL || osr_entry->is_set(BlockBegin::osr_entry_flag), "osr entry must be flagged");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2006
    BlockList* s = new BlockList(2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2007
    if (osr_entry != NULL) s->append(osr_entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2008
    s->append(std_entry); // must be default sux!
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2009
    set_sux(s);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2010
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2011
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2012
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2013
  BlockBegin* std_entry() const                  { return default_sux(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2014
  BlockBegin* osr_entry() const                  { return number_of_sux() < 2 ? NULL : sux_at(0); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2015
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2016
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2017
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2018
LEAF(OsrEntry, Instruction)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2019
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2020
  // creation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2021
#ifdef _LP64
6750
b84813b41757 6988303: 6986046 breaks build with recent gcc
roland
parents: 6745
diff changeset
  2022
  OsrEntry() : Instruction(longType) { pin(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2023
#else
6750
b84813b41757 6988303: 6986046 breaks build with recent gcc
roland
parents: 6745
diff changeset
  2024
  OsrEntry() : Instruction(intType)  { pin(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2025
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2026
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2027
  // generic
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  2028
  virtual void input_values_do(ValueVisitor* f)   { }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2029
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2030
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2031
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2032
// Models the incoming exception at a catch site
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2033
LEAF(ExceptionObject, Instruction)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2034
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2035
  // creation
6750
b84813b41757 6988303: 6986046 breaks build with recent gcc
roland
parents: 6745
diff changeset
  2036
  ExceptionObject() : Instruction(objectType) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2037
    pin();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2038
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2039
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2040
  // generic
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  2041
  virtual void input_values_do(ValueVisitor* f)   { }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2042
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2043
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2044
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2045
// Models needed rounding for floating-point values on Intel.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2046
// Currently only used to represent rounding of double-precision
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2047
// values stored into local variables, but could be used to model
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2048
// intermediate rounding of single-precision values as well.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2049
LEAF(RoundFP, Instruction)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2050
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2051
  Value _input;             // floating-point value to be rounded
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2052
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2053
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2054
  RoundFP(Value input)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2055
  : Instruction(input->type()) // Note: should not be used for constants
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2056
  , _input(input)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2057
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2058
    ASSERT_VALUES
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2059
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2060
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2061
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2062
  Value input() const                            { return _input; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2063
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2064
  // generic
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  2065
  virtual void input_values_do(ValueVisitor* f)   { f->visit(&_input); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2066
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2067
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2068
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2069
BASE(UnsafeOp, Instruction)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2070
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2071
  BasicType _basic_type;    // ValueType can not express byte-sized integers
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2072
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2073
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2074
  // creation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2075
  UnsafeOp(BasicType basic_type, bool is_put)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2076
  : Instruction(is_put ? voidType : as_ValueType(basic_type))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2077
  , _basic_type(basic_type)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2078
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2079
    //Note:  Unsafe ops are not not guaranteed to throw NPE.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2080
    // Convservatively, Unsafe operations must be pinned though we could be
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2081
    // looser about this if we wanted to..
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2082
    pin();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2083
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2084
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2085
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2086
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2087
  BasicType basic_type()                         { return _basic_type; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2088
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2089
  // generic
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  2090
  virtual void input_values_do(ValueVisitor* f)   { }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2091
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2092
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2093
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2094
BASE(UnsafeRawOp, UnsafeOp)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2095
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2096
  Value _base;                                   // Base address (a Java long)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2097
  Value _index;                                  // Index if computed by optimizer; initialized to NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2098
  int   _log2_scale;                             // Scale factor: 0, 1, 2, or 3.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2099
                                                 // Indicates log2 of number of bytes (1, 2, 4, or 8)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2100
                                                 // to scale index by.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2101
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2102
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2103
  UnsafeRawOp(BasicType basic_type, Value addr, bool is_put)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2104
  : UnsafeOp(basic_type, is_put)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2105
  , _base(addr)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2106
  , _index(NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2107
  , _log2_scale(0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2108
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2109
    // Can not use ASSERT_VALUES because index may be NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2110
    assert(addr != NULL && addr->type()->is_long(), "just checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2111
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2112
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2113
  UnsafeRawOp(BasicType basic_type, Value base, Value index, int log2_scale, bool is_put)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2114
  : UnsafeOp(basic_type, is_put)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2115
  , _base(base)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2116
  , _index(index)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2117
  , _log2_scale(log2_scale)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2118
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2119
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2120
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2121
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2122
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2123
  Value base()                                   { return _base; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2124
  Value index()                                  { return _index; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2125
  bool  has_index()                              { return (_index != NULL); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2126
  int   log2_scale()                             { return _log2_scale; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2127
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2128
  // setters
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2129
  void set_base (Value base)                     { _base  = base; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2130
  void set_index(Value index)                    { _index = index; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2131
  void set_log2_scale(int log2_scale)            { _log2_scale = log2_scale; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2132
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2133
  // generic
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  2134
  virtual void input_values_do(ValueVisitor* f)   { UnsafeOp::input_values_do(f);
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  2135
                                                   f->visit(&_base);
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  2136
                                                   if (has_index()) f->visit(&_index); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2137
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2138
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2139
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2140
LEAF(UnsafeGetRaw, UnsafeRawOp)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2141
 private:
7427
d7b79a367474 6985015: C1 needs to support compressed oops
iveresov
parents: 7397
diff changeset
  2142
 bool _may_be_unaligned, _is_wide;  // For OSREntry
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2143
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2144
 public:
7427
d7b79a367474 6985015: C1 needs to support compressed oops
iveresov
parents: 7397
diff changeset
  2145
 UnsafeGetRaw(BasicType basic_type, Value addr, bool may_be_unaligned, bool is_wide = false)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2146
  : UnsafeRawOp(basic_type, addr, false) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2147
    _may_be_unaligned = may_be_unaligned;
7427
d7b79a367474 6985015: C1 needs to support compressed oops
iveresov
parents: 7397
diff changeset
  2148
    _is_wide = is_wide;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2149
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2150
7427
d7b79a367474 6985015: C1 needs to support compressed oops
iveresov
parents: 7397
diff changeset
  2151
 UnsafeGetRaw(BasicType basic_type, Value base, Value index, int log2_scale, bool may_be_unaligned, bool is_wide = false)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2152
  : UnsafeRawOp(basic_type, base, index, log2_scale, false) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2153
    _may_be_unaligned = may_be_unaligned;
7427
d7b79a367474 6985015: C1 needs to support compressed oops
iveresov
parents: 7397
diff changeset
  2154
    _is_wide = is_wide;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2155
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2156
7427
d7b79a367474 6985015: C1 needs to support compressed oops
iveresov
parents: 7397
diff changeset
  2157
  bool may_be_unaligned()                         { return _may_be_unaligned; }
d7b79a367474 6985015: C1 needs to support compressed oops
iveresov
parents: 7397
diff changeset
  2158
  bool is_wide()                                  { return _is_wide; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2159
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2160
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2161
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2162
LEAF(UnsafePutRaw, UnsafeRawOp)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2163
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2164
  Value _value;                                  // Value to be stored
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2165
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2166
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2167
  UnsafePutRaw(BasicType basic_type, Value addr, Value value)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2168
  : UnsafeRawOp(basic_type, addr, true)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2169
  , _value(value)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2170
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2171
    assert(value != NULL, "just checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2172
    ASSERT_VALUES
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2173
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2174
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2175
  UnsafePutRaw(BasicType basic_type, Value base, Value index, int log2_scale, Value value)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2176
  : UnsafeRawOp(basic_type, base, index, log2_scale, true)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2177
  , _value(value)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2178
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2179
    assert(value != NULL, "just checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2180
    ASSERT_VALUES
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2181
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2182
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2183
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2184
  Value value()                                  { return _value; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2185
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2186
  // generic
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  2187
  virtual void input_values_do(ValueVisitor* f)   { UnsafeRawOp::input_values_do(f);
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  2188
                                                   f->visit(&_value); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2189
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2190
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2191
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2192
BASE(UnsafeObjectOp, UnsafeOp)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2193
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2194
  Value _object;                                 // Object to be fetched from or mutated
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2195
  Value _offset;                                 // Offset within object
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2196
  bool  _is_volatile;                            // true if volatile - dl/JSR166
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2197
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2198
  UnsafeObjectOp(BasicType basic_type, Value object, Value offset, bool is_put, bool is_volatile)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2199
    : UnsafeOp(basic_type, is_put), _object(object), _offset(offset), _is_volatile(is_volatile)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2200
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2201
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2202
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2203
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2204
  Value object()                                 { return _object; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2205
  Value offset()                                 { return _offset; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2206
  bool  is_volatile()                            { return _is_volatile; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2207
  // generic
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  2208
  virtual void input_values_do(ValueVisitor* f)   { UnsafeOp::input_values_do(f);
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  2209
                                                   f->visit(&_object);
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  2210
                                                   f->visit(&_offset); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2211
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2212
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2213
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2214
LEAF(UnsafeGetObject, UnsafeObjectOp)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2215
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2216
  UnsafeGetObject(BasicType basic_type, Value object, Value offset, bool is_volatile)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2217
  : UnsafeObjectOp(basic_type, object, offset, false, is_volatile)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2218
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2219
    ASSERT_VALUES
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2220
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2221
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2222
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2223
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2224
LEAF(UnsafePutObject, UnsafeObjectOp)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2225
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2226
  Value _value;                                  // Value to be stored
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2227
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2228
  UnsafePutObject(BasicType basic_type, Value object, Value offset, Value value, bool is_volatile)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2229
  : UnsafeObjectOp(basic_type, object, offset, true, is_volatile)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2230
    , _value(value)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2231
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2232
    ASSERT_VALUES
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2233
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2234
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2235
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2236
  Value value()                                  { return _value; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2237
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2238
  // generic
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  2239
  virtual void input_values_do(ValueVisitor* f)   { UnsafeObjectOp::input_values_do(f);
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  2240
                                                   f->visit(&_value); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2241
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2242
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2243
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2244
BASE(UnsafePrefetch, UnsafeObjectOp)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2245
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2246
  UnsafePrefetch(Value object, Value offset)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2247
  : UnsafeObjectOp(T_VOID, object, offset, false, false)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2248
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2249
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2250
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2251
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2252
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2253
LEAF(UnsafePrefetchRead, UnsafePrefetch)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2254
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2255
  UnsafePrefetchRead(Value object, Value offset)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2256
  : UnsafePrefetch(object, offset)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2257
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2258
    ASSERT_VALUES
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2259
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2260
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2261
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2262
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2263
LEAF(UnsafePrefetchWrite, UnsafePrefetch)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2264
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2265
  UnsafePrefetchWrite(Value object, Value offset)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2266
  : UnsafePrefetch(object, offset)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2267
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2268
    ASSERT_VALUES
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2269
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2270
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2271
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2272
LEAF(ProfileCall, Instruction)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2273
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2274
  ciMethod* _method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2275
  int       _bci_of_invoke;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2276
  Value     _recv;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2277
  ciKlass*  _known_holder;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2278
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2279
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2280
  ProfileCall(ciMethod* method, int bci, Value recv, ciKlass* known_holder)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2281
    : Instruction(voidType)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2282
    , _method(method)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2283
    , _bci_of_invoke(bci)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2284
    , _recv(recv)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2285
    , _known_holder(known_holder)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2286
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2287
    // The ProfileCall has side-effects and must occur precisely where located
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2288
    pin();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2289
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2290
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2291
  ciMethod* method()      { return _method; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2292
  int bci_of_invoke()     { return _bci_of_invoke; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2293
  Value recv()            { return _recv; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2294
  ciKlass* known_holder() { return _known_holder; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2295
5707
6c66849ed24e 6958292: C1: Enable parallel compilation
iveresov
parents: 5547
diff changeset
  2296
  virtual void input_values_do(ValueVisitor* f)   { if (_recv != NULL) f->visit(&_recv); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2297
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2298
8065
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2299
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2300
// Call some C runtime function that doesn't safepoint,
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2301
// optionally passing the current thread as the first argument.
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2302
LEAF(RuntimeCall, Instruction)
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2303
 private:
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2304
  const char* _entry_name;
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2305
  address     _entry;
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2306
  Values*     _args;
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2307
  bool        _pass_thread;  // Pass the JavaThread* as an implicit first argument
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2308
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2309
 public:
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2310
  RuntimeCall(ValueType* type, const char* entry_name, address entry, Values* args, bool pass_thread = true)
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2311
    : Instruction(type)
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2312
    , _entry(entry)
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2313
    , _args(args)
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2314
    , _entry_name(entry_name)
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2315
    , _pass_thread(pass_thread) {
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2316
    ASSERT_VALUES
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2317
    pin();
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2318
  }
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2319
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2320
  const char* entry_name() const  { return _entry_name; }
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2321
  address entry() const           { return _entry; }
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2322
  int number_of_arguments() const { return _args->length(); }
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2323
  Value argument_at(int i) const  { return _args->at(i); }
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2324
  bool pass_thread() const        { return _pass_thread; }
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2325
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2326
  virtual void input_values_do(ValueVisitor* f)   {
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2327
    for (int i = 0; i < _args->length(); i++) f->visit(_args->adr_at(i));
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2328
  }
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2329
};
7ca689ce3d32 6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents: 7427
diff changeset
  2330
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  2331
// Use to trip invocation counter of an inlined method
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2332
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  2333
LEAF(ProfileInvoke, Instruction)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2334
 private:
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  2335
  ciMethod*   _inlinee;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  2336
  ValueStack* _state;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2337
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2338
 public:
6751
b399fd234e47 6988346: 6986046 breaks tiered
iveresov
parents: 6750
diff changeset
  2339
  ProfileInvoke(ciMethod* inlinee,  ValueStack* state)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2340
    : Instruction(voidType)
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  2341
    , _inlinee(inlinee)
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  2342
    , _state(state)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2343
  {
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  2344
    // The ProfileInvoke has side-effects and must occur precisely where located QQQ???
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2345
    pin();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2346
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2347
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  2348
  ciMethod* inlinee()      { return _inlinee; }
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  2349
  ValueStack* state()      { return _state; }
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  2350
  virtual void input_values_do(ValueVisitor*)   {}
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5707
diff changeset
  2351
  virtual void state_values_do(ValueVisitor*);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2352
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2353
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2354
class BlockPair: public CompilationResourceObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2355
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2356
  BlockBegin* _from;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2357
  BlockBegin* _to;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2358
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2359
  BlockPair(BlockBegin* from, BlockBegin* to): _from(from), _to(to) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2360
  BlockBegin* from() const { return _from; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2361
  BlockBegin* to() const   { return _to;   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2362
  bool is_same(BlockBegin* from, BlockBegin* to) const { return  _from == from && _to == to; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2363
  bool is_same(BlockPair* p) const { return  _from == p->from() && _to == p->to(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2364
  void set_to(BlockBegin* b)   { _to = b; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2365
  void set_from(BlockBegin* b) { _from = b; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2366
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2367
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2368
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2369
define_array(BlockPairArray, BlockPair*)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2370
define_stack(BlockPairList, BlockPairArray)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2371
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2372
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2373
inline int         BlockBegin::number_of_sux() const            { assert(_end == NULL || _end->number_of_sux() == _successors.length(), "mismatch"); return _successors.length(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2374
inline BlockBegin* BlockBegin::sux_at(int i) const              { assert(_end == NULL || _end->sux_at(i) == _successors.at(i), "mismatch");          return _successors.at(i); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2375
inline void        BlockBegin::add_successor(BlockBegin* sux)   { assert(_end == NULL, "Would create mismatch with successors of BlockEnd");         _successors.append(sux); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2376
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2377
#undef ASSERT_VALUES
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7100
diff changeset
  2378
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7100
diff changeset
  2379
#endif // SHARE_VM_C1_C1_INSTRUCTION_HPP