Tue, 11 Nov 2014 11:05:41 +0100
8056071: compiler/whitebox/IsMethodCompilableTest.java fails with 'method() is not compilable after 3 iterations'
Summary: Always use MDO if valid and always compile trivial methods with C1 if available.
Reviewed-by: kvn, iveresov
1 /*
2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
25 #ifndef SHARE_VM_OOPS_TYPEARRAYKLASS_HPP
26 #define SHARE_VM_OOPS_TYPEARRAYKLASS_HPP
28 #include "classfile/classLoaderData.hpp"
29 #include "oops/arrayKlass.hpp"
31 // A TypeArrayKlass is the klass of a typeArray
32 // It contains the type and size of the elements
34 class TypeArrayKlass : public ArrayKlass {
35 friend class VMStructs;
36 private:
37 jint _max_length; // maximum number of elements allowed in an array
39 // Constructor
40 TypeArrayKlass(BasicType type, Symbol* name);
41 static TypeArrayKlass* allocate(ClassLoaderData* loader_data, BasicType type, Symbol* name, TRAPS);
42 public:
43 TypeArrayKlass() {} // For dummy objects.
45 // instance variables
46 jint max_length() { return _max_length; }
47 void set_max_length(jint m) { _max_length = m; }
49 // testers
50 bool oop_is_typeArray_slow() const { return true; }
52 // klass allocation
53 static TypeArrayKlass* create_klass(BasicType type, const char* name_str,
54 TRAPS);
55 static inline Klass* create_klass(BasicType type, int scale, TRAPS) {
56 TypeArrayKlass* tak = create_klass(type, external_name(type), CHECK_NULL);
57 assert(scale == (1 << tak->log2_element_size()), "scale must check out");
58 return tak;
59 }
61 int oop_size(oop obj) const;
63 bool compute_is_subtype_of(Klass* k);
65 // Allocation
66 typeArrayOop allocate_common(int length, bool do_zero, TRAPS);
67 typeArrayOop allocate(int length, TRAPS) { return allocate_common(length, true, THREAD); }
68 oop multi_allocate(int rank, jint* sizes, TRAPS);
70 oop protection_domain() const { return NULL; }
72 // Copying
73 void copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS);
75 // Iteration
76 int oop_oop_iterate(oop obj, ExtendedOopClosure* blk);
77 int oop_oop_iterate_m(oop obj, ExtendedOopClosure* blk, MemRegion mr);
79 // Garbage collection
80 void oop_follow_contents(oop obj);
81 int oop_adjust_pointers(oop obj);
83 // Parallel Scavenge and Parallel Old
84 PARALLEL_GC_DECLS
86 protected:
87 // Find n'th dimensional array
88 virtual Klass* array_klass_impl(bool or_null, int n, TRAPS);
90 // Returns the array class with this class as element type
91 virtual Klass* array_klass_impl(bool or_null, TRAPS);
93 public:
94 // Casting from Klass*
95 static TypeArrayKlass* cast(Klass* k) {
96 assert(k->oop_is_typeArray(), "cast to TypeArrayKlass");
97 return (TypeArrayKlass*) k;
98 }
100 // Naming
101 static const char* external_name(BasicType type);
103 // Sizing
104 static int header_size() { return sizeof(TypeArrayKlass)/HeapWordSize; }
105 int size() const { return ArrayKlass::static_size(header_size()); }
107 // Initialization (virtual from Klass)
108 void initialize(TRAPS);
110 public:
111 // Printing
112 #ifndef PRODUCT
113 void oop_print_on(oop obj, outputStream* st);
114 #endif
116 void print_on(outputStream* st) const;
117 void print_value_on(outputStream* st) const;
119 public:
120 const char* internal_name() const;
121 };
123 #endif // SHARE_VM_OOPS_TYPEARRAYKLASS_HPP