28 #include "memory/oopFactory.hpp" |
28 #include "memory/oopFactory.hpp" |
29 |
29 |
30 // ------------------------------------------------------------------ |
30 // ------------------------------------------------------------------ |
31 // ciSymbol::ciSymbol |
31 // ciSymbol::ciSymbol |
32 // |
32 // |
33 // Preallocated handle variant. Used with handles from vmSymboHandles. |
33 // Preallocated symbol variant. Used with symbols from vmSymbols. |
34 ciSymbol::ciSymbol(symbolHandle h_s, vmSymbols::SID sid) |
34 ciSymbol::ciSymbol(Symbol* s, vmSymbols::SID sid) |
35 : ciObject(h_s), _sid(sid) |
35 : _symbol(s), _sid(sid) |
36 { |
36 { |
|
37 assert(_symbol != NULL, "adding null symbol"); |
|
38 _symbol->increment_refcount(); // increment ref count |
37 assert(sid_ok(), "must be in vmSymbols"); |
39 assert(sid_ok(), "must be in vmSymbols"); |
38 } |
40 } |
39 |
41 |
40 // Normal case for non-famous symbols. |
42 // Normal case for non-famous symbols. |
41 ciSymbol::ciSymbol(symbolOop s) |
43 ciSymbol::ciSymbol(Symbol* s) |
42 : ciObject(s), _sid(vmSymbols::NO_SID) |
44 : _symbol(s), _sid(vmSymbols::NO_SID) |
43 { |
45 { |
|
46 assert(_symbol != NULL, "adding null symbol"); |
|
47 _symbol->increment_refcount(); // increment ref count |
44 assert(sid_ok(), "must not be in vmSymbols"); |
48 assert(sid_ok(), "must not be in vmSymbols"); |
45 } |
49 } |
46 |
50 |
47 // ciSymbol |
51 // ciSymbol |
48 // |
52 // |
49 // This class represents a symbolOop in the HotSpot virtual |
53 // This class represents a Symbol* in the HotSpot virtual |
50 // machine. |
54 // machine. |
51 |
55 |
52 // ------------------------------------------------------------------ |
56 // ------------------------------------------------------------------ |
53 // ciSymbol::as_utf8 |
57 // ciSymbol::as_utf8 |
54 // |
58 // |
55 // The text of the symbol as a null-terminated C string. |
59 // The text of the symbol as a null-terminated C string. |
56 const char* ciSymbol::as_utf8() { |
60 const char* ciSymbol::as_utf8() { |
57 VM_QUICK_ENTRY_MARK; |
61 VM_QUICK_ENTRY_MARK; |
58 symbolOop s = get_symbolOop(); |
62 Symbol* s = get_symbol(); |
59 return s->as_utf8(); |
63 return s->as_utf8(); |
60 } |
64 } |
61 |
65 |
62 // ------------------------------------------------------------------ |
66 // ------------------------------------------------------------------ |
63 // ciSymbol::base |
67 // ciSymbol::base |
64 jbyte* ciSymbol::base() { |
68 const jbyte* ciSymbol::base() { |
65 GUARDED_VM_ENTRY(return get_symbolOop()->base();) |
69 GUARDED_VM_ENTRY(return get_symbol()->base();) |
66 } |
70 } |
67 |
71 |
68 // ------------------------------------------------------------------ |
72 // ------------------------------------------------------------------ |
69 // ciSymbol::byte_at |
73 // ciSymbol::byte_at |
70 int ciSymbol::byte_at(int i) { |
74 int ciSymbol::byte_at(int i) { |
71 GUARDED_VM_ENTRY(return get_symbolOop()->byte_at(i);) |
75 GUARDED_VM_ENTRY(return get_symbol()->byte_at(i);) |
72 } |
76 } |
73 |
77 |
74 // ------------------------------------------------------------------ |
78 // ------------------------------------------------------------------ |
75 // ciSymbol::starts_with |
79 // ciSymbol::starts_with |
76 // |
80 // |
77 // Tests if the symbol starts with the given prefix. |
81 // Tests if the symbol starts with the given prefix. |
78 bool ciSymbol::starts_with(const char* prefix, int len) const { |
82 bool ciSymbol::starts_with(const char* prefix, int len) const { |
79 GUARDED_VM_ENTRY(return get_symbolOop()->starts_with(prefix, len);) |
83 GUARDED_VM_ENTRY(return get_symbol()->starts_with(prefix, len);) |
80 } |
84 } |
81 |
85 |
82 // ------------------------------------------------------------------ |
86 // ------------------------------------------------------------------ |
83 // ciSymbol::index_of |
87 // ciSymbol::index_of |
84 // |
88 // |
85 // Determines where the symbol contains the given substring. |
89 // Determines where the symbol contains the given substring. |
86 int ciSymbol::index_of_at(int i, const char* str, int len) const { |
90 int ciSymbol::index_of_at(int i, const char* str, int len) const { |
87 GUARDED_VM_ENTRY(return get_symbolOop()->index_of_at(i, str, len);) |
91 GUARDED_VM_ENTRY(return get_symbol()->index_of_at(i, str, len);) |
88 } |
92 } |
89 |
93 |
90 // ------------------------------------------------------------------ |
94 // ------------------------------------------------------------------ |
91 // ciSymbol::utf8_length |
95 // ciSymbol::utf8_length |
92 int ciSymbol::utf8_length() { |
96 int ciSymbol::utf8_length() { |
93 GUARDED_VM_ENTRY(return get_symbolOop()->utf8_length();) |
97 GUARDED_VM_ENTRY(return get_symbol()->utf8_length();) |
94 } |
98 } |
95 |
99 |
96 // ------------------------------------------------------------------ |
100 // ------------------------------------------------------------------ |
97 // ciSymbol::print_impl |
101 // ciSymbol::print_impl |
98 // |
102 // |
105 // ------------------------------------------------------------------ |
109 // ------------------------------------------------------------------ |
106 // ciSymbol::print_symbol_on |
110 // ciSymbol::print_symbol_on |
107 // |
111 // |
108 // Print the value of this symbol on an outputStream |
112 // Print the value of this symbol on an outputStream |
109 void ciSymbol::print_symbol_on(outputStream *st) { |
113 void ciSymbol::print_symbol_on(outputStream *st) { |
110 GUARDED_VM_ENTRY(get_symbolOop()->print_symbol_on(st);) |
114 GUARDED_VM_ENTRY(get_symbol()->print_symbol_on(st);) |
111 } |
115 } |
112 |
116 |
113 // ------------------------------------------------------------------ |
117 // ------------------------------------------------------------------ |
114 // ciSymbol::make_impl |
118 // ciSymbol::make_impl |
115 // |
119 // |
116 // Make a ciSymbol from a C string (implementation). |
120 // Make a ciSymbol from a C string (implementation). |
117 ciSymbol* ciSymbol::make_impl(const char* s) { |
121 ciSymbol* ciSymbol::make_impl(const char* s) { |
118 EXCEPTION_CONTEXT; |
122 EXCEPTION_CONTEXT; |
119 // For some reason, oopFactory::new_symbol doesn't declare its |
123 TempNewSymbol sym = SymbolTable::new_symbol(s, THREAD); |
120 // char* argument as const. |
|
121 symbolOop sym = oopFactory::new_symbol((char*)s, (int)strlen(s), THREAD); |
|
122 if (HAS_PENDING_EXCEPTION) { |
124 if (HAS_PENDING_EXCEPTION) { |
123 CLEAR_PENDING_EXCEPTION; |
125 CLEAR_PENDING_EXCEPTION; |
124 CURRENT_THREAD_ENV->record_out_of_memory_failure(); |
126 CURRENT_THREAD_ENV->record_out_of_memory_failure(); |
125 return ciEnv::_unloaded_cisymbol; |
127 return ciEnv::_unloaded_cisymbol; |
126 } |
128 } |
127 return CURRENT_THREAD_ENV->get_object(sym)->as_symbol(); |
129 return CURRENT_THREAD_ENV->get_symbol(sym); |
128 } |
130 } |
129 |
131 |
130 // ------------------------------------------------------------------ |
132 // ------------------------------------------------------------------ |
131 // ciSymbol::make |
133 // ciSymbol::make |
132 // |
134 // |