|
1 /* |
|
2 * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved. |
|
3 * Copyright (c) 2019 SAP SE. All rights reserved. |
|
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
|
5 * |
|
6 * This code is free software; you can redistribute it and/or modify it |
|
7 * under the terms of the GNU General Public License version 2 only, as |
|
8 * published by the Free Software Foundation. |
|
9 * |
|
10 * This code is distributed in the hope that it will be useful, but WITHOUT |
|
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
13 * version 2 for more details (a copy is included in the LICENSE file that |
|
14 * accompanied this code). |
|
15 * |
|
16 * You should have received a copy of the GNU General Public License version |
|
17 * 2 along with this work; if not, write to the Free Software Foundation, |
|
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
19 * |
|
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
21 * or visit www.oracle.com if you need additional information or have any |
|
22 * questions. |
|
23 * |
|
24 */ |
|
25 |
|
26 #include "asm/assembler.inline.hpp" |
|
27 #include "asm/macroAssembler.hpp" |
|
28 #include "code/codeCache.hpp" |
|
29 #include "compiler/disassembler.hpp" |
|
30 #include "depChecker_s390.hpp" |
|
31 #include "gc/cms/concurrentMarkSweepGeneration.inline.hpp" |
|
32 #include "gc/cms/parOopClosures.inline.hpp" |
|
33 #include "gc/shared/collectedHeap.hpp" |
|
34 #include "gc/shared/cardTableBarrierSet.hpp" |
|
35 #include "gc/shared/genOopClosures.inline.hpp" |
|
36 #include "oops/oop.inline.hpp" |
|
37 #include "runtime/handles.inline.hpp" |
|
38 #include "runtime/stubCodeGenerator.hpp" |
|
39 #include "runtime/stubRoutines.hpp" |
|
40 #include "utilities/align.hpp" |
|
41 |
|
42 // List of all major opcodes, as of |
|
43 // Principles of Operation, Eleventh Edition, March 2015 |
|
44 bool Disassembler::valid_opcodes[] = |
|
45 { true, true, false, false, true, true, true, true, // 0x00..07 |
|
46 false, false, true, true, true, true, true, true, // 0x08..0f |
|
47 true, true, true, true, true, true, true, true, // 0x10..17 |
|
48 true, true, true, true, true, true, true, true, // 0x18..1f |
|
49 true, true, true, true, true, true, true, true, // 0x20..27 |
|
50 true, true, true, true, true, true, true, true, // 0x28..2f |
|
51 true, true, true, true, true, true, true, true, // 0x30..37 |
|
52 true, true, true, true, true, true, true, true, // 0x38..3f |
|
53 true, true, true, true, true, true, true, true, // 0x40..47 |
|
54 true, true, true, true, true, true, true, true, // 0x48..4f |
|
55 true, true, false, false, true, true, true, true, // 0x50..57 |
|
56 true, true, true, true, true, true, true, true, // 0x58..5f |
|
57 true, false, false, false, false, false, false, true, // 0x60..67 |
|
58 true, true, true, true, true, true, true, true, // 0x68..6f |
|
59 true, true, false, false, false, false, false, false, // 0x70..77 |
|
60 true, true, true, true, true, true, true, true, // 0x78..7f |
|
61 true, false, true, true, true, true, true, true, // 0x80..87 |
|
62 true, true, true, true, true, true, true, true, // 0x88..8f |
|
63 true, true, true, true, true, true, true, true, // 0x90..97 |
|
64 true, true, true, true, false, false, false, false, // 0x98..9f |
|
65 false, false, false, false, false, true, false, true, // 0xa0..a7 |
|
66 true, true, false, false, true, true, true, true, // 0xa8..af |
|
67 false, true, true, true, false, false, true, true, // 0xb0..b7 |
|
68 false, true, true, true, false, true, true, true, // 0xb8..bf |
|
69 true, false, true, false, true, false, true, false, // 0xc0..c7 |
|
70 true, false, false, false, true, false, false, false, // 0xc8..cf |
|
71 true, true, true, true, true, true, true, true, // 0xd0..d7 |
|
72 false, true, true, true, true, true, true, true, // 0xd8..df |
|
73 false, true, true, true, false, true, false, true, // 0xe0..e7 |
|
74 true, true, true, true, true, true, true, true, // 0xe8..ef |
|
75 true, true, true, true, false, false, false, false, // 0xf0..f7 |
|
76 true, true, true, true, true, true, false, false, // 0xf8..ff |
|
77 }; |
|
78 // Check for valid opcodes. |
|
79 // |
|
80 // The major opcode (one byte) at the passed location is inspected. |
|
81 // If the opcode found is assigned, the function returns true, false otherwise. |
|
82 // The true indication is not reliable. It may well be that the major opcode is |
|
83 // assigned, but there exists a minor opcode field in the instruction which |
|
84 // which has unassigned values. |
|
85 bool Disassembler::is_valid_opcode_at(address here) { |
|
86 return valid_opcodes[*here]; |
|
87 } |
|
88 |
|
89 // This method does plain instruction decoding, no frills. |
|
90 // It may be called before the binutils disassembler kicks in |
|
91 // to handle special cases the binutils disassembler does not. |
|
92 // Instruction address, comments, and the like have to be output by caller. |
|
93 address Disassembler::decode_instruction0(address here, outputStream * st, address virtual_begin) { |
|
94 if (is_abstract()) { |
|
95 // The disassembler library was not loaded (yet), |
|
96 // use AbstractDisassembler's decode-method. |
|
97 return decode_instruction_abstract(here, st, Assembler::instr_len(here), Assembler::instr_maxlen()); |
|
98 } |
|
99 |
|
100 // Currently, "special decoding" doesn't work when decoding error files. |
|
101 // When decoding an instruction from a hs_err file, the given |
|
102 // instruction address 'start' points to the instruction's virtual address |
|
103 // which is not equal to the address where the instruction is located. |
|
104 // Therefore, we will either crash or decode garbage. |
|
105 if (is_decode_error_file()) { |
|
106 return here; |
|
107 } |
|
108 |
|
109 //---< Decode some well-known "instructions" >--- |
|
110 |
|
111 address next; |
|
112 uint16_t instruction_2bytes = *(uint16_t*)here; |
|
113 |
|
114 if (Assembler::is_z_nop((long)instruction_2bytes)) { |
|
115 #if 1 |
|
116 st->print("nop "); // fill up to operand column, leads to better code comment alignment |
|
117 next = here + 2; |
|
118 #else |
|
119 // Compact disassembler output. Does not work the easy way. |
|
120 // Currently unusable, search does not terminate, risk of crash. |
|
121 // TODO: rework required. |
|
122 // Terminate search loop when reaching CodeEntryAlignment-aligned offset |
|
123 // or, at the latest, when reaching the next page boundary. |
|
124 int n_nops = 0; |
|
125 while(is_same_page(here, here+2*n_nops) && Assembler::is_z_nop((long)instruction_2bytes)) { |
|
126 n_nops++; |
|
127 instruction_2bytes = *(uint16_t*)(here+2*n_nops); |
|
128 } |
|
129 if (n_nops <= 4) { // do not group few subsequent nops |
|
130 st->print("nop "); // fill up to operand column, leads to better code comment alignment |
|
131 next = here + 2; |
|
132 } else { |
|
133 st->print("nop count=%d", n_nops); |
|
134 next = here + 2*n_nops; |
|
135 } |
|
136 #endif |
|
137 } else if (Assembler::is_z_sync((long)instruction_2bytes)) { |
|
138 // Specific names. Make use of lightweight sync. |
|
139 st->print("sync "); |
|
140 if (Assembler::is_z_sync_full((long)instruction_2bytes) ) st->print("heavyweight"); |
|
141 if (Assembler::is_z_sync_light((long)instruction_2bytes)) st->print("lightweight"); |
|
142 next = here + 2; |
|
143 } else if (instruction_2bytes == 0x0000) { |
|
144 #if 1 |
|
145 st->print("illtrap .nodata"); |
|
146 next = here + 2; |
|
147 #else |
|
148 // Compact disassembler output. Does not work the easy way. |
|
149 // Currently unusable, search does not terminate, risk of crash. |
|
150 // TODO: rework required. |
|
151 // Terminate search loop when reaching CodeEntryAlignment-aligned offset |
|
152 // or, at the latest, when reaching the next page boundary. |
|
153 int n_traps = 0; |
|
154 while(is_same_page(here, here+2*n_nops) && (instruction_2bytes == 0x0000)) { |
|
155 n_traps++; |
|
156 instruction_2bytes = *(uint16_t*)(here+2*n_traps); |
|
157 } |
|
158 if (n_traps <= 4) { // do not group few subsequent illtraps |
|
159 st->print("illtrap .nodata"); |
|
160 next = here + 2; |
|
161 } else { |
|
162 st->print("illtrap .nodata count=%d", n_traps); |
|
163 next = here + 2*n_traps; |
|
164 } |
|
165 #endif |
|
166 } else if ((instruction_2bytes & 0xff00) == 0x0000) { |
|
167 st->print("illtrap .data 0x%2.2x", instruction_2bytes & 0x00ff); |
|
168 next = here + 2; |
|
169 } else { |
|
170 next = here; |
|
171 } |
|
172 return next; |
|
173 } |
|
174 |
|
175 // Count the instructions contained in the range [begin..end). |
|
176 // The range must exactly contain the instructions, i.e. |
|
177 // - the first instruction starts @begin |
|
178 // - the last instruction ends @(end-1) |
|
179 // The caller has to make sure that the given range is readable. |
|
180 // This function performs no safety checks! |
|
181 // Return value: |
|
182 // - The number of instructions, if there was exact containment. |
|
183 // - If there is no exact containment, a negative value is returned. |
|
184 // Its absolute value is the number of instructions from begin to end, |
|
185 // where the last instruction counted runs over the range end. |
|
186 // - 0 (zero) is returned if there was a parameter error |
|
187 // (inverted range, bad starting point). |
|
188 int Disassembler::count_instr(address begin, address end) { |
|
189 if (end < begin+2) return 0; // no instructions in range |
|
190 if (!Disassembler::is_valid_opcode_at(begin)) return 0; // bad starting point |
|
191 |
|
192 address p = begin; |
|
193 int n = 0; |
|
194 while(p < end) { |
|
195 p += Assembler::instr_len(p); |
|
196 n++; |
|
197 } |
|
198 return (p == end) ? n : -n; |
|
199 } |
|
200 |
|
201 // Find preceding instruction. |
|
202 // |
|
203 // Starting at the passed location, the n-th preceding (towards lower addresses) |
|
204 // instruction is searched. With variable length instructions, there may be |
|
205 // more than one solution, or no solution at all (if the passed location |
|
206 // does not point to the start of an instruction or if the storage area |
|
207 // does not contain instructions at all). |
|
208 // instructions - has the passed location as n-th successor. |
|
209 // - If multiple such locations exist between (here-n*instr_maxlen()) and here, |
|
210 // the most distant location is selected. |
|
211 // - If no such location exists, NULL is returned. The caller should then |
|
212 // terminate its search and react properly. |
|
213 // Must be placed here in disassembler_s390.cpp. It does not compile |
|
214 // in the header. There the class 'Assembler' is not available. |
|
215 address Disassembler::find_prev_instr(address here, int n_instr) { |
|
216 if (!os::is_readable_pointer(here)) return NULL; // obviously a bad location to decode |
|
217 |
|
218 // Find most distant possible starting point. |
|
219 // Narrow down because we don't want to SEGV while printing. |
|
220 address start = here - n_instr*Assembler::instr_maxlen(); // starting point can't be further away. |
|
221 while ((start < here) && !os::is_readable_range(start, here)) { |
|
222 start = align_down(start, os::min_page_size()) + os::min_page_size(); |
|
223 } |
|
224 if (start >= here) { |
|
225 // Strange. Can only happen with here on page boundary. |
|
226 return NULL; |
|
227 } |
|
228 |
|
229 //---< Find a starting point >--- |
|
230 int i_count = 0; |
|
231 while ((start < here) && ((i_count = count_instr(start, here)) <= 0)) start += 2; |
|
232 if (i_count == 0) return NULL; // There is something seriously wrong |
|
233 |
|
234 //---< Narrow down distance (estimate was too large) >--- |
|
235 while(i_count-- > n_instr) { |
|
236 start += Assembler::instr_len(start); |
|
237 } |
|
238 assert(n_instr >= count_instr(start, here), "just checking"); |
|
239 return start; |
|
240 } |
|
241 |
|
242 |
|
243 // Print annotations (value of loaded constant) |
|
244 void Disassembler::annotate(address here, outputStream* st) { |
|
245 // Currently, annotation doesn't work when decoding error files. |
|
246 // When decoding an instruction from a hs_err file, the given |
|
247 // instruction address 'start' points to the instruction's virtual address |
|
248 // which is not equal to the address where the instruction is located. |
|
249 // Therefore, we will either crash or decode garbage. |
|
250 if (is_decode_error_file()) { |
|
251 return; |
|
252 } |
|
253 |
|
254 if (MacroAssembler::is_load_const(here)) { |
|
255 long value = MacroAssembler::get_const(here); |
|
256 const int tsize = 8; |
|
257 |
|
258 st->fill_to(60); |
|
259 st->print(";const %p | %ld | %23.15e", (void *)value, value, (double)value); |
|
260 } |
|
261 } |