hotspot/src/share/vm/opto/graphKit.hpp
author jmasa
Fri, 08 Apr 2011 14:19:50 -0700
changeset 9179 6db9c9dffe1f
parent 8921 14bfe81f2a9d
parent 9176 42d9d1010f38
child 9182 ab3e9e0925ad
permissions -rw-r--r--
Merge
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
9176
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8732
diff changeset
     2
 * Copyright (c) 2001, 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: 4761
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4761
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: 4761
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: 6416
diff changeset
    25
#ifndef SHARE_VM_OPTO_GRAPHKIT_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6416
diff changeset
    26
#define SHARE_VM_OPTO_GRAPHKIT_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6416
diff changeset
    27
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6416
diff changeset
    28
#include "ci/ciEnv.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6416
diff changeset
    29
#include "ci/ciMethodData.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6416
diff changeset
    30
#include "opto/addnode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6416
diff changeset
    31
#include "opto/callnode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6416
diff changeset
    32
#include "opto/cfgnode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6416
diff changeset
    33
#include "opto/compile.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6416
diff changeset
    34
#include "opto/divnode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6416
diff changeset
    35
#include "opto/mulnode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6416
diff changeset
    36
#include "opto/phaseX.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6416
diff changeset
    37
#include "opto/subnode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6416
diff changeset
    38
#include "opto/type.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6416
diff changeset
    39
#include "runtime/deoptimization.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6416
diff changeset
    40
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
class FastLockNode;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
class FastUnlockNode;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
    43
class IdealKit;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
class Parse;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
class RootNode;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
//-----------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
//----------------------------GraphKit-----------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
// Toolkit for building the common sorts of subgraphs.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
// Does not know about bytecode parsing or type-flow results.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
// It is able to create graphs implementing the semantics of most
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
// or all bytecodes, so that it can expand intrinsics and calls.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
// It may depend on JVMState structure, but it must not depend
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
// on specific bytecode streams.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
class GraphKit : public Phase {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
  friend class PreserveJVMState;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  ciEnv*            _env;       // Compilation environment
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
  PhaseGVN         &_gvn;       // Some optimizations while parsing
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  SafePointNode*    _map;       // Parser map from JVM to Nodes
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
  SafePointNode*    _exceptions;// Parser map(s) for exception state(s)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
  int               _sp;        // JVM Expression Stack Pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
  int               _bci;       // JVM Bytecode Pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
  ciMethod*         _method;    // JVM Current Method
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  SafePointNode*     map_not_null() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
    assert(_map != NULL, "must call stopped() to test for reset compiler map");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
    return _map;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  GraphKit();                   // empty constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  GraphKit(JVMState* jvms);     // the JVM state on which to operate
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
  ~GraphKit() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
    assert(!has_exceptions(), "user must call transfer_exceptions_into_jvms");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  virtual Parse* is_Parse() const { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  ciEnv*        env()           const { return _env; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  PhaseGVN&     gvn()           const { return _gvn; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  void record_for_igvn(Node* n) const { C->record_for_igvn(n); }  // delegate to Compile
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  // Handy well-known nodes:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  Node*         null()          const { return zerocon(T_OBJECT); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  Node*         top()           const { return C->top(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  RootNode*     root()          const { return C->root(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  // Create or find a constant node
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  Node* intcon(jint con)        const { return _gvn.intcon(con); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  Node* longcon(jlong con)      const { return _gvn.longcon(con); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  Node* makecon(const Type *t)  const { return _gvn.makecon(t); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  Node* zerocon(BasicType bt)   const { return _gvn.zerocon(bt); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  // (See also macro MakeConX in type.hpp, which uses intcon or longcon.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
2027
a980915cf495 6442502: assert(bits,"Use TypePtr for NULL") on linux-x86
never
parents: 1374
diff changeset
   102
  // Helper for byte_map_base
a980915cf495 6442502: assert(bits,"Use TypePtr for NULL") on linux-x86
never
parents: 1374
diff changeset
   103
  Node* byte_map_base_node() {
a980915cf495 6442502: assert(bits,"Use TypePtr for NULL") on linux-x86
never
parents: 1374
diff changeset
   104
    // Get base of card map
a980915cf495 6442502: assert(bits,"Use TypePtr for NULL") on linux-x86
never
parents: 1374
diff changeset
   105
    CardTableModRefBS* ct = (CardTableModRefBS*)(Universe::heap()->barrier_set());
a980915cf495 6442502: assert(bits,"Use TypePtr for NULL") on linux-x86
never
parents: 1374
diff changeset
   106
    assert(sizeof(*ct->byte_map_base) == sizeof(jbyte), "adjust users of this code");
a980915cf495 6442502: assert(bits,"Use TypePtr for NULL") on linux-x86
never
parents: 1374
diff changeset
   107
    if (ct->byte_map_base != NULL) {
a980915cf495 6442502: assert(bits,"Use TypePtr for NULL") on linux-x86
never
parents: 1374
diff changeset
   108
      return makecon(TypeRawPtr::make((address)ct->byte_map_base));
a980915cf495 6442502: assert(bits,"Use TypePtr for NULL") on linux-x86
never
parents: 1374
diff changeset
   109
    } else {
a980915cf495 6442502: assert(bits,"Use TypePtr for NULL") on linux-x86
never
parents: 1374
diff changeset
   110
      return null();
a980915cf495 6442502: assert(bits,"Use TypePtr for NULL") on linux-x86
never
parents: 1374
diff changeset
   111
    }
a980915cf495 6442502: assert(bits,"Use TypePtr for NULL") on linux-x86
never
parents: 1374
diff changeset
   112
  }
a980915cf495 6442502: assert(bits,"Use TypePtr for NULL") on linux-x86
never
parents: 1374
diff changeset
   113
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
  jint  find_int_con(Node* n, jint value_if_unknown) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
    return _gvn.find_int_con(n, value_if_unknown);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  jlong find_long_con(Node* n, jlong value_if_unknown) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
    return _gvn.find_long_con(n, value_if_unknown);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  // (See also macro find_intptr_t_con in type.hpp, which uses one of these.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  // JVM State accessors:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  // Parser mapping from JVM indices into Nodes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  // Low slots are accessed by the StartNode::enum.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  // Then come the locals at StartNode::Parms to StartNode::Parms+max_locals();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  // Then come JVM stack slots.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  // Finally come the monitors, if any.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  // See layout accessors in class JVMState.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  SafePointNode*     map()      const { return _map; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  bool               has_exceptions() const { return _exceptions != NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  JVMState*          jvms()     const { return map_not_null()->_jvms; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  int                sp()       const { return _sp; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  int                bci()      const { return _bci; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  Bytecodes::Code    java_bc()  const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  ciMethod*          method()   const { return _method; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  void set_jvms(JVMState* jvms)       { set_map(jvms->map());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
                                        assert(jvms == this->jvms(), "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
                                        _sp = jvms->sp();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
                                        _bci = jvms->bci();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
                                        _method = jvms->has_method() ? jvms->method() : NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
  void set_map(SafePointNode* m)      { _map = m; debug_only(verify_map()); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  void set_sp(int i)                  { assert(i >= 0, "must be non-negative"); _sp = i; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  void clean_stack(int from_sp); // clear garbage beyond from_sp to top
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  void inc_sp(int i)                  { set_sp(sp() + i); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  void set_bci(int bci)               { _bci = bci; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  // Make sure jvms has current bci & sp.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  JVMState* sync_jvms()     const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  // Make sure JVMS has an updated copy of bci and sp.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  // Also sanity-check method, depth, and monitor depth.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  bool jvms_in_sync() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  // Make sure the map looks OK.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  void verify_map() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  // Make sure a proposed exception state looks OK.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  static void verify_exception_state(SafePointNode* ex_map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  // Clone the existing map state.  (Implements PreserveJVMState.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  SafePointNode* clone_map();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
  // Set the map to a clone of the given one.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  void set_map_clone(SafePointNode* m);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
  // Tell if the compilation is failing.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  bool failing() const { return C->failing(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  // Set _map to NULL, signalling a stop to further bytecode execution.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  // Preserve the map intact for future use, and return it back to the caller.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  SafePointNode* stop() { SafePointNode* m = map(); set_map(NULL); return m; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  // Stop, but first smash the map's inputs to NULL, to mark it dead.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  void stop_and_kill_map();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  // Tell if _map is NULL, or control is top.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  bool stopped();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  // Tell if this method or any caller method has exception handlers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  bool has_ex_handler();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
  // Save an exception without blowing stack contents or other JVM state.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  // (The extra pointer is stuck with add_req on the map, beyond the JVMS.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  static void set_saved_ex_oop(SafePointNode* ex_map, Node* ex_oop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  // Recover a saved exception from its map.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  static Node* saved_ex_oop(SafePointNode* ex_map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  // Recover a saved exception from its map, and remove it from the map.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  static Node* clear_saved_ex_oop(SafePointNode* ex_map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  // Recover a saved exception from its map, and remove it from the map.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  static bool has_saved_ex_oop(SafePointNode* ex_map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  // Push an exception in the canonical position for handlers (stack(0)).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
  void push_ex_oop(Node* ex_oop) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
    ensure_stack(1);  // ensure room to push the exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
    set_stack(0, ex_oop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
    set_sp(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
    clean_stack(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
  // Detach and return an exception state.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
  SafePointNode* pop_exception_state() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
    SafePointNode* ex_map = _exceptions;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
    if (ex_map != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
      _exceptions = ex_map->next_exception();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
      ex_map->set_next_exception(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
      debug_only(verify_exception_state(ex_map));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
    return ex_map;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
  // Add an exception, using the given JVM state, without commoning.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
  void push_exception_state(SafePointNode* ex_map) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
    debug_only(verify_exception_state(ex_map));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
    ex_map->set_next_exception(_exceptions);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
    _exceptions = ex_map;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
  // Turn the current JVM state into an exception state, appending the ex_oop.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
  SafePointNode* make_exception_state(Node* ex_oop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
  // Add an exception, using the given JVM state.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
  // Combine all exceptions with a common exception type into a single state.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
  // (This is done via combine_exception_states.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
  void add_exception_state(SafePointNode* ex_map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  // Combine all exceptions of any sort whatever into a single master state.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  SafePointNode* combine_and_pop_all_exception_states() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
    if (_exceptions == NULL)  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
    SafePointNode* phi_map = pop_exception_state();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
    SafePointNode* ex_map;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
    while ((ex_map = pop_exception_state()) != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
      combine_exception_states(ex_map, phi_map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
    return phi_map;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
  // Combine the two exception states, building phis as necessary.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
  // The second argument is updated to include contributions from the first.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
  void combine_exception_states(SafePointNode* ex_map, SafePointNode* phi_map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
  // Reset the map to the given state.  If there are any half-finished phis
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
  // in it (created by combine_exception_states), transform them now.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
  // Returns the exception oop.  (Caller must call push_ex_oop if required.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
  Node* use_exception_state(SafePointNode* ex_map);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  // Collect exceptions from a given JVM state into my exception list.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  void add_exception_states_from(JVMState* jvms);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
  // Collect all raised exceptions into the current JVM state.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
  // Clear the current exception list and map, returns the combined states.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
  JVMState* transfer_exceptions_into_jvms();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
  // Helper to throw a built-in exception.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
  // Range checks take the offending index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
  // Cast and array store checks take the offending class.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
  // Others do not take the optional argument.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
  // The JVMS must allow the bytecode to be re-executed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
  // via an uncommon trap.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
  void builtin_throw(Deoptimization::DeoptReason reason, Node* arg = NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
4761
bdb7375a1fee 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 4450
diff changeset
   270
  // Helper to check the JavaThread::_should_post_on_exceptions flag
bdb7375a1fee 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 4450
diff changeset
   271
  // and branch to an uncommon_trap if it is true (with the specified reason and must_throw)
bdb7375a1fee 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 4450
diff changeset
   272
  void uncommon_trap_if_should_post_on_exceptions(Deoptimization::DeoptReason reason,
bdb7375a1fee 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 4450
diff changeset
   273
                                                  bool must_throw) ;
bdb7375a1fee 6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents: 4450
diff changeset
   274
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
  // Helper Functions for adding debug information
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
  void kill_dead_locals();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
  bool dead_locals_are_killed();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
  // The call may deoptimize.  Supply required JVM state as debug info.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
  // If must_throw is true, the call is guaranteed not to return normally.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
  void add_safepoint_edges(SafePointNode* call,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
                           bool must_throw = false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
  // How many stack inputs does the current BC consume?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
  // And, how does the stack change after the bytecode?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
  // Returns false if unknown.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
  bool compute_stack_effects(int& inputs, int& depth);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
  // Add a fixed offset to a pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
  Node* basic_plus_adr(Node* base, Node* ptr, intptr_t offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
    return basic_plus_adr(base, ptr, MakeConX(offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
  Node* basic_plus_adr(Node* base, intptr_t offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
    return basic_plus_adr(base, base, MakeConX(offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  // Add a variable offset to a pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
  Node* basic_plus_adr(Node* base, Node* offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
    return basic_plus_adr(base, base, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  Node* basic_plus_adr(Node* base, Node* ptr, Node* offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   303
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   304
  // Some convenient shortcuts for common nodes
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   305
  Node* IfTrue(IfNode* iff)                   { return _gvn.transform(new (C,1) IfTrueNode(iff));      }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   306
  Node* IfFalse(IfNode* iff)                  { return _gvn.transform(new (C,1) IfFalseNode(iff));     }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   307
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   308
  Node* AddI(Node* l, Node* r)                { return _gvn.transform(new (C,3) AddINode(l, r));       }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   309
  Node* SubI(Node* l, Node* r)                { return _gvn.transform(new (C,3) SubINode(l, r));       }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   310
  Node* MulI(Node* l, Node* r)                { return _gvn.transform(new (C,3) MulINode(l, r));       }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   311
  Node* DivI(Node* ctl, Node* l, Node* r)     { return _gvn.transform(new (C,3) DivINode(ctl, l, r));  }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   312
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   313
  Node* AndI(Node* l, Node* r)                { return _gvn.transform(new (C,3) AndINode(l, r));       }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   314
  Node* OrI(Node* l, Node* r)                 { return _gvn.transform(new (C,3) OrINode(l, r));        }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   315
  Node* XorI(Node* l, Node* r)                { return _gvn.transform(new (C,3) XorINode(l, r));       }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   316
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   317
  Node* MaxI(Node* l, Node* r)                { return _gvn.transform(new (C,3) MaxINode(l, r));       }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   318
  Node* MinI(Node* l, Node* r)                { return _gvn.transform(new (C,3) MinINode(l, r));       }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   319
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   320
  Node* LShiftI(Node* l, Node* r)             { return _gvn.transform(new (C,3) LShiftINode(l, r));    }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   321
  Node* RShiftI(Node* l, Node* r)             { return _gvn.transform(new (C,3) RShiftINode(l, r));    }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   322
  Node* URShiftI(Node* l, Node* r)            { return _gvn.transform(new (C,3) URShiftINode(l, r));   }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   323
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   324
  Node* CmpI(Node* l, Node* r)                { return _gvn.transform(new (C,3) CmpINode(l, r));       }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   325
  Node* CmpL(Node* l, Node* r)                { return _gvn.transform(new (C,3) CmpLNode(l, r));       }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   326
  Node* CmpP(Node* l, Node* r)                { return _gvn.transform(new (C,3) CmpPNode(l, r));       }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   327
  Node* Bool(Node* cmp, BoolTest::mask relop) { return _gvn.transform(new (C,2) BoolNode(cmp, relop)); }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   328
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   329
  Node* AddP(Node* b, Node* a, Node* o)       { return _gvn.transform(new (C,4) AddPNode(b, a, o));    }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   330
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
  // Convert between int and long, and size_t.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
  // (See macros ConvI2X, etc., in type.hpp for ConvI2X, etc.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
  Node* ConvI2L(Node* offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
  Node* ConvL2I(Node* offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
  // Find out the klass of an object.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
  Node* load_object_klass(Node* object);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  // Find out the length of an array.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  Node* load_array_length(Node* array);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
  // Helper function to do a NULL pointer check or ZERO check based on type.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  Node* null_check_common(Node* value, BasicType type,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
                          bool assert_null, Node* *null_control);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  // Throw an exception if a given value is null.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  // Return the value cast to not-null.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  // Be clever about equivalent dominating null checks.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  Node* do_null_check(Node* value, BasicType type) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
    return null_check_common(value, type, false, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
  // Throw an uncommon trap if a given value is __not__ null.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
  // Return the value cast to null, and be clever about dominating checks.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
  Node* do_null_assert(Node* value, BasicType type) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
    return null_check_common(value, type, true, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
  // Null check oop.  Return null-path control into (*null_control).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
  // Return a cast-not-null node which depends on the not-null control.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
  // If never_see_null, use an uncommon trap (*null_control sees a top).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
  // The cast is not valid along the null path; keep a copy of the original.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
  Node* null_check_oop(Node* value, Node* *null_control,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
                       bool never_see_null = false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
6416
d49b65c9425a 6912064: type profiles need to be exploited more for dynamic language support
jrose
parents: 5547
diff changeset
   360
  // Check the null_seen bit.
d49b65c9425a 6912064: type profiles need to be exploited more for dynamic language support
jrose
parents: 5547
diff changeset
   361
  bool seems_never_null(Node* obj, ciProfileData* data);
d49b65c9425a 6912064: type profiles need to be exploited more for dynamic language support
jrose
parents: 5547
diff changeset
   362
d49b65c9425a 6912064: type profiles need to be exploited more for dynamic language support
jrose
parents: 5547
diff changeset
   363
  // Use the type profile to narrow an object type.
d49b65c9425a 6912064: type profiles need to be exploited more for dynamic language support
jrose
parents: 5547
diff changeset
   364
  Node* maybe_cast_profiled_receiver(Node* not_null_obj,
d49b65c9425a 6912064: type profiles need to be exploited more for dynamic language support
jrose
parents: 5547
diff changeset
   365
                                     ciProfileData* data,
d49b65c9425a 6912064: type profiles need to be exploited more for dynamic language support
jrose
parents: 5547
diff changeset
   366
                                     ciKlass* require_klass);
d49b65c9425a 6912064: type profiles need to be exploited more for dynamic language support
jrose
parents: 5547
diff changeset
   367
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
  // Cast obj to not-null on this path
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
  Node* cast_not_null(Node* obj, bool do_replace_in_map = true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
  // Replace all occurrences of one node by another.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
  void replace_in_map(Node* old, Node* neww);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
  void push(Node* n)    { map_not_null(); _map->set_stack(_map->_jvms,_sp++,n); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
  Node* pop()           { map_not_null(); return _map->stack(_map->_jvms,--_sp); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  Node* peek(int off=0) { map_not_null(); return _map->stack(_map->_jvms, _sp - off - 1); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
  void push_pair(Node* ldval) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
    push(ldval);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
    push(top());  // the halfword is merely a placeholder
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
  void push_pair_local(int i) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
    // longs are stored in locals in "push" order
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
    push(  local(i+0) );  // the real value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
    assert(local(i+1) == top(), "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
    push(top());  // halfword placeholder
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
  Node* pop_pair() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
    // the second half is pushed last & popped first; it contains exactly nothing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
    Node* halfword = pop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
    assert(halfword == top(), "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
    // the long bits are pushed first & popped last:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
    return pop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
  void set_pair_local(int i, Node* lval) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
    // longs are stored in locals as a value/half pair (like doubles)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
    set_local(i+0, lval);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
    set_local(i+1, top());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
  // Push the node, which may be zero, one, or two words.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
  void push_node(BasicType n_type, Node* n) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
    int n_size = type2size[n_type];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
    if      (n_size == 1)  push(      n );  // T_INT, ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
    else if (n_size == 2)  push_pair( n );  // T_DOUBLE, T_LONG
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
    else                   { assert(n_size == 0, "must be T_VOID"); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
  Node* pop_node(BasicType n_type) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
    int n_size = type2size[n_type];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
    if      (n_size == 1)  return pop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
    else if (n_size == 2)  return pop_pair();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
    else                   return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
  Node* control()               const { return map_not_null()->control(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
  Node* i_o()                   const { return map_not_null()->i_o(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  Node* returnadr()             const { return map_not_null()->returnadr(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
  Node* frameptr()              const { return map_not_null()->frameptr(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
  Node* local(uint idx)         const { map_not_null(); return _map->local(      _map->_jvms, idx); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
  Node* stack(uint idx)         const { map_not_null(); return _map->stack(      _map->_jvms, idx); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
  Node* argument(uint idx)      const { map_not_null(); return _map->argument(   _map->_jvms, idx); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
  Node* monitor_box(uint idx)   const { map_not_null(); return _map->monitor_box(_map->_jvms, idx); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
  Node* monitor_obj(uint idx)   const { map_not_null(); return _map->monitor_obj(_map->_jvms, idx); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
  void set_control  (Node* c)         { map_not_null()->set_control(c); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
  void set_i_o      (Node* c)         { map_not_null()->set_i_o(c); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
  void set_local(uint idx, Node* c)   { map_not_null(); _map->set_local(   _map->_jvms, idx, c); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
  void set_stack(uint idx, Node* c)   { map_not_null(); _map->set_stack(   _map->_jvms, idx, c); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
  void set_argument(uint idx, Node* c){ map_not_null(); _map->set_argument(_map->_jvms, idx, c); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
  void ensure_stack(uint stk_size)    { map_not_null(); _map->ensure_stack(_map->_jvms, stk_size); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
  // Access unaliased memory
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
  Node* memory(uint alias_idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
  Node* memory(const TypePtr *tp) { return memory(C->get_alias_index(tp)); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
  Node* memory(Node* adr) { return memory(_gvn.type(adr)->is_ptr()); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
  // Access immutable memory
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
  Node* immutable_memory() { return C->immutable_memory(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
  // Set unaliased memory
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
  void set_memory(Node* c, uint alias_idx) { merged_memory()->set_memory_at(alias_idx, c); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
  void set_memory(Node* c, const TypePtr *tp) { set_memory(c,C->get_alias_index(tp)); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
  void set_memory(Node* c, Node* adr) { set_memory(c,_gvn.type(adr)->is_ptr()); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
  // Get the entire memory state (probably a MergeMemNode), and reset it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
  // (The resetting prevents somebody from using the dangling Node pointer.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  Node* reset_memory();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
  // Get the entire memory state, asserted to be a MergeMemNode.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
  MergeMemNode* merged_memory() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
    Node* mem = map_not_null()->memory();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
    assert(mem->is_MergeMem(), "parse memory is always pre-split");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
    return mem->as_MergeMem();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
  // Set the entire memory state; produce a new MergeMemNode.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
  void set_all_memory(Node* newmem);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
  // Create a memory projection from the call, then set_all_memory.
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   460
  void set_all_memory_call(Node* call, bool separate_io_proj = false);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
  // Create a LoadNode, reading from the parser's memory state.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
  // (Note:  require_atomic_access is useful only with T_LONG.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
  Node* make_load(Node* ctl, Node* adr, const Type* t, BasicType bt,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
                  bool require_atomic_access = false) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
    // This version computes alias_index from bottom_type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
    return make_load(ctl, adr, t, bt, adr->bottom_type()->is_ptr(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
                     require_atomic_access);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
  Node* make_load(Node* ctl, Node* adr, const Type* t, BasicType bt, const TypePtr* adr_type, bool require_atomic_access = false) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
    // This version computes alias_index from an address type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
    assert(adr_type != NULL, "use other make_load factory");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
    return make_load(ctl, adr, t, bt, C->get_alias_index(adr_type),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
                     require_atomic_access);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
  // This is the base version which is given an alias index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
  Node* make_load(Node* ctl, Node* adr, const Type* t, BasicType bt, int adr_idx, bool require_atomic_access = false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
  // Create & transform a StoreNode and store the effect into the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
  // parser's memory state.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
  Node* store_to_memory(Node* ctl, Node* adr, Node* val, BasicType bt,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
                        const TypePtr* adr_type,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
                        bool require_atomic_access = false) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
    // This version computes alias_index from an address type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
    assert(adr_type != NULL, "use other store_to_memory factory");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
    return store_to_memory(ctl, adr, val, bt,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
                           C->get_alias_index(adr_type),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
                           require_atomic_access);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
  // This is the base version which is given alias index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
  // Return the new StoreXNode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
  Node* store_to_memory(Node* ctl, Node* adr, Node* val, BasicType bt,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
                        int adr_idx,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
                        bool require_atomic_access = false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
  // All in one pre-barrier, store, post_barrier
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
  // Insert a write-barrier'd store.  This is to let generational GC
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
  // work; we have to flag all oop-stores before the next GC point.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
  // It comes in 3 flavors of store to an object, array, or unknown.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
  // We use precise card marks for arrays to avoid scanning the entire
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
  // array. We use imprecise for object. We use precise for unknown
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
  // since we don't know if we have an array or and object or even
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
  // where the object starts.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
  // If val==NULL, it is taken to be a completely unknown value. QQQ
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
3268
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 3178
diff changeset
   509
  Node* store_oop(Node* ctl,
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 3178
diff changeset
   510
                  Node* obj,   // containing obj
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 3178
diff changeset
   511
                  Node* adr,  // actual adress to store val at
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 3178
diff changeset
   512
                  const TypePtr* adr_type,
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 3178
diff changeset
   513
                  Node* val,
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 3178
diff changeset
   514
                  const TypeOopPtr* val_type,
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 3178
diff changeset
   515
                  BasicType bt,
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 3178
diff changeset
   516
                  bool use_precise);
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 3178
diff changeset
   517
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
  Node* store_oop_to_object(Node* ctl,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
                            Node* obj,   // containing obj
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
                            Node* adr,  // actual adress to store val at
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
                            const TypePtr* adr_type,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
                            Node* val,
3178
596a9ab2a92d 6818666: G1: Type lost in g1 pre-barrier
never
parents: 2574
diff changeset
   523
                            const TypeOopPtr* val_type,
3268
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 3178
diff changeset
   524
                            BasicType bt) {
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 3178
diff changeset
   525
    return store_oop(ctl, obj, adr, adr_type, val, val_type, bt, false);
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 3178
diff changeset
   526
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
  Node* store_oop_to_array(Node* ctl,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
                           Node* obj,   // containing obj
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
                           Node* adr,  // actual adress to store val at
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
                           const TypePtr* adr_type,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
                           Node* val,
3178
596a9ab2a92d 6818666: G1: Type lost in g1 pre-barrier
never
parents: 2574
diff changeset
   533
                           const TypeOopPtr* val_type,
3268
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 3178
diff changeset
   534
                           BasicType bt) {
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 3178
diff changeset
   535
    return store_oop(ctl, obj, adr, adr_type, val, val_type, bt, true);
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 3178
diff changeset
   536
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
  // Could be an array or object we don't know at compile time (unsafe ref.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
  Node* store_oop_to_unknown(Node* ctl,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
                             Node* obj,   // containing obj
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
                             Node* adr,  // actual adress to store val at
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
                             const TypePtr* adr_type,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
                             Node* val,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
                             BasicType bt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
  // For the few case where the barriers need special help
9176
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8732
diff changeset
   547
  void pre_barrier(bool do_load, Node* ctl,
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8732
diff changeset
   548
                   Node* obj, Node* adr, uint adr_idx, Node* val, const TypeOopPtr* val_type,
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8732
diff changeset
   549
                   Node* pre_val,
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8732
diff changeset
   550
                   BasicType bt);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
  void post_barrier(Node* ctl, Node* store, Node* obj, Node* adr, uint adr_idx,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
                    Node* val, BasicType bt, bool use_precise);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
  // Return addressing for an array element.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  Node* array_element_address(Node* ary, Node* idx, BasicType elembt,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
                              // Optional constraint on the array size:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
                              const TypeInt* sizetype = NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
  // Return a load of array element at idx.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
  Node* load_array_element(Node* ctl, Node* ary, Node* idx, const TypeAryPtr* arytype);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
  //---------------- Dtrace support --------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
  void make_dtrace_method_entry_exit(ciMethod* method, bool is_entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
  void make_dtrace_method_entry(ciMethod* method) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
    make_dtrace_method_entry_exit(method, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
  void make_dtrace_method_exit(ciMethod* method) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
    make_dtrace_method_entry_exit(method, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
  //--------------- stub generation -------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
  void gen_stub(address C_function,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
                const char *name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
                int is_fancy_jump,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
                bool pass_tls,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
                bool return_pc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
  //---------- help for generating calls --------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
  // Do a null check on the receiver, which is in argument(0).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
  Node* null_check_receiver(ciMethod* callee) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
    assert(!callee->is_static(), "must be a virtual method");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
    int nargs = 1 + callee->signature()->size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
    // Null check on self without removing any arguments.  The argument
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
    // null check technically happens in the wrong place, which can lead to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
    // invalid stack traces when the primitive is inlined into a method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
    // which handles NullPointerExceptions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
    Node* receiver = argument(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
    _sp += nargs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
    receiver = do_null_check(receiver, T_OBJECT);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
    _sp -= nargs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
    return receiver;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
  // Fill in argument edges for the call from argument(0), argument(1), ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
  // (The next step is to call set_edges_for_java_call.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
  void  set_arguments_for_java_call(CallJavaNode* call);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
  // Fill in non-argument edges for the call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
  // Transform the call, and update the basics: control, i_o, memory.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
  // (The next step is usually to call set_results_for_java_call.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
  void set_edges_for_java_call(CallJavaNode* call,
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   605
                               bool must_throw = false, bool separate_io_proj = false);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
  // Finish up a java call that was started by set_edges_for_java_call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
  // Call add_exception on any throw arising from the call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
  // Return the call result (transformed).
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   610
  Node* set_results_for_java_call(CallJavaNode* call, bool separate_io_proj = false);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
  // Similar to set_edges_for_java_call, but simplified for runtime calls.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
  void  set_predefined_output_for_runtime_call(Node* call) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
    set_predefined_output_for_runtime_call(call, NULL, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
  void  set_predefined_output_for_runtime_call(Node* call,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
                                               Node* keep_mem,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
                                               const TypePtr* hook_mem);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
  Node* set_predefined_input_for_runtime_call(SafePointNode* call);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   621
  // Replace the call with the current state of the kit.  Requires
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   622
  // that the call was generated with separate io_projs so that
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   623
  // exceptional control flow can be handled properly.
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   624
  void replace_call(CallNode* call, Node* result);
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3904
diff changeset
   625
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
  // helper functions for statistics
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
  void increment_counter(address counter_addr);   // increment a debug counter
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
  void increment_counter(Node*   counter_addr);   // increment a debug counter
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
  // Bail out to the interpreter right now
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
  // The optional klass is the one causing the trap.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
  // The optional reason is debug information written to the compile log.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
  // Optional must_throw is the same as with add_safepoint_edges.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
  void uncommon_trap(int trap_request,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
                     ciKlass* klass = NULL, const char* reason_string = NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
                     bool must_throw = false, bool keep_exact_action = false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
  // Shorthand, to avoid saying "Deoptimization::" so many times.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
  void uncommon_trap(Deoptimization::DeoptReason reason,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
                     Deoptimization::DeoptAction action,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
                     ciKlass* klass = NULL, const char* reason_string = NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
                     bool must_throw = false, bool keep_exact_action = false) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
    uncommon_trap(Deoptimization::make_trap_request(reason, action),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
                  klass, reason_string, must_throw, keep_exact_action);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
  // Report if there were too many traps at the current method and bci.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
  // Report if a trap was recorded, and/or PerMethodTrapLimit was exceeded.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
  // If there is no MDO at all, report no trap unless told to assume it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
  bool too_many_traps(Deoptimization::DeoptReason reason) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
    return C->too_many_traps(method(), bci(), reason);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
  // Report if there were too many recompiles at the current method and bci.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
  bool too_many_recompiles(Deoptimization::DeoptReason reason) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
    return C->too_many_recompiles(method(), bci(), reason);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
  // Returns the object (if any) which was created the moment before.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
  Node* just_allocated_object(Node* current_control);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
  static bool use_ReduceInitialCardMarks() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
    return (ReduceInitialCardMarks
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
            && Universe::heap()->can_elide_tlab_store_barriers());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
3268
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 3178
diff changeset
   667
  void sync_kit(IdealKit& ideal);
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 3178
diff changeset
   668
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 3178
diff changeset
   669
  // vanilla/CMS post barrier
3904
007a45522a7f 6877254: Server vm crashes with no branches off of store slice" when run with CMS and UseSuperWord(default)
cfang
parents: 3600
diff changeset
   670
  void write_barrier_post(Node *store, Node* obj,
007a45522a7f 6877254: Server vm crashes with no branches off of store slice" when run with CMS and UseSuperWord(default)
cfang
parents: 3600
diff changeset
   671
                          Node* adr,  uint adr_idx, Node* val, bool use_precise);
3268
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 3178
diff changeset
   672
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   673
  // G1 pre/post barriers
9176
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8732
diff changeset
   674
  void g1_write_barrier_pre(bool do_load,
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8732
diff changeset
   675
                            Node* obj,
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   676
                            Node* adr,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   677
                            uint alias_idx,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   678
                            Node* val,
3178
596a9ab2a92d 6818666: G1: Type lost in g1 pre-barrier
never
parents: 2574
diff changeset
   679
                            const TypeOopPtr* val_type,
9176
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8732
diff changeset
   680
                            Node* pre_val,
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   681
                            BasicType bt);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   682
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   683
  void g1_write_barrier_post(Node* store,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   684
                             Node* obj,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   685
                             Node* adr,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   686
                             uint alias_idx,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   687
                             Node* val,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   688
                             BasicType bt,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   689
                             bool use_precise);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   690
  // Helper function for g1
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   691
  private:
3904
007a45522a7f 6877254: Server vm crashes with no branches off of store slice" when run with CMS and UseSuperWord(default)
cfang
parents: 3600
diff changeset
   692
  void g1_mark_card(IdealKit& ideal, Node* card_adr, Node* store, uint oop_alias_idx,
007a45522a7f 6877254: Server vm crashes with no branches off of store slice" when run with CMS and UseSuperWord(default)
cfang
parents: 3600
diff changeset
   693
                    Node* index, Node* index_adr,
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   694
                    Node* buffer, const TypeFunc* tf);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   695
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   696
  public:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
  // Helper function to round double arguments before a call
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
  void round_double_arguments(ciMethod* dest_method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
  void round_double_result(ciMethod* dest_method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
  // rounding for strict float precision conformance
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
  Node* precision_rounding(Node* n);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
  // rounding for strict double precision conformance
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
  Node* dprecision_rounding(Node* n);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
  // rounding for non-strict double stores
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
  Node* dstore_rounding(Node* n);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
  // Helper functions for fast/slow path codes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
  Node* opt_iff(Node* region, Node* iff);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
  Node* make_runtime_call(int flags,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
                          const TypeFunc* call_type, address call_addr,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
                          const char* call_name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
                          const TypePtr* adr_type, // NULL if no memory effects
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
                          Node* parm0 = NULL, Node* parm1 = NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
                          Node* parm2 = NULL, Node* parm3 = NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
                          Node* parm4 = NULL, Node* parm5 = NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
                          Node* parm6 = NULL, Node* parm7 = NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
  enum {  // flag values for make_runtime_call
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
    RC_NO_FP = 1,               // CallLeafNoFPNode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
    RC_NO_IO = 2,               // do not hook IO edges
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
    RC_NO_LEAF = 4,             // CallStaticJavaNode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
    RC_MUST_THROW = 8,          // flag passed to add_safepoint_edges
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
    RC_NARROW_MEM = 16,         // input memory is same as output
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
    RC_UNCOMMON = 32,           // freq. expected to be like uncommon trap
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
    RC_LEAF = 0                 // null value:  no flags set
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
  // merge in all memory slices from new_mem, along the given path
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
  void merge_memory(Node* new_mem, Node* region, int new_path);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
  void make_slow_call_ex(Node* call, ciInstanceKlass* ex_klass, bool separate_io_proj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
  // Helper functions to build synchronizations
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
  int next_monitor();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
  Node* insert_mem_bar(int opcode, Node* precedent = NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
  Node* insert_mem_bar_volatile(int opcode, int alias_idx, Node* precedent = NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
  // Optional 'precedent' is appended as an extra edge, to force ordering.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
  FastLockNode* shared_lock(Node* obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
  void shared_unlock(Node* box, Node* obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
  // helper functions for the fast path/slow path idioms
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
  Node* fast_and_slow(Node* in, const Type *result_type, Node* null_result, IfNode* fast_test, Node* fast_result, address slow_call, const TypeFunc *slow_call_type, Node* slow_arg, klassOop ex_klass, Node* slow_result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
  // Generate an instance-of idiom.  Used by both the instance-of bytecode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
  // and the reflective instance-of call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
  Node* gen_instanceof( Node *subobj, Node* superkls );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
  // Generate a check-cast idiom.  Used by both the check-cast bytecode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
  // and the array-store bytecode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
  Node* gen_checkcast( Node *subobj, Node* superkls,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
                       Node* *failure_control = NULL );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
  // Generate a subtyping check.  Takes as input the subtype and supertype.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
  // Returns 2 values: sets the default control() to the true path and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
  // returns the false path.  Only reads from constant memory taken from the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
  // default memory; does not write anything.  It also doesn't take in an
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
  // Object; if you wish to check an Object you need to load the Object's
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
  // class prior to coming here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
  Node* gen_subtype_check(Node* subklass, Node* superklass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
  // Static parse-time type checking logic for gen_subtype_check:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
  enum { SSC_always_false, SSC_always_true, SSC_easy_test, SSC_full_test };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
  int static_subtype_check(ciKlass* superk, ciKlass* subk);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
  // Exact type check used for predicted calls and casts.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
  // Rewrites (*casted_receiver) to be casted to the stronger type.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
  // (Caller is responsible for doing replace_in_map.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
  Node* type_check_receiver(Node* receiver, ciKlass* klass, float prob,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
                            Node* *casted_receiver);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
  // implementation of object creation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
  Node* set_output_for_allocation(AllocateNode* alloc,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
                                  const TypeOopPtr* oop_type,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
                                  bool raw_mem_only);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
  Node* get_layout_helper(Node* klass_node, jint& constant_value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
  Node* new_instance(Node* klass_node,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
                     Node* slow_test = NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
                     bool raw_mem_only = false,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
                     Node* *return_size_val = NULL);
2574
1d5f85c2d755 6589834: deoptimization problem with -XX:+DeoptimizeALot
cfang
parents: 2105
diff changeset
   781
  Node* new_array(Node* klass_node, Node* count_val, int nargs,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
                  bool raw_mem_only = false, Node* *return_size_val = NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
  // Handy for making control flow
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
  IfNode* create_and_map_if(Node* ctrl, Node* tst, float prob, float cnt) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
    IfNode* iff = new (C, 2) IfNode(ctrl, tst, prob, cnt);// New IfNode's
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
    _gvn.set_type(iff, iff->Value(&_gvn)); // Value may be known at parse-time
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
    // Place 'if' on worklist if it will be in graph
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
    if (!tst->is_Con())  record_for_igvn(iff);     // Range-check and Null-check removal is later
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
    return iff;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
  IfNode* create_and_xform_if(Node* ctrl, Node* tst, float prob, float cnt) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
    IfNode* iff = new (C, 2) IfNode(ctrl, tst, prob, cnt);// New IfNode's
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
    _gvn.transform(iff);                           // Value may be known at parse-time
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
    // Place 'if' on worklist if it will be in graph
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
    if (!tst->is_Con())  record_for_igvn(iff);     // Range-check and Null-check removal is later
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
    return iff;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
  }
8732
16fc1c68714b 7008866: Missing loop predicate for loop with multiple entries
kvn
parents: 7397
diff changeset
   800
16fc1c68714b 7008866: Missing loop predicate for loop with multiple entries
kvn
parents: 7397
diff changeset
   801
  // Insert a loop predicate into the graph
16fc1c68714b 7008866: Missing loop predicate for loop with multiple entries
kvn
parents: 7397
diff changeset
   802
  void add_predicate(int nargs = 0);
16fc1c68714b 7008866: Missing loop predicate for loop with multiple entries
kvn
parents: 7397
diff changeset
   803
  void add_predicate_impl(Deoptimization::DeoptReason reason, int nargs);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
// Helper class to support building of control flow branches. Upon
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
// creation the map and sp at bci are cloned and restored upon de-
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
// struction. Typical use:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
// { PreserveJVMState pjvms(this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
//   // code of new branch
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
// }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
// // here the JVM state at bci is established
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
class PreserveJVMState: public StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
  GraphKit*      _kit;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
  int            _block;  // PO of current block, if a Parse
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
  int            _bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
  SafePointNode* _map;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
  uint           _sp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
  PreserveJVMState(GraphKit* kit, bool clone_map = true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
  ~PreserveJVMState();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
// Helper class to build cutouts of the form if (p) ; else {x...}.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
// The code {x...} must not fall through.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
// The kit's main flow of control is set to the "then" continuation of if(p).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
class BuildCutout: public PreserveJVMState {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
  BuildCutout(GraphKit* kit, Node* p, float prob, float cnt = COUNT_UNKNOWN);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
  ~BuildCutout();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
};
3600
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 3268
diff changeset
   838
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 3268
diff changeset
   839
// Helper class to preserve the original _reexecute bit and _sp and restore
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 3268
diff changeset
   840
// them back
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 3268
diff changeset
   841
class PreserveReexecuteState: public StackObj {
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 3268
diff changeset
   842
 protected:
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 3268
diff changeset
   843
  GraphKit*                 _kit;
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 3268
diff changeset
   844
  uint                      _sp;
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 3268
diff changeset
   845
  JVMState::ReexecuteState  _reexecute;
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 3268
diff changeset
   846
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 3268
diff changeset
   847
 public:
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 3268
diff changeset
   848
  PreserveReexecuteState(GraphKit* kit);
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 3268
diff changeset
   849
  ~PreserveReexecuteState();
27aa4477d039 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents: 3268
diff changeset
   850
};
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6416
diff changeset
   851
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6416
diff changeset
   852
#endif // SHARE_VM_OPTO_GRAPHKIT_HPP