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