bcEscapeAnalyzer.hpp 5.4 KB
Newer Older
D
duke 已提交
1
/*
2
 * Copyright (c) 2005, 2012, Oracle and/or its affiliates. All rights reserved.
D
duke 已提交
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
19 20 21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
D
duke 已提交
22 23 24
 *
 */

25 26 27 28
#ifndef SHARE_VM_CI_BCESCAPEANALYZER_HPP
#define SHARE_VM_CI_BCESCAPEANALYZER_HPP

#ifdef COMPILER2
29
#include "ci/ciObject.hpp"
30 31 32 33 34 35 36 37
#include "ci/ciMethod.hpp"
#include "ci/ciMethodData.hpp"
#include "code/dependencies.hpp"
#include "libadt/vectset.hpp"
#include "memory/allocation.hpp"
#include "utilities/growableArray.hpp"
#endif

D
duke 已提交
38 39 40 41 42 43 44 45 46
// This class implements a fast, conservative analysis of effect of methods
// on the escape state of their arguments.  The analysis is at the bytecode
// level.

class  ciMethodBlocks;
class  ciBlock;

class BCEscapeAnalyzer : public ResourceObj {
 private:
47 48
  Arena*            _arena;        // ciEnv arena

D
duke 已提交
49 50 51 52 53
  bool              _conservative; // If true, return maximally
                                   // conservative results.
  ciMethod*         _method;
  ciMethodData*     _methodData;
  int               _arg_size;
54 55 56 57
  VectorSet         _arg_local;
  VectorSet         _arg_stack;
  VectorSet         _arg_returned;
  VectorSet         _dirty;
58 59
  enum{ ARG_OFFSET_MAX = 31};
  uint              *_arg_modified;
D
duke 已提交
60 61

  bool              _return_local;
62
  bool              _return_allocated;
D
duke 已提交
63
  bool              _allocated_escapes;
64
  bool              _unknown_modified;
D
duke 已提交
65

66
  GrowableArray<ciMetadata *> _dependencies;
D
duke 已提交
67 68 69 70 71 72

  ciMethodBlocks   *_methodBlocks;

  BCEscapeAnalyzer* _parent;
  int               _level;

73
 public:
D
duke 已提交
74 75 76
  class  ArgumentMap;
  class  StateInfo;

77
 private:
D
duke 已提交
78 79 80 81 82
  // helper functions
  bool is_argument(int i)    { return i >= 0 && i < _arg_size; }
  void set_returned(ArgumentMap vars);
  bool is_argument(ArgumentMap vars);
  bool is_arg_stack(ArgumentMap vars);
83
  void clear_bits(ArgumentMap vars, VectorSet &bs);
D
duke 已提交
84
  void set_method_escape(ArgumentMap vars);
85
  void set_global_escape(ArgumentMap vars, bool merge = false);
D
duke 已提交
86
  void set_dirty(ArgumentMap vars);
87
  void set_modified(ArgumentMap vars, int offs, int size);
D
duke 已提交
88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117

  bool is_recursive_call(ciMethod* callee);
  void add_dependence(ciKlass *klass, ciMethod *meth);
  void propagate_dependencies(ciMethod *meth);
  void invoke(StateInfo &state, Bytecodes::Code code, ciMethod* target, ciKlass* holder);

  void iterate_one_block(ciBlock *blk, StateInfo &state, GrowableArray<ciBlock *> &successors);
  void iterate_blocks(Arena *);
  void merge_block_states(StateInfo *blockstates, ciBlock *dest, StateInfo *s_state);

  // analysis
  void initialize();
  void clear_escape_info();
  void compute_escape_info();
  vmIntrinsics::ID known_intrinsic();
  bool compute_escape_for_intrinsic(vmIntrinsics::ID iid);
  bool do_analysis();

  void read_escape_info();

  bool contains(uint arg_set1, uint arg_set2);

 public:
  BCEscapeAnalyzer(ciMethod* method, BCEscapeAnalyzer* parent = NULL);

  // accessors
  ciMethod*         method() const               { return _method; }
  ciMethodData*     methodData() const           { return _methodData; }
  BCEscapeAnalyzer* parent() const               { return _parent; }
  int               level() const                { return _level; }
118
  GrowableArray<ciMetadata *>* dependencies()    { return &_dependencies; }
D
duke 已提交
119 120 121 122 123 124
  bool              has_dependencies() const     { return !_dependencies.is_empty(); }

  // retrieval of interprocedural escape information

  // The given argument does not escape the callee.
  bool is_arg_local(int i) const {
125
    return !_conservative && _arg_local.test(i);
D
duke 已提交
126 127 128 129 130
  }

  // The given argument escapes the callee, but does not become globally
  // reachable.
  bool is_arg_stack(int i) const {
131
    return !_conservative && _arg_stack.test(i);
D
duke 已提交
132 133 134 135
  }

  // The given argument does not escape globally, and may be returned.
  bool is_arg_returned(int i) const {
136
    return !_conservative && _arg_returned.test(i); }
D
duke 已提交
137 138 139 140 141 142 143 144 145 146 147

  // True iff only input arguments are returned.
  bool is_return_local() const {
    return !_conservative && _return_local;
  }

  // True iff only newly allocated unescaped objects are returned.
  bool is_return_allocated() const {
    return !_conservative && _return_allocated && !_allocated_escapes;
  }

148 149 150 151 152 153 154
  // Tracking of argument modification

  enum {OFFSET_ANY = -1};
  bool is_arg_modified(int arg, int offset, int size_in_bytes);
  void set_arg_modified(int arg, int offset, int size_in_bytes);
  bool has_non_arg_side_affects()    { return _unknown_modified; }

D
duke 已提交
155 156
  // Copy dependencies from this analysis into "deps"
  void copy_dependencies(Dependencies *deps);
157 158 159 160 161

#ifndef PRODUCT
  // dump escape information
  void dump();
#endif
D
duke 已提交
162
};
163 164

#endif // SHARE_VM_CI_BCESCAPEANALYZER_HPP