author | ohair |
Tue, 25 May 2010 15:58:33 -0700 | |
changeset 5506 | 202f599c92aa |
parent 5191 | 79b41f733e33 |
child 7668 | d4a77089c587 |
permissions | -rw-r--r-- |
2 | 1 |
/* |
5506 | 2 |
* Copyright (c) 2001, 2009, Oracle and/or its affiliates. All rights reserved. |
2 | 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 |
|
5506 | 7 |
* published by the Free Software Foundation. Oracle designates this |
2 | 8 |
* particular file as subject to the "Classpath" exception as provided |
5506 | 9 |
* by Oracle in the LICENSE file that accompanied this code. |
2 | 10 |
* |
11 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
12 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
13 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
14 |
* version 2 for more details (a copy is included in the LICENSE file that |
|
15 |
* accompanied this code). |
|
16 |
* |
|
17 |
* You should have received a copy of the GNU General Public License version |
|
18 |
* 2 along with this work; if not, write to the Free Software Foundation, |
|
19 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
20 |
* |
|
5506 | 21 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
22 |
* or visit www.oracle.com if you need additional information or have any |
|
23 |
* questions. |
|
2 | 24 |
*/ |
25 |
||
26 |
// -*- C++ -*- |
|
27 |
// Program for unpacking specially compressed Java packages. |
|
28 |
// John R. Rose |
|
29 |
||
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
30 |
/* |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
31 |
* When compiling for a 64bit LP64 system (longs and pointers being 64bits), |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
32 |
* the printf format %ld is correct and use of %lld will cause warning |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
33 |
* errors from some compilers (gcc/g++). |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
34 |
* _LP64 can be explicitly set (used on Linux). |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
35 |
* Solaris compilers will define __sparcv9 or __x86_64 on 64bit compilations. |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
36 |
*/ |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
37 |
#if defined(_LP64) || defined(__sparcv9) || defined(__x86_64) |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
38 |
#define LONG_LONG_FORMAT "%ld" |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
39 |
#define LONG_LONG_HEX_FORMAT "%lx" |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
40 |
#else |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
41 |
#define LONG_LONG_FORMAT "%lld" |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
42 |
#define LONG_LONG_HEX_FORMAT "%016llx" |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
43 |
#endif |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
44 |
|
2 | 45 |
#include <sys/types.h> |
46 |
||
47 |
#include <stdio.h> |
|
48 |
#include <string.h> |
|
49 |
#include <stdlib.h> |
|
50 |
#include <stdarg.h> |
|
51 |
||
52 |
#include <limits.h> |
|
53 |
#include <time.h> |
|
54 |
||
55 |
||
56 |
||
57 |
||
58 |
#include "defines.h" |
|
59 |
#include "bytes.h" |
|
60 |
#include "utils.h" |
|
61 |
#include "coding.h" |
|
62 |
#include "bands.h" |
|
63 |
||
64 |
#include "constants.h" |
|
65 |
||
66 |
#include "zip.h" |
|
67 |
||
68 |
#include "unpack.h" |
|
69 |
||
70 |
||
71 |
// tags, in canonical order: |
|
72 |
static const byte TAGS_IN_ORDER[] = { |
|
73 |
CONSTANT_Utf8, |
|
74 |
CONSTANT_Integer, |
|
75 |
CONSTANT_Float, |
|
76 |
CONSTANT_Long, |
|
77 |
CONSTANT_Double, |
|
78 |
CONSTANT_String, |
|
79 |
CONSTANT_Class, |
|
80 |
CONSTANT_Signature, |
|
81 |
CONSTANT_NameandType, |
|
82 |
CONSTANT_Fieldref, |
|
83 |
CONSTANT_Methodref, |
|
84 |
CONSTANT_InterfaceMethodref |
|
85 |
}; |
|
86 |
#define N_TAGS_IN_ORDER (sizeof TAGS_IN_ORDER) |
|
87 |
||
88 |
#ifndef PRODUCT |
|
89 |
static const char* TAG_NAME[] = { |
|
90 |
"*None", |
|
91 |
"Utf8", |
|
92 |
"*Unicode", |
|
93 |
"Integer", |
|
94 |
"Float", |
|
95 |
"Long", |
|
96 |
"Double", |
|
97 |
"Class", |
|
98 |
"String", |
|
99 |
"Fieldref", |
|
100 |
"Methodref", |
|
101 |
"InterfaceMethodref", |
|
102 |
"NameandType", |
|
103 |
"*Signature", |
|
104 |
0 |
|
105 |
}; |
|
106 |
||
107 |
static const char* ATTR_CONTEXT_NAME[] = { // match ATTR_CONTEXT_NAME, etc. |
|
108 |
"class", "field", "method", "code" |
|
109 |
}; |
|
110 |
||
111 |
#else |
|
112 |
||
113 |
#define ATTR_CONTEXT_NAME ((const char**)null) |
|
114 |
||
115 |
#endif |
|
116 |
||
117 |
||
118 |
// REQUESTED must be -2 for u2 and REQUESTED_LDC must be -1 for u1 |
|
119 |
enum { NOT_REQUESTED = 0, REQUESTED = -2, REQUESTED_LDC = -1 }; |
|
120 |
||
121 |
#define NO_INORD ((uint)-1) |
|
122 |
||
123 |
struct entry { |
|
124 |
byte tag; |
|
125 |
||
126 |
#if 0 |
|
127 |
byte bits; |
|
128 |
enum { |
|
129 |
//EB_EXTRA = 1, |
|
130 |
EB_SUPER = 2 |
|
131 |
}; |
|
132 |
#endif |
|
133 |
unsigned short nrefs; // pack w/ tag |
|
134 |
||
135 |
int outputIndex; |
|
136 |
uint inord; // &cp.entries[cp.tag_base[this->tag]+this->inord] == this |
|
137 |
||
138 |
entry* *refs; |
|
139 |
||
140 |
// put last to pack best |
|
141 |
union { |
|
142 |
bytes b; |
|
143 |
int i; |
|
144 |
jlong l; |
|
145 |
} value; |
|
146 |
||
147 |
void requestOutputIndex(cpool& cp, int req = REQUESTED); |
|
148 |
int getOutputIndex() { |
|
149 |
assert(outputIndex > NOT_REQUESTED); |
|
150 |
return outputIndex; |
|
151 |
} |
|
152 |
||
153 |
entry* ref(int refnum) { |
|
154 |
assert((uint)refnum < nrefs); |
|
155 |
return refs[refnum]; |
|
156 |
} |
|
157 |
||
158 |
const char* utf8String() { |
|
159 |
assert(tagMatches(CONSTANT_Utf8)); |
|
160 |
assert(value.b.len == strlen((const char*)value.b.ptr)); |
|
161 |
return (const char*)value.b.ptr; |
|
162 |
} |
|
163 |
||
164 |
entry* className() { |
|
165 |
assert(tagMatches(CONSTANT_Class)); |
|
166 |
return ref(0); |
|
167 |
} |
|
168 |
||
169 |
entry* memberClass() { |
|
170 |
assert(tagMatches(CONSTANT_Member)); |
|
171 |
return ref(0); |
|
172 |
} |
|
173 |
||
174 |
entry* memberDescr() { |
|
175 |
assert(tagMatches(CONSTANT_Member)); |
|
176 |
return ref(1); |
|
177 |
} |
|
178 |
||
179 |
entry* descrName() { |
|
180 |
assert(tagMatches(CONSTANT_NameandType)); |
|
181 |
return ref(0); |
|
182 |
} |
|
183 |
||
184 |
entry* descrType() { |
|
185 |
assert(tagMatches(CONSTANT_NameandType)); |
|
186 |
return ref(1); |
|
187 |
} |
|
188 |
||
189 |
int typeSize(); |
|
190 |
||
191 |
bytes& asUtf8(); |
|
192 |
int asInteger() { assert(tag == CONSTANT_Integer); return value.i; } |
|
193 |
||
194 |
bool isUtf8(bytes& b) { return tagMatches(CONSTANT_Utf8) && value.b.equals(b); } |
|
195 |
||
196 |
bool isDoubleWord() { return tag == CONSTANT_Double || tag == CONSTANT_Long; } |
|
197 |
||
198 |
bool tagMatches(byte tag2) { |
|
199 |
return (tag2 == tag) |
|
200 |
|| (tag2 == CONSTANT_Utf8 && tag == CONSTANT_Signature) |
|
201 |
#ifndef PRODUCT |
|
202 |
|| (tag2 == CONSTANT_Literal |
|
203 |
&& tag >= CONSTANT_Integer && tag <= CONSTANT_String && tag != CONSTANT_Class) |
|
204 |
|| (tag2 == CONSTANT_Member |
|
205 |
&& tag >= CONSTANT_Fieldref && tag <= CONSTANT_InterfaceMethodref) |
|
206 |
#endif |
|
207 |
; |
|
208 |
} |
|
209 |
||
210 |
#ifdef PRODUCT |
|
211 |
char* string() { return 0; } |
|
212 |
#else |
|
213 |
char* string(); // see far below |
|
214 |
#endif |
|
215 |
}; |
|
216 |
||
217 |
entry* cpindex::get(uint i) { |
|
218 |
if (i >= len) |
|
219 |
return null; |
|
220 |
else if (base1 != null) |
|
221 |
// primary index |
|
222 |
return &base1[i]; |
|
223 |
else |
|
224 |
// secondary index |
|
225 |
return base2[i]; |
|
226 |
} |
|
227 |
||
228 |
inline bytes& entry::asUtf8() { |
|
229 |
assert(tagMatches(CONSTANT_Utf8)); |
|
230 |
return value.b; |
|
231 |
} |
|
232 |
||
233 |
int entry::typeSize() { |
|
234 |
assert(tagMatches(CONSTANT_Utf8)); |
|
235 |
const char* sigp = (char*) value.b.ptr; |
|
236 |
switch (*sigp) { |
|
237 |
case '(': sigp++; break; // skip opening '(' |
|
238 |
case 'D': |
|
239 |
case 'J': return 2; // double field |
|
240 |
default: return 1; // field |
|
241 |
} |
|
242 |
int siglen = 0; |
|
243 |
for (;;) { |
|
244 |
int ch = *sigp++; |
|
245 |
switch (ch) { |
|
246 |
case 'D': case 'J': |
|
247 |
siglen += 1; |
|
248 |
break; |
|
249 |
case '[': |
|
250 |
// Skip rest of array info. |
|
251 |
while (ch == '[') { ch = *sigp++; } |
|
252 |
if (ch != 'L') break; |
|
253 |
// else fall through |
|
254 |
case 'L': |
|
255 |
sigp = strchr(sigp, ';'); |
|
256 |
if (sigp == null) { |
|
257 |
unpack_abort("bad data"); |
|
258 |
return 0; |
|
259 |
} |
|
260 |
sigp += 1; |
|
261 |
break; |
|
262 |
case ')': // closing ')' |
|
263 |
return siglen; |
|
264 |
} |
|
265 |
siglen += 1; |
|
266 |
} |
|
267 |
} |
|
268 |
||
269 |
inline cpindex* cpool::getFieldIndex(entry* classRef) { |
|
270 |
assert(classRef->tagMatches(CONSTANT_Class)); |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
271 |
assert((uint)classRef->inord < (uint)tag_count[CONSTANT_Class]); |
2 | 272 |
return &member_indexes[classRef->inord*2+0]; |
273 |
} |
|
274 |
inline cpindex* cpool::getMethodIndex(entry* classRef) { |
|
275 |
assert(classRef->tagMatches(CONSTANT_Class)); |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
276 |
assert((uint)classRef->inord < (uint)tag_count[CONSTANT_Class]); |
2 | 277 |
return &member_indexes[classRef->inord*2+1]; |
278 |
} |
|
279 |
||
280 |
struct inner_class { |
|
281 |
entry* inner; |
|
282 |
entry* outer; |
|
283 |
entry* name; |
|
284 |
int flags; |
|
285 |
inner_class* next_sibling; |
|
286 |
bool requested; |
|
287 |
}; |
|
288 |
||
289 |
// Here is where everything gets deallocated: |
|
290 |
void unpacker::free() { |
|
291 |
int i; |
|
292 |
assert(jniobj == null); // caller resp. |
|
293 |
assert(infileptr == null); // caller resp. |
|
294 |
if (jarout != null) jarout->reset(); |
|
295 |
if (gzin != null) { gzin->free(); gzin = null; } |
|
296 |
if (free_input) input.free(); |
|
297 |
// free everybody ever allocated with U_NEW or (recently) with T_NEW |
|
298 |
assert(smallbuf.base() == null || mallocs.contains(smallbuf.base())); |
|
299 |
assert(tsmallbuf.base() == null || tmallocs.contains(tsmallbuf.base())); |
|
300 |
mallocs.freeAll(); |
|
301 |
tmallocs.freeAll(); |
|
302 |
smallbuf.init(); |
|
303 |
tsmallbuf.init(); |
|
304 |
bcimap.free(); |
|
305 |
class_fixup_type.free(); |
|
306 |
class_fixup_offset.free(); |
|
307 |
class_fixup_ref.free(); |
|
308 |
code_fixup_type.free(); |
|
309 |
code_fixup_offset.free(); |
|
310 |
code_fixup_source.free(); |
|
311 |
requested_ics.free(); |
|
312 |
cur_classfile_head.free(); |
|
313 |
cur_classfile_tail.free(); |
|
314 |
for (i = 0; i < ATTR_CONTEXT_LIMIT; i++) |
|
315 |
attr_defs[i].free(); |
|
316 |
||
317 |
// free CP state |
|
318 |
cp.outputEntries.free(); |
|
319 |
for (i = 0; i < CONSTANT_Limit; i++) |
|
320 |
cp.tag_extras[i].free(); |
|
321 |
} |
|
322 |
||
323 |
// input handling |
|
324 |
// Attempts to advance rplimit so that (rplimit-rp) is at least 'more'. |
|
325 |
// Will eagerly read ahead by larger chunks, if possible. |
|
326 |
// Returns false if (rplimit-rp) is not at least 'more', |
|
327 |
// unless rplimit hits input.limit(). |
|
328 |
bool unpacker::ensure_input(jlong more) { |
|
329 |
julong want = more - input_remaining(); |
|
330 |
if ((jlong)want <= 0) return true; // it's already in the buffer |
|
331 |
if (rplimit == input.limit()) return true; // not expecting any more |
|
332 |
||
333 |
if (read_input_fn == null) { |
|
334 |
// assume it is already all there |
|
335 |
bytes_read += input.limit() - rplimit; |
|
336 |
rplimit = input.limit(); |
|
337 |
return true; |
|
338 |
} |
|
339 |
CHECK_0; |
|
340 |
||
341 |
julong remaining = (input.limit() - rplimit); // how much left to read? |
|
342 |
byte* rpgoal = (want >= remaining)? input.limit(): rplimit + (size_t)want; |
|
343 |
enum { CHUNK_SIZE = (1<<14) }; |
|
344 |
julong fetch = want; |
|
345 |
if (fetch < CHUNK_SIZE) |
|
346 |
fetch = CHUNK_SIZE; |
|
347 |
if (fetch > remaining*3/4) |
|
348 |
fetch = remaining; |
|
349 |
// Try to fetch at least "more" bytes. |
|
350 |
while ((jlong)fetch > 0) { |
|
351 |
jlong nr = (*read_input_fn)(this, rplimit, fetch, remaining); |
|
352 |
if (nr <= 0) { |
|
353 |
return (rplimit >= rpgoal); |
|
354 |
} |
|
355 |
remaining -= nr; |
|
356 |
rplimit += nr; |
|
357 |
fetch -= nr; |
|
358 |
bytes_read += nr; |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
359 |
assert(remaining == (julong)(input.limit() - rplimit)); |
2 | 360 |
} |
361 |
return true; |
|
362 |
} |
|
363 |
||
364 |
// output handling |
|
365 |
||
366 |
fillbytes* unpacker::close_output(fillbytes* which) { |
|
367 |
assert(wp != null); |
|
368 |
if (which == null) { |
|
369 |
if (wpbase == cur_classfile_head.base()) { |
|
370 |
which = &cur_classfile_head; |
|
371 |
} else { |
|
372 |
which = &cur_classfile_tail; |
|
373 |
} |
|
374 |
} |
|
375 |
assert(wpbase == which->base()); |
|
376 |
assert(wplimit == which->end()); |
|
377 |
which->setLimit(wp); |
|
378 |
wp = null; |
|
379 |
wplimit = null; |
|
380 |
//wpbase = null; |
|
381 |
return which; |
|
382 |
} |
|
383 |
||
384 |
//maybe_inline |
|
385 |
void unpacker::ensure_put_space(size_t size) { |
|
386 |
if (wp + size <= wplimit) return; |
|
387 |
// Determine which segment needs expanding. |
|
388 |
fillbytes* which = close_output(); |
|
389 |
byte* wp0 = which->grow(size); |
|
390 |
wpbase = which->base(); |
|
391 |
wplimit = which->end(); |
|
392 |
wp = wp0; |
|
393 |
} |
|
394 |
||
395 |
maybe_inline |
|
396 |
byte* unpacker::put_space(size_t size) { |
|
397 |
byte* wp0 = wp; |
|
398 |
byte* wp1 = wp0 + size; |
|
399 |
if (wp1 > wplimit) { |
|
400 |
ensure_put_space(size); |
|
401 |
wp0 = wp; |
|
402 |
wp1 = wp0 + size; |
|
403 |
} |
|
404 |
wp = wp1; |
|
405 |
return wp0; |
|
406 |
} |
|
407 |
||
408 |
maybe_inline |
|
409 |
void unpacker::putu2_at(byte* wp, int n) { |
|
410 |
if (n != (unsigned short)n) { |
|
411 |
unpack_abort(ERROR_OVERFLOW); |
|
412 |
return; |
|
413 |
} |
|
414 |
wp[0] = (n) >> 8; |
|
415 |
wp[1] = (n) >> 0; |
|
416 |
} |
|
417 |
||
418 |
maybe_inline |
|
419 |
void unpacker::putu4_at(byte* wp, int n) { |
|
420 |
wp[0] = (n) >> 24; |
|
421 |
wp[1] = (n) >> 16; |
|
422 |
wp[2] = (n) >> 8; |
|
423 |
wp[3] = (n) >> 0; |
|
424 |
} |
|
425 |
||
426 |
maybe_inline |
|
427 |
void unpacker::putu8_at(byte* wp, jlong n) { |
|
428 |
putu4_at(wp+0, (int)((julong)n >> 32)); |
|
429 |
putu4_at(wp+4, (int)((julong)n >> 0)); |
|
430 |
} |
|
431 |
||
432 |
maybe_inline |
|
433 |
void unpacker::putu2(int n) { |
|
434 |
putu2_at(put_space(2), n); |
|
435 |
} |
|
436 |
||
437 |
maybe_inline |
|
438 |
void unpacker::putu4(int n) { |
|
439 |
putu4_at(put_space(4), n); |
|
440 |
} |
|
441 |
||
442 |
maybe_inline |
|
443 |
void unpacker::putu8(jlong n) { |
|
444 |
putu8_at(put_space(8), n); |
|
445 |
} |
|
446 |
||
447 |
maybe_inline |
|
448 |
int unpacker::putref_index(entry* e, int size) { |
|
449 |
if (e == null) |
|
450 |
return 0; |
|
451 |
else if (e->outputIndex > NOT_REQUESTED) |
|
452 |
return e->outputIndex; |
|
453 |
else if (e->tag == CONSTANT_Signature) |
|
454 |
return putref_index(e->ref(0), size); |
|
455 |
else { |
|
456 |
e->requestOutputIndex(cp, -size); |
|
457 |
// Later on we'll fix the bits. |
|
458 |
class_fixup_type.addByte(size); |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
459 |
class_fixup_offset.add((int)wpoffset()); |
2 | 460 |
class_fixup_ref.add(e); |
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
461 |
#ifdef PRODUCT |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
462 |
return 0; |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
463 |
#else |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
464 |
return 0x20+size; // 0x22 is easy to eyeball |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
465 |
#endif |
2 | 466 |
} |
467 |
} |
|
468 |
||
469 |
maybe_inline |
|
470 |
void unpacker::putref(entry* e) { |
|
471 |
int oidx = putref_index(e, 2); |
|
472 |
putu2_at(put_space(2), oidx); |
|
473 |
} |
|
474 |
||
475 |
maybe_inline |
|
476 |
void unpacker::putu1ref(entry* e) { |
|
477 |
int oidx = putref_index(e, 1); |
|
478 |
putu1_at(put_space(1), oidx); |
|
479 |
} |
|
480 |
||
481 |
||
482 |
static int total_cp_size[] = {0, 0}; |
|
483 |
static int largest_cp_ref[] = {0, 0}; |
|
484 |
static int hash_probes[] = {0, 0}; |
|
485 |
||
486 |
// Allocation of small and large blocks. |
|
487 |
||
488 |
enum { CHUNK = (1 << 14), SMALL = (1 << 9) }; |
|
489 |
||
490 |
// Call malloc. Try to combine small blocks and free much later. |
|
491 |
void* unpacker::alloc_heap(size_t size, bool smallOK, bool temp) { |
|
492 |
CHECK_0; |
|
493 |
if (!smallOK || size > SMALL) { |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
494 |
void* res = must_malloc((int)size); |
2 | 495 |
(temp ? &tmallocs : &mallocs)->add(res); |
496 |
return res; |
|
497 |
} |
|
498 |
fillbytes& xsmallbuf = *(temp ? &tsmallbuf : &smallbuf); |
|
499 |
if (!xsmallbuf.canAppend(size+1)) { |
|
500 |
xsmallbuf.init(CHUNK); |
|
501 |
(temp ? &tmallocs : &mallocs)->add(xsmallbuf.base()); |
|
502 |
} |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
503 |
int growBy = (int)size; |
2 | 504 |
growBy += -growBy & 7; // round up mod 8 |
505 |
return xsmallbuf.grow(growBy); |
|
506 |
} |
|
507 |
||
508 |
maybe_inline |
|
509 |
void unpacker::saveTo(bytes& b, byte* ptr, size_t len) { |
|
5191
79b41f733e33
6902299: Java JAR "unpack200" must verify input parameters
ksrini
parents:
3463
diff
changeset
|
510 |
b.ptr = U_NEW(byte, add_size(len,1)); |
2 | 511 |
if (aborting()) { |
512 |
b.len = 0; |
|
513 |
return; |
|
514 |
} |
|
515 |
b.len = len; |
|
516 |
b.copyFrom(ptr, len); |
|
517 |
} |
|
518 |
||
519 |
// Read up through band_headers. |
|
520 |
// Do the archive_size dance to set the size of the input mega-buffer. |
|
521 |
void unpacker::read_file_header() { |
|
522 |
// Read file header to determine file type and total size. |
|
523 |
enum { |
|
524 |
MAGIC_BYTES = 4, |
|
525 |
AH_LENGTH_0 = 3, //minver, majver, options are outside of archive_size |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
526 |
AH_LENGTH_0_MAX = AH_LENGTH_0 + 1, // options might have 2 bytes |
2 | 527 |
AH_LENGTH = 26, //maximum archive header length (w/ all fields) |
528 |
// Length contributions from optional header fields: |
|
529 |
AH_FILE_HEADER_LEN = 5, // sizehi/lo/next/modtime/files |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
530 |
AH_ARCHIVE_SIZE_LEN = 2, // sizehi/lo only; part of AH_FILE_HEADER_LEN |
2 | 531 |
AH_CP_NUMBER_LEN = 4, // int/float/long/double |
532 |
AH_SPECIAL_FORMAT_LEN = 2, // layouts/band-headers |
|
533 |
AH_LENGTH_MIN = AH_LENGTH |
|
534 |
-(AH_FILE_HEADER_LEN+AH_SPECIAL_FORMAT_LEN+AH_CP_NUMBER_LEN), |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
535 |
ARCHIVE_SIZE_MIN = AH_LENGTH_MIN - (AH_LENGTH_0 + AH_ARCHIVE_SIZE_LEN), |
2 | 536 |
FIRST_READ = MAGIC_BYTES + AH_LENGTH_MIN |
537 |
}; |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
538 |
|
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
539 |
assert(AH_LENGTH_MIN == 15); // # of UNSIGNED5 fields required after archive_magic |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
540 |
assert(ARCHIVE_SIZE_MIN == 10); // # of UNSIGNED5 fields required after archive_size |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
541 |
// An absolute minimum null archive is magic[4], {minver,majver,options}[3], |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
542 |
// archive_size[0], cp_counts[8], class_counts[4], for a total of 19 bytes. |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
543 |
// (Note that archive_size is optional; it may be 0..10 bytes in length.) |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
544 |
// The first read must capture everything up through the options field. |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
545 |
// This happens to work even if {minver,majver,options} is a pathological |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
546 |
// 15 bytes long. Legal pack files limit those three fields to 1+1+2 bytes. |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
547 |
assert(FIRST_READ >= MAGIC_BYTES + AH_LENGTH_0 * B_MAX); |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
548 |
|
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
549 |
// Up through archive_size, the largest possible archive header is |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
550 |
// magic[4], {minver,majver,options}[4], archive_size[10]. |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
551 |
// (Note only the low 12 bits of options are allowed to be non-zero.) |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
552 |
// In order to parse archive_size, we need at least this many bytes |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
553 |
// in the first read. Of course, if archive_size_hi is more than |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
554 |
// a byte, we probably will fail to allocate the buffer, since it |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
555 |
// will be many gigabytes long. This is a practical, not an |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
556 |
// architectural limit to Pack200 archive sizes. |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
557 |
assert(FIRST_READ >= MAGIC_BYTES + AH_LENGTH_0_MAX + 2*B_MAX); |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
558 |
|
2 | 559 |
bool foreign_buf = (read_input_fn == null); |
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
560 |
byte initbuf[(int)FIRST_READ + (int)C_SLOP + 200]; // 200 is for JAR I/O |
2 | 561 |
if (foreign_buf) { |
562 |
// inbytes is all there is |
|
563 |
input.set(inbytes); |
|
564 |
rp = input.base(); |
|
565 |
rplimit = input.limit(); |
|
566 |
} else { |
|
567 |
// inbytes, if not empty, contains some read-ahead we must use first |
|
568 |
// ensure_input will take care of copying it into initbuf, |
|
569 |
// then querying read_input_fn for any additional data needed. |
|
570 |
// However, the caller must assume that we use up all of inbytes. |
|
571 |
// There is no way to tell the caller that we used only part of them. |
|
572 |
// Therefore, the caller must use only a bare minimum of read-ahead. |
|
573 |
if (inbytes.len > FIRST_READ) { |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
574 |
abort("too much read-ahead"); |
2 | 575 |
return; |
576 |
} |
|
577 |
input.set(initbuf, sizeof(initbuf)); |
|
578 |
input.b.clear(); |
|
579 |
input.b.copyFrom(inbytes); |
|
580 |
rplimit = rp = input.base(); |
|
581 |
rplimit += inbytes.len; |
|
582 |
bytes_read += inbytes.len; |
|
583 |
} |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
584 |
// Read only 19 bytes, which is certain to contain #archive_options fields, |
2 | 585 |
// but is certain not to overflow past the archive_header. |
586 |
input.b.len = FIRST_READ; |
|
587 |
if (!ensure_input(FIRST_READ)) |
|
588 |
abort("EOF reading archive magic number"); |
|
589 |
||
590 |
if (rp[0] == 'P' && rp[1] == 'K') { |
|
591 |
#ifdef UNPACK_JNI |
|
592 |
// Java driver must handle this case before we get this far. |
|
593 |
abort("encountered a JAR header in unpacker"); |
|
594 |
#else |
|
595 |
// In the Unix-style program, we simply simulate a copy command. |
|
596 |
// Copy until EOF; assume the JAR file is the last segment. |
|
597 |
fprintf(errstrm, "Copy-mode.\n"); |
|
598 |
for (;;) { |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
599 |
jarout->write_data(rp, (int)input_remaining()); |
2 | 600 |
if (foreign_buf) |
601 |
break; // one-time use of a passed in buffer |
|
602 |
if (input.size() < CHUNK) { |
|
603 |
// Get some breathing room. |
|
604 |
input.set(U_NEW(byte, (size_t) CHUNK + C_SLOP), (size_t) CHUNK); |
|
605 |
CHECK; |
|
606 |
} |
|
607 |
rp = rplimit = input.base(); |
|
608 |
if (!ensure_input(1)) |
|
609 |
break; |
|
610 |
} |
|
611 |
jarout->closeJarFile(false); |
|
612 |
#endif |
|
613 |
return; |
|
614 |
} |
|
615 |
||
616 |
// Read the magic number. |
|
617 |
magic = 0; |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
618 |
for (int i1 = 0; i1 < (int)sizeof(magic); i1++) { |
2 | 619 |
magic <<= 8; |
620 |
magic += (*rp++ & 0xFF); |
|
621 |
} |
|
622 |
||
623 |
// Read the first 3 values from the header. |
|
624 |
value_stream hdr; |
|
625 |
int hdrVals = 0; |
|
626 |
int hdrValsSkipped = 0; // debug only |
|
627 |
hdr.init(rp, rplimit, UNSIGNED5_spec); |
|
628 |
minver = hdr.getInt(); |
|
629 |
majver = hdr.getInt(); |
|
630 |
hdrVals += 2; |
|
631 |
||
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
632 |
if (magic != (int)JAVA_PACKAGE_MAGIC || |
2 | 633 |
(majver != JAVA5_PACKAGE_MAJOR_VERSION && |
634 |
majver != JAVA6_PACKAGE_MAJOR_VERSION) || |
|
635 |
(minver != JAVA5_PACKAGE_MINOR_VERSION && |
|
636 |
minver != JAVA6_PACKAGE_MINOR_VERSION)) { |
|
637 |
char message[200]; |
|
638 |
sprintf(message, "@" ERROR_FORMAT ": magic/ver = " |
|
639 |
"%08X/%d.%d should be %08X/%d.%d OR %08X/%d.%d\n", |
|
640 |
magic, majver, minver, |
|
641 |
JAVA_PACKAGE_MAGIC, JAVA5_PACKAGE_MAJOR_VERSION, JAVA5_PACKAGE_MINOR_VERSION, |
|
642 |
JAVA_PACKAGE_MAGIC, JAVA6_PACKAGE_MAJOR_VERSION, JAVA6_PACKAGE_MINOR_VERSION); |
|
643 |
abort(message); |
|
644 |
} |
|
645 |
CHECK; |
|
646 |
||
647 |
archive_options = hdr.getInt(); |
|
648 |
hdrVals += 1; |
|
649 |
assert(hdrVals == AH_LENGTH_0); // first three fields only |
|
650 |
||
651 |
#define ORBIT(bit) |(bit) |
|
652 |
int OPTION_LIMIT = (0 ARCHIVE_BIT_DO(ORBIT)); |
|
653 |
#undef ORBIT |
|
654 |
if ((archive_options & ~OPTION_LIMIT) != 0) { |
|
655 |
fprintf(errstrm, "Warning: Illegal archive options 0x%x\n", |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
656 |
archive_options); |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
657 |
abort("illegal archive options"); |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
658 |
return; |
2 | 659 |
} |
660 |
||
661 |
if ((archive_options & AO_HAVE_FILE_HEADERS) != 0) { |
|
662 |
uint hi = hdr.getInt(); |
|
663 |
uint lo = hdr.getInt(); |
|
2602
5b394a4b6ce1
6755943: Java JAR Pack200 Decompression should enforce stricter header checks
ksrini
parents:
2
diff
changeset
|
664 |
julong x = band::makeLong(hi, lo); |
5b394a4b6ce1
6755943: Java JAR Pack200 Decompression should enforce stricter header checks
ksrini
parents:
2
diff
changeset
|
665 |
archive_size = (size_t) x; |
5b394a4b6ce1
6755943: Java JAR Pack200 Decompression should enforce stricter header checks
ksrini
parents:
2
diff
changeset
|
666 |
if (archive_size != x) { |
5b394a4b6ce1
6755943: Java JAR Pack200 Decompression should enforce stricter header checks
ksrini
parents:
2
diff
changeset
|
667 |
// Silly size specified; force overflow. |
5b394a4b6ce1
6755943: Java JAR Pack200 Decompression should enforce stricter header checks
ksrini
parents:
2
diff
changeset
|
668 |
archive_size = PSIZE_MAX+1; |
5b394a4b6ce1
6755943: Java JAR Pack200 Decompression should enforce stricter header checks
ksrini
parents:
2
diff
changeset
|
669 |
} |
2 | 670 |
hdrVals += 2; |
671 |
} else { |
|
672 |
hdrValsSkipped += 2; |
|
673 |
} |
|
674 |
||
675 |
// Now we can size the whole archive. |
|
676 |
// Read everything else into a mega-buffer. |
|
677 |
rp = hdr.rp; |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
678 |
int header_size_0 = (int)(rp - input.base()); // used-up header (4byte + 3int) |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
679 |
int header_size_1 = (int)(rplimit - rp); // buffered unused initial fragment |
2 | 680 |
int header_size = header_size_0+header_size_1; |
681 |
unsized_bytes_read = header_size_0; |
|
682 |
CHECK; |
|
683 |
if (foreign_buf) { |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
684 |
if (archive_size > (size_t)header_size_1) { |
2 | 685 |
abort("EOF reading fixed input buffer"); |
686 |
return; |
|
687 |
} |
|
2602
5b394a4b6ce1
6755943: Java JAR Pack200 Decompression should enforce stricter header checks
ksrini
parents:
2
diff
changeset
|
688 |
} else if (archive_size != 0) { |
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
689 |
if (archive_size < ARCHIVE_SIZE_MIN) { |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
690 |
abort("impossible archive size"); // bad input data |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
691 |
return; |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
692 |
} |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
693 |
if (archive_size < header_size_1) { |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
694 |
abort("too much read-ahead"); // somehow we pre-fetched too much? |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
695 |
return; |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
696 |
} |
2602
5b394a4b6ce1
6755943: Java JAR Pack200 Decompression should enforce stricter header checks
ksrini
parents:
2
diff
changeset
|
697 |
input.set(U_NEW(byte, add_size(header_size_0, archive_size, C_SLOP)), |
2 | 698 |
(size_t) header_size_0 + archive_size); |
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
699 |
CHECK; |
2 | 700 |
assert(input.limit()[0] == 0); |
701 |
// Move all the bytes we read initially into the real buffer. |
|
702 |
input.b.copyFrom(initbuf, header_size); |
|
703 |
rp = input.b.ptr + header_size_0; |
|
704 |
rplimit = input.b.ptr + header_size; |
|
705 |
} else { |
|
706 |
// It's more complicated and painful. |
|
707 |
// A zero archive_size means that we must read until EOF. |
|
708 |
input.init(CHUNK*2); |
|
709 |
CHECK; |
|
710 |
input.b.len = input.allocated; |
|
711 |
rp = rplimit = input.base(); |
|
712 |
// Set up input buffer as if we already read the header: |
|
713 |
input.b.copyFrom(initbuf, header_size); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
714 |
CHECK; |
2 | 715 |
rplimit += header_size; |
716 |
while (ensure_input(input.limit() - rp)) { |
|
717 |
size_t dataSoFar = input_remaining(); |
|
2602
5b394a4b6ce1
6755943: Java JAR Pack200 Decompression should enforce stricter header checks
ksrini
parents:
2
diff
changeset
|
718 |
size_t nextSize = add_size(dataSoFar, CHUNK); |
2 | 719 |
input.ensureSize(nextSize); |
720 |
CHECK; |
|
721 |
input.b.len = input.allocated; |
|
722 |
rp = rplimit = input.base(); |
|
723 |
rplimit += dataSoFar; |
|
724 |
} |
|
725 |
size_t dataSize = (rplimit - input.base()); |
|
726 |
input.b.len = dataSize; |
|
727 |
input.grow(C_SLOP); |
|
728 |
CHECK; |
|
729 |
free_input = true; // free it later |
|
730 |
input.b.len = dataSize; |
|
731 |
assert(input.limit()[0] == 0); |
|
732 |
rp = rplimit = input.base(); |
|
733 |
rplimit += dataSize; |
|
734 |
rp += header_size_0; // already scanned these bytes... |
|
735 |
} |
|
736 |
live_input = true; // mark as "do not reuse" |
|
737 |
if (aborting()) { |
|
738 |
abort("cannot allocate large input buffer for package file"); |
|
739 |
return; |
|
740 |
} |
|
741 |
||
742 |
// read the rest of the header fields |
|
743 |
ensure_input((AH_LENGTH-AH_LENGTH_0) * B_MAX); |
|
744 |
CHECK; |
|
745 |
hdr.rp = rp; |
|
746 |
hdr.rplimit = rplimit; |
|
747 |
||
748 |
if ((archive_options & AO_HAVE_FILE_HEADERS) != 0) { |
|
749 |
archive_next_count = hdr.getInt(); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
750 |
CHECK_COUNT(archive_next_count); |
2 | 751 |
archive_modtime = hdr.getInt(); |
752 |
file_count = hdr.getInt(); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
753 |
CHECK_COUNT(file_count); |
2 | 754 |
hdrVals += 3; |
755 |
} else { |
|
756 |
hdrValsSkipped += 3; |
|
757 |
} |
|
758 |
||
759 |
if ((archive_options & AO_HAVE_SPECIAL_FORMATS) != 0) { |
|
760 |
band_headers_size = hdr.getInt(); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
761 |
CHECK_COUNT(band_headers_size); |
2 | 762 |
attr_definition_count = hdr.getInt(); |
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
763 |
CHECK_COUNT(attr_definition_count); |
2 | 764 |
hdrVals += 2; |
765 |
} else { |
|
766 |
hdrValsSkipped += 2; |
|
767 |
} |
|
768 |
||
769 |
int cp_counts[N_TAGS_IN_ORDER]; |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
770 |
for (int k = 0; k < (int)N_TAGS_IN_ORDER; k++) { |
2 | 771 |
if (!(archive_options & AO_HAVE_CP_NUMBERS)) { |
772 |
switch (TAGS_IN_ORDER[k]) { |
|
773 |
case CONSTANT_Integer: |
|
774 |
case CONSTANT_Float: |
|
775 |
case CONSTANT_Long: |
|
776 |
case CONSTANT_Double: |
|
777 |
cp_counts[k] = 0; |
|
778 |
hdrValsSkipped += 1; |
|
779 |
continue; |
|
780 |
} |
|
781 |
} |
|
782 |
cp_counts[k] = hdr.getInt(); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
783 |
CHECK_COUNT(cp_counts[k]); |
2 | 784 |
hdrVals += 1; |
785 |
} |
|
786 |
||
787 |
ic_count = hdr.getInt(); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
788 |
CHECK_COUNT(ic_count); |
2 | 789 |
default_class_minver = hdr.getInt(); |
790 |
default_class_majver = hdr.getInt(); |
|
791 |
class_count = hdr.getInt(); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
792 |
CHECK_COUNT(class_count); |
2 | 793 |
hdrVals += 4; |
794 |
||
795 |
// done with archive_header |
|
796 |
hdrVals += hdrValsSkipped; |
|
797 |
assert(hdrVals == AH_LENGTH); |
|
798 |
#ifndef PRODUCT |
|
799 |
int assertSkipped = AH_LENGTH - AH_LENGTH_MIN; |
|
800 |
if ((archive_options & AO_HAVE_FILE_HEADERS) != 0) |
|
801 |
assertSkipped -= AH_FILE_HEADER_LEN; |
|
802 |
if ((archive_options & AO_HAVE_SPECIAL_FORMATS) != 0) |
|
803 |
assertSkipped -= AH_SPECIAL_FORMAT_LEN; |
|
804 |
if ((archive_options & AO_HAVE_CP_NUMBERS) != 0) |
|
805 |
assertSkipped -= AH_CP_NUMBER_LEN; |
|
806 |
assert(hdrValsSkipped == assertSkipped); |
|
807 |
#endif //PRODUCT |
|
808 |
||
809 |
rp = hdr.rp; |
|
810 |
if (rp > rplimit) |
|
811 |
abort("EOF reading archive header"); |
|
812 |
||
813 |
// Now size the CP. |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
814 |
#ifndef PRODUCT |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
815 |
bool x = (N_TAGS_IN_ORDER == cpool::NUM_COUNTS); |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
816 |
assert(x); |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
817 |
#endif //PRODUCT |
2 | 818 |
cp.init(this, cp_counts); |
819 |
CHECK; |
|
820 |
||
821 |
default_file_modtime = archive_modtime; |
|
822 |
if (default_file_modtime == 0 && !(archive_options & AO_HAVE_FILE_MODTIME)) |
|
823 |
default_file_modtime = DEFAULT_ARCHIVE_MODTIME; // taken from driver |
|
824 |
if ((archive_options & AO_DEFLATE_HINT) != 0) |
|
825 |
default_file_options |= FO_DEFLATE_HINT; |
|
826 |
||
827 |
// meta-bytes, if any, immediately follow archive header |
|
828 |
//band_headers.readData(band_headers_size); |
|
829 |
ensure_input(band_headers_size); |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
830 |
if (input_remaining() < (size_t)band_headers_size) { |
2 | 831 |
abort("EOF reading band headers"); |
832 |
return; |
|
833 |
} |
|
834 |
bytes band_headers; |
|
835 |
// The "1+" allows an initial byte to be pushed on the front. |
|
836 |
band_headers.set(1+U_NEW(byte, 1+band_headers_size+C_SLOP), |
|
837 |
band_headers_size); |
|
838 |
CHECK; |
|
839 |
// Start scanning band headers here: |
|
840 |
band_headers.copyFrom(rp, band_headers.len); |
|
841 |
rp += band_headers.len; |
|
842 |
assert(rp <= rplimit); |
|
843 |
meta_rp = band_headers.ptr; |
|
844 |
// Put evil meta-codes at the end of the band headers, |
|
845 |
// so we are sure to throw an error if we run off the end. |
|
846 |
bytes::of(band_headers.limit(), C_SLOP).clear(_meta_error); |
|
847 |
} |
|
848 |
||
849 |
void unpacker::finish() { |
|
850 |
if (verbose >= 1) { |
|
851 |
fprintf(errstrm, |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
852 |
"A total of " |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
853 |
LONG_LONG_FORMAT " bytes were read in %d segment(s).\n", |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
854 |
(bytes_read_before_reset+bytes_read), |
2 | 855 |
segments_read_before_reset+1); |
856 |
fprintf(errstrm, |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
857 |
"A total of " |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
858 |
LONG_LONG_FORMAT " file content bytes were written.\n", |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
859 |
(bytes_written_before_reset+bytes_written)); |
2 | 860 |
fprintf(errstrm, |
861 |
"A total of %d files (of which %d are classes) were written to output.\n", |
|
862 |
files_written_before_reset+files_written, |
|
863 |
classes_written_before_reset+classes_written); |
|
864 |
} |
|
865 |
if (jarout != null) |
|
866 |
jarout->closeJarFile(true); |
|
867 |
if (errstrm != null) { |
|
868 |
if (errstrm == stdout || errstrm == stderr) { |
|
869 |
fflush(errstrm); |
|
870 |
} else { |
|
871 |
fclose(errstrm); |
|
872 |
} |
|
873 |
errstrm = null; |
|
874 |
errstrm_name = null; |
|
875 |
} |
|
876 |
} |
|
877 |
||
878 |
||
879 |
// Cf. PackageReader.readConstantPoolCounts |
|
880 |
void cpool::init(unpacker* u_, int counts[NUM_COUNTS]) { |
|
881 |
this->u = u_; |
|
882 |
||
883 |
// Fill-pointer for CP. |
|
884 |
int next_entry = 0; |
|
885 |
||
886 |
// Size the constant pool: |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
887 |
for (int k = 0; k < (int)N_TAGS_IN_ORDER; k++) { |
2 | 888 |
byte tag = TAGS_IN_ORDER[k]; |
889 |
int len = counts[k]; |
|
890 |
tag_count[tag] = len; |
|
891 |
tag_base[tag] = next_entry; |
|
892 |
next_entry += len; |
|
893 |
// Detect and defend against constant pool size overflow. |
|
894 |
// (Pack200 forbids the sum of CP counts to exceed 2^29-1.) |
|
895 |
enum { |
|
896 |
CP_SIZE_LIMIT = (1<<29), |
|
897 |
IMPLICIT_ENTRY_COUNT = 1 // empty Utf8 string |
|
898 |
}; |
|
899 |
if (len >= (1<<29) || len < 0 |
|
900 |
|| next_entry >= CP_SIZE_LIMIT+IMPLICIT_ENTRY_COUNT) { |
|
901 |
abort("archive too large: constant pool limit exceeded"); |
|
902 |
return; |
|
903 |
} |
|
904 |
} |
|
905 |
||
906 |
// Close off the end of the CP: |
|
907 |
nentries = next_entry; |
|
908 |
||
909 |
// place a limit on future CP growth: |
|
910 |
int generous = 0; |
|
3463
054c9c1f9fd9
6830335: Java JAR Pack200 Decompression Integer Overflow Vulnerability
ksrini
parents:
2624
diff
changeset
|
911 |
generous = add_size(generous, u->ic_count); // implicit name |
054c9c1f9fd9
6830335: Java JAR Pack200 Decompression Integer Overflow Vulnerability
ksrini
parents:
2624
diff
changeset
|
912 |
generous = add_size(generous, u->ic_count); // outer |
054c9c1f9fd9
6830335: Java JAR Pack200 Decompression Integer Overflow Vulnerability
ksrini
parents:
2624
diff
changeset
|
913 |
generous = add_size(generous, u->ic_count); // outer.utf8 |
054c9c1f9fd9
6830335: Java JAR Pack200 Decompression Integer Overflow Vulnerability
ksrini
parents:
2624
diff
changeset
|
914 |
generous = add_size(generous, 40); // WKUs, misc |
054c9c1f9fd9
6830335: Java JAR Pack200 Decompression Integer Overflow Vulnerability
ksrini
parents:
2624
diff
changeset
|
915 |
generous = add_size(generous, u->class_count); // implicit SourceFile strings |
054c9c1f9fd9
6830335: Java JAR Pack200 Decompression Integer Overflow Vulnerability
ksrini
parents:
2624
diff
changeset
|
916 |
maxentries = add_size(nentries, generous); |
2 | 917 |
|
918 |
// Note that this CP does not include "empty" entries |
|
919 |
// for longs and doubles. Those are introduced when |
|
920 |
// the entries are renumbered for classfile output. |
|
921 |
||
922 |
entries = U_NEW(entry, maxentries); |
|
923 |
CHECK; |
|
924 |
||
925 |
first_extra_entry = &entries[nentries]; |
|
926 |
||
927 |
// Initialize the standard indexes. |
|
928 |
tag_count[CONSTANT_All] = nentries; |
|
929 |
tag_base[ CONSTANT_All] = 0; |
|
930 |
for (int tag = 0; tag < CONSTANT_Limit; tag++) { |
|
931 |
entry* cpMap = &entries[tag_base[tag]]; |
|
932 |
tag_index[tag].init(tag_count[tag], cpMap, tag); |
|
933 |
} |
|
934 |
||
935 |
// Initialize hashTab to a generous power-of-two size. |
|
936 |
uint pow2 = 1; |
|
937 |
uint target = maxentries + maxentries/2; // 60% full |
|
938 |
while (pow2 < target) pow2 <<= 1; |
|
939 |
hashTab = U_NEW(entry*, hashTabLength = pow2); |
|
940 |
} |
|
941 |
||
942 |
static byte* store_Utf8_char(byte* cp, unsigned short ch) { |
|
943 |
if (ch >= 0x001 && ch <= 0x007F) { |
|
944 |
*cp++ = (byte) ch; |
|
945 |
} else if (ch <= 0x07FF) { |
|
946 |
*cp++ = (byte) (0xC0 | ((ch >> 6) & 0x1F)); |
|
947 |
*cp++ = (byte) (0x80 | ((ch >> 0) & 0x3F)); |
|
948 |
} else { |
|
949 |
*cp++ = (byte) (0xE0 | ((ch >> 12) & 0x0F)); |
|
950 |
*cp++ = (byte) (0x80 | ((ch >> 6) & 0x3F)); |
|
951 |
*cp++ = (byte) (0x80 | ((ch >> 0) & 0x3F)); |
|
952 |
} |
|
953 |
return cp; |
|
954 |
} |
|
955 |
||
956 |
static byte* skip_Utf8_chars(byte* cp, int len) { |
|
957 |
for (;; cp++) { |
|
958 |
int ch = *cp & 0xFF; |
|
959 |
if ((ch & 0xC0) != 0x80) { |
|
960 |
if (len-- == 0) |
|
961 |
return cp; |
|
962 |
if (ch < 0x80 && len == 0) |
|
963 |
return cp+1; |
|
964 |
} |
|
965 |
} |
|
966 |
} |
|
967 |
||
968 |
static int compare_Utf8_chars(bytes& b1, bytes& b2) { |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
969 |
int l1 = (int)b1.len; |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
970 |
int l2 = (int)b2.len; |
2 | 971 |
int l0 = (l1 < l2) ? l1 : l2; |
972 |
byte* p1 = b1.ptr; |
|
973 |
byte* p2 = b2.ptr; |
|
974 |
int c0 = 0; |
|
975 |
for (int i = 0; i < l0; i++) { |
|
976 |
int c1 = p1[i] & 0xFF; |
|
977 |
int c2 = p2[i] & 0xFF; |
|
978 |
if (c1 != c2) { |
|
979 |
// Before returning the obvious answer, |
|
980 |
// check to see if c1 or c2 is part of a 0x0000, |
|
981 |
// which encodes as {0xC0,0x80}. The 0x0000 is the |
|
982 |
// lowest-sorting Java char value, and yet it encodes |
|
983 |
// as if it were the first char after 0x7F, which causes |
|
984 |
// strings containing nulls to sort too high. All other |
|
985 |
// comparisons are consistent between Utf8 and Java chars. |
|
986 |
if (c1 == 0xC0 && (p1[i+1] & 0xFF) == 0x80) c1 = 0; |
|
987 |
if (c2 == 0xC0 && (p2[i+1] & 0xFF) == 0x80) c2 = 0; |
|
988 |
if (c0 == 0xC0) { |
|
989 |
assert(((c1|c2) & 0xC0) == 0x80); // c1 & c2 are extension chars |
|
990 |
if (c1 == 0x80) c1 = 0; // will sort below c2 |
|
991 |
if (c2 == 0x80) c2 = 0; // will sort below c1 |
|
992 |
} |
|
993 |
return c1 - c2; |
|
994 |
} |
|
995 |
c0 = c1; // save away previous char |
|
996 |
} |
|
997 |
// common prefix is identical; return length difference if any |
|
998 |
return l1 - l2; |
|
999 |
} |
|
1000 |
||
1001 |
// Cf. PackageReader.readUtf8Bands |
|
1002 |
local_inline |
|
1003 |
void unpacker::read_Utf8_values(entry* cpMap, int len) { |
|
1004 |
// Implicit first Utf8 string is the empty string. |
|
1005 |
enum { |
|
1006 |
// certain bands begin with implicit zeroes |
|
1007 |
PREFIX_SKIP_2 = 2, |
|
1008 |
SUFFIX_SKIP_1 = 1 |
|
1009 |
}; |
|
1010 |
||
1011 |
int i; |
|
1012 |
||
1013 |
// First band: Read lengths of shared prefixes. |
|
1014 |
if (len > PREFIX_SKIP_2) |
|
1015 |
cp_Utf8_prefix.readData(len - PREFIX_SKIP_2); |
|
2602
5b394a4b6ce1
6755943: Java JAR Pack200 Decompression should enforce stricter header checks
ksrini
parents:
2
diff
changeset
|
1016 |
NOT_PRODUCT(else cp_Utf8_prefix.readData(0)); // for asserts |
2 | 1017 |
|
1018 |
// Second band: Read lengths of unshared suffixes: |
|
1019 |
if (len > SUFFIX_SKIP_1) |
|
1020 |
cp_Utf8_suffix.readData(len - SUFFIX_SKIP_1); |
|
2602
5b394a4b6ce1
6755943: Java JAR Pack200 Decompression should enforce stricter header checks
ksrini
parents:
2
diff
changeset
|
1021 |
NOT_PRODUCT(else cp_Utf8_suffix.readData(0)); // for asserts |
2 | 1022 |
|
1023 |
bytes* allsuffixes = T_NEW(bytes, len); |
|
1024 |
CHECK; |
|
1025 |
||
1026 |
int nbigsuf = 0; |
|
1027 |
fillbytes charbuf; // buffer to allocate small strings |
|
1028 |
charbuf.init(); |
|
1029 |
||
1030 |
// Third band: Read the char values in the unshared suffixes: |
|
1031 |
cp_Utf8_chars.readData(cp_Utf8_suffix.getIntTotal()); |
|
1032 |
for (i = 0; i < len; i++) { |
|
1033 |
int suffix = (i < SUFFIX_SKIP_1)? 0: cp_Utf8_suffix.getInt(); |
|
1034 |
if (suffix < 0) { |
|
1035 |
abort("bad utf8 suffix"); |
|
1036 |
return; |
|
1037 |
} |
|
1038 |
if (suffix == 0 && i >= SUFFIX_SKIP_1) { |
|
1039 |
// chars are packed in cp_Utf8_big_chars |
|
1040 |
nbigsuf += 1; |
|
1041 |
continue; |
|
1042 |
} |
|
1043 |
bytes& chars = allsuffixes[i]; |
|
1044 |
uint size3 = suffix * 3; // max Utf8 length |
|
1045 |
bool isMalloc = (suffix > SMALL); |
|
1046 |
if (isMalloc) { |
|
1047 |
chars.malloc(size3); |
|
1048 |
} else { |
|
1049 |
if (!charbuf.canAppend(size3+1)) { |
|
1050 |
assert(charbuf.allocated == 0 || tmallocs.contains(charbuf.base())); |
|
1051 |
charbuf.init(CHUNK); // Reset to new buffer. |
|
1052 |
tmallocs.add(charbuf.base()); |
|
1053 |
} |
|
1054 |
chars.set(charbuf.grow(size3+1), size3); |
|
1055 |
} |
|
1056 |
CHECK; |
|
1057 |
byte* chp = chars.ptr; |
|
1058 |
for (int j = 0; j < suffix; j++) { |
|
1059 |
unsigned short ch = cp_Utf8_chars.getInt(); |
|
1060 |
chp = store_Utf8_char(chp, ch); |
|
1061 |
} |
|
1062 |
// shrink to fit: |
|
1063 |
if (isMalloc) { |
|
1064 |
chars.realloc(chp - chars.ptr); |
|
1065 |
CHECK; |
|
1066 |
tmallocs.add(chars.ptr); // free it later |
|
1067 |
} else { |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
1068 |
int shrink = (int)(chars.limit() - chp); |
2 | 1069 |
chars.len -= shrink; |
1070 |
charbuf.b.len -= shrink; // ungrow to reclaim buffer space |
|
1071 |
// Note that we did not reclaim the final '\0'. |
|
1072 |
assert(chars.limit() == charbuf.limit()-1); |
|
1073 |
assert(strlen((char*)chars.ptr) == chars.len); |
|
1074 |
} |
|
1075 |
} |
|
1076 |
//cp_Utf8_chars.done(); |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
1077 |
#ifndef PRODUCT |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
1078 |
charbuf.b.set(null, 0); // tidy |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
1079 |
#endif |
2 | 1080 |
|
1081 |
// Fourth band: Go back and size the specially packed strings. |
|
1082 |
int maxlen = 0; |
|
1083 |
cp_Utf8_big_suffix.readData(nbigsuf); |
|
1084 |
cp_Utf8_suffix.rewind(); |
|
1085 |
for (i = 0; i < len; i++) { |
|
1086 |
int suffix = (i < SUFFIX_SKIP_1)? 0: cp_Utf8_suffix.getInt(); |
|
1087 |
int prefix = (i < PREFIX_SKIP_2)? 0: cp_Utf8_prefix.getInt(); |
|
1088 |
if (prefix < 0 || prefix+suffix < 0) { |
|
1089 |
abort("bad utf8 prefix"); |
|
1090 |
return; |
|
1091 |
} |
|
1092 |
bytes& chars = allsuffixes[i]; |
|
1093 |
if (suffix == 0 && i >= SUFFIX_SKIP_1) { |
|
1094 |
suffix = cp_Utf8_big_suffix.getInt(); |
|
1095 |
assert(chars.ptr == null); |
|
1096 |
chars.len = suffix; // just a momentary hack |
|
1097 |
} else { |
|
1098 |
assert(chars.ptr != null); |
|
1099 |
} |
|
1100 |
if (maxlen < prefix + suffix) { |
|
1101 |
maxlen = prefix + suffix; |
|
1102 |
} |
|
1103 |
} |
|
1104 |
//cp_Utf8_suffix.done(); // will use allsuffixes[i].len (ptr!=null) |
|
1105 |
//cp_Utf8_big_suffix.done(); // will use allsuffixes[i].len |
|
1106 |
||
1107 |
// Fifth band(s): Get the specially packed characters. |
|
1108 |
cp_Utf8_big_suffix.rewind(); |
|
1109 |
for (i = 0; i < len; i++) { |
|
1110 |
bytes& chars = allsuffixes[i]; |
|
1111 |
if (chars.ptr != null) continue; // already input |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
1112 |
int suffix = (int)chars.len; // pick up the hack |
2 | 1113 |
uint size3 = suffix * 3; |
1114 |
if (suffix == 0) continue; // done with empty string |
|
1115 |
chars.malloc(size3); |
|
1116 |
byte* chp = chars.ptr; |
|
1117 |
band saved_band = cp_Utf8_big_chars; |
|
1118 |
cp_Utf8_big_chars.readData(suffix); |
|
1119 |
for (int j = 0; j < suffix; j++) { |
|
1120 |
unsigned short ch = cp_Utf8_big_chars.getInt(); |
|
1121 |
chp = store_Utf8_char(chp, ch); |
|
1122 |
} |
|
1123 |
chars.realloc(chp - chars.ptr); |
|
1124 |
CHECK; |
|
1125 |
tmallocs.add(chars.ptr); // free it later |
|
1126 |
//cp_Utf8_big_chars.done(); |
|
1127 |
cp_Utf8_big_chars = saved_band; // reset the band for the next string |
|
1128 |
} |
|
1129 |
cp_Utf8_big_chars.readData(0); // zero chars |
|
1130 |
//cp_Utf8_big_chars.done(); |
|
1131 |
||
1132 |
// Finally, sew together all the prefixes and suffixes. |
|
1133 |
bytes bigbuf; |
|
1134 |
bigbuf.malloc(maxlen * 3 + 1); // max Utf8 length, plus slop for null |
|
1135 |
CHECK; |
|
1136 |
int prevlen = 0; // previous string length (in chars) |
|
1137 |
tmallocs.add(bigbuf.ptr); // free after this block |
|
1138 |
cp_Utf8_prefix.rewind(); |
|
1139 |
for (i = 0; i < len; i++) { |
|
1140 |
bytes& chars = allsuffixes[i]; |
|
1141 |
int prefix = (i < PREFIX_SKIP_2)? 0: cp_Utf8_prefix.getInt(); |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
1142 |
int suffix = (int)chars.len; |
2 | 1143 |
byte* fillp; |
1144 |
// by induction, the buffer is already filled with the prefix |
|
1145 |
// make sure the prefix value is not corrupted, though: |
|
1146 |
if (prefix > prevlen) { |
|
1147 |
abort("utf8 prefix overflow"); |
|
1148 |
return; |
|
1149 |
} |
|
1150 |
fillp = skip_Utf8_chars(bigbuf.ptr, prefix); |
|
1151 |
// copy the suffix into the same buffer: |
|
1152 |
fillp = chars.writeTo(fillp); |
|
1153 |
assert(bigbuf.inBounds(fillp)); |
|
1154 |
*fillp = 0; // bigbuf must contain a well-formed Utf8 string |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
1155 |
int length = (int)(fillp - bigbuf.ptr); |
2 | 1156 |
bytes& value = cpMap[i].value.b; |
5191
79b41f733e33
6902299: Java JAR "unpack200" must verify input parameters
ksrini
parents:
3463
diff
changeset
|
1157 |
value.set(U_NEW(byte, add_size(length,1)), length); |
2 | 1158 |
value.copyFrom(bigbuf.ptr, length); |
1159 |
CHECK; |
|
1160 |
// Index all Utf8 strings |
|
1161 |
entry* &htref = cp.hashTabRef(CONSTANT_Utf8, value); |
|
1162 |
if (htref == null) { |
|
1163 |
// Note that if two identical strings are transmitted, |
|
1164 |
// the first is taken to be the canonical one. |
|
1165 |
htref = &cpMap[i]; |
|
1166 |
} |
|
1167 |
prevlen = prefix + suffix; |
|
1168 |
} |
|
1169 |
//cp_Utf8_prefix.done(); |
|
1170 |
||
1171 |
// Free intermediate buffers. |
|
1172 |
free_temps(); |
|
1173 |
} |
|
1174 |
||
1175 |
local_inline |
|
1176 |
void unpacker::read_single_words(band& cp_band, entry* cpMap, int len) { |
|
1177 |
cp_band.readData(len); |
|
1178 |
for (int i = 0; i < len; i++) { |
|
1179 |
cpMap[i].value.i = cp_band.getInt(); // coding handles signs OK |
|
1180 |
} |
|
1181 |
} |
|
1182 |
||
1183 |
maybe_inline |
|
1184 |
void unpacker::read_double_words(band& cp_bands, entry* cpMap, int len) { |
|
1185 |
band& cp_band_hi = cp_bands; |
|
1186 |
band& cp_band_lo = cp_bands.nextBand(); |
|
1187 |
cp_band_hi.readData(len); |
|
1188 |
cp_band_lo.readData(len); |
|
1189 |
for (int i = 0; i < len; i++) { |
|
1190 |
cpMap[i].value.l = cp_band_hi.getLong(cp_band_lo, true); |
|
1191 |
} |
|
1192 |
//cp_band_hi.done(); |
|
1193 |
//cp_band_lo.done(); |
|
1194 |
} |
|
1195 |
||
1196 |
maybe_inline |
|
1197 |
void unpacker::read_single_refs(band& cp_band, byte refTag, entry* cpMap, int len) { |
|
1198 |
assert(refTag == CONSTANT_Utf8); |
|
1199 |
cp_band.setIndexByTag(refTag); |
|
1200 |
cp_band.readData(len); |
|
1201 |
CHECK; |
|
1202 |
int indexTag = (cp_band.bn == e_cp_Class) ? CONSTANT_Class : 0; |
|
1203 |
for (int i = 0; i < len; i++) { |
|
1204 |
entry& e = cpMap[i]; |
|
1205 |
e.refs = U_NEW(entry*, e.nrefs = 1); |
|
1206 |
entry* utf = cp_band.getRef(); |
|
1207 |
CHECK; |
|
1208 |
e.refs[0] = utf; |
|
1209 |
e.value.b = utf->value.b; // copy value of Utf8 string to self |
|
1210 |
if (indexTag != 0) { |
|
1211 |
// Maintain cross-reference: |
|
1212 |
entry* &htref = cp.hashTabRef(indexTag, e.value.b); |
|
1213 |
if (htref == null) { |
|
1214 |
// Note that if two identical classes are transmitted, |
|
1215 |
// the first is taken to be the canonical one. |
|
1216 |
htref = &e; |
|
1217 |
} |
|
1218 |
} |
|
1219 |
} |
|
1220 |
//cp_band.done(); |
|
1221 |
} |
|
1222 |
||
1223 |
maybe_inline |
|
1224 |
void unpacker::read_double_refs(band& cp_band, byte ref1Tag, byte ref2Tag, |
|
1225 |
entry* cpMap, int len) { |
|
1226 |
band& cp_band1 = cp_band; |
|
1227 |
band& cp_band2 = cp_band.nextBand(); |
|
1228 |
cp_band1.setIndexByTag(ref1Tag); |
|
1229 |
cp_band2.setIndexByTag(ref2Tag); |
|
1230 |
cp_band1.readData(len); |
|
1231 |
cp_band2.readData(len); |
|
1232 |
CHECK; |
|
1233 |
for (int i = 0; i < len; i++) { |
|
1234 |
entry& e = cpMap[i]; |
|
1235 |
e.refs = U_NEW(entry*, e.nrefs = 2); |
|
1236 |
e.refs[0] = cp_band1.getRef(); |
|
1237 |
e.refs[1] = cp_band2.getRef(); |
|
1238 |
CHECK; |
|
1239 |
} |
|
1240 |
//cp_band1.done(); |
|
1241 |
//cp_band2.done(); |
|
1242 |
} |
|
1243 |
||
1244 |
// Cf. PackageReader.readSignatureBands |
|
1245 |
maybe_inline |
|
1246 |
void unpacker::read_signature_values(entry* cpMap, int len) { |
|
1247 |
cp_Signature_form.setIndexByTag(CONSTANT_Utf8); |
|
1248 |
cp_Signature_form.readData(len); |
|
1249 |
CHECK; |
|
1250 |
int ncTotal = 0; |
|
1251 |
int i; |
|
1252 |
for (i = 0; i < len; i++) { |
|
1253 |
entry& e = cpMap[i]; |
|
1254 |
entry& form = *cp_Signature_form.getRef(); |
|
1255 |
CHECK; |
|
1256 |
int nc = 0; |
|
1257 |
||
1258 |
for ( const char* ncp = form.utf8String() ; *ncp; ncp++) { |
|
1259 |
if (*ncp == 'L') nc++; |
|
1260 |
} |
|
1261 |
||
1262 |
ncTotal += nc; |
|
1263 |
e.refs = U_NEW(entry*, cpMap[i].nrefs = 1 + nc); |
|
1264 |
CHECK; |
|
1265 |
e.refs[0] = &form; |
|
1266 |
} |
|
1267 |
//cp_Signature_form.done(); |
|
1268 |
cp_Signature_classes.setIndexByTag(CONSTANT_Class); |
|
1269 |
cp_Signature_classes.readData(ncTotal); |
|
1270 |
for (i = 0; i < len; i++) { |
|
1271 |
entry& e = cpMap[i]; |
|
1272 |
for (int j = 1; j < e.nrefs; j++) { |
|
1273 |
e.refs[j] = cp_Signature_classes.getRef(); |
|
1274 |
CHECK; |
|
1275 |
} |
|
1276 |
} |
|
1277 |
//cp_Signature_classes.done(); |
|
1278 |
} |
|
1279 |
||
1280 |
// Cf. PackageReader.readConstantPool |
|
1281 |
void unpacker::read_cp() { |
|
1282 |
byte* rp0 = rp; |
|
1283 |
||
1284 |
int i; |
|
1285 |
||
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
1286 |
for (int k = 0; k < (int)N_TAGS_IN_ORDER; k++) { |
2 | 1287 |
byte tag = TAGS_IN_ORDER[k]; |
1288 |
int len = cp.tag_count[tag]; |
|
1289 |
int base = cp.tag_base[tag]; |
|
1290 |
||
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
1291 |
PRINTCR((1,"Reading %d %s entries...", len, NOT_PRODUCT(TAG_NAME[tag])+0)); |
2 | 1292 |
entry* cpMap = &cp.entries[base]; |
1293 |
for (i = 0; i < len; i++) { |
|
1294 |
cpMap[i].tag = tag; |
|
1295 |
cpMap[i].inord = i; |
|
1296 |
} |
|
1297 |
||
1298 |
switch (tag) { |
|
1299 |
case CONSTANT_Utf8: |
|
1300 |
read_Utf8_values(cpMap, len); |
|
1301 |
break; |
|
1302 |
case CONSTANT_Integer: |
|
1303 |
read_single_words(cp_Int, cpMap, len); |
|
1304 |
break; |
|
1305 |
case CONSTANT_Float: |
|
1306 |
read_single_words(cp_Float, cpMap, len); |
|
1307 |
break; |
|
1308 |
case CONSTANT_Long: |
|
1309 |
read_double_words(cp_Long_hi /*& cp_Long_lo*/, cpMap, len); |
|
1310 |
break; |
|
1311 |
case CONSTANT_Double: |
|
1312 |
read_double_words(cp_Double_hi /*& cp_Double_lo*/, cpMap, len); |
|
1313 |
break; |
|
1314 |
case CONSTANT_String: |
|
1315 |
read_single_refs(cp_String, CONSTANT_Utf8, cpMap, len); |
|
1316 |
break; |
|
1317 |
case CONSTANT_Class: |
|
1318 |
read_single_refs(cp_Class, CONSTANT_Utf8, cpMap, len); |
|
1319 |
break; |
|
1320 |
case CONSTANT_Signature: |
|
1321 |
read_signature_values(cpMap, len); |
|
1322 |
break; |
|
1323 |
case CONSTANT_NameandType: |
|
1324 |
read_double_refs(cp_Descr_name /*& cp_Descr_type*/, |
|
1325 |
CONSTANT_Utf8, CONSTANT_Signature, |
|
1326 |
cpMap, len); |
|
1327 |
break; |
|
1328 |
case CONSTANT_Fieldref: |
|
1329 |
read_double_refs(cp_Field_class /*& cp_Field_desc*/, |
|
1330 |
CONSTANT_Class, CONSTANT_NameandType, |
|
1331 |
cpMap, len); |
|
1332 |
break; |
|
1333 |
case CONSTANT_Methodref: |
|
1334 |
read_double_refs(cp_Method_class /*& cp_Method_desc*/, |
|
1335 |
CONSTANT_Class, CONSTANT_NameandType, |
|
1336 |
cpMap, len); |
|
1337 |
break; |
|
1338 |
case CONSTANT_InterfaceMethodref: |
|
1339 |
read_double_refs(cp_Imethod_class /*& cp_Imethod_desc*/, |
|
1340 |
CONSTANT_Class, CONSTANT_NameandType, |
|
1341 |
cpMap, len); |
|
1342 |
break; |
|
1343 |
default: |
|
1344 |
assert(false); |
|
1345 |
break; |
|
1346 |
} |
|
1347 |
||
1348 |
// Initialize the tag's CP index right away, since it might be needed |
|
1349 |
// in the next pass to initialize the CP for another tag. |
|
1350 |
#ifndef PRODUCT |
|
1351 |
cpindex* ix = &cp.tag_index[tag]; |
|
1352 |
assert(ix->ixTag == tag); |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
1353 |
assert((int)ix->len == len); |
2 | 1354 |
assert(ix->base1 == cpMap); |
1355 |
#endif |
|
1356 |
CHECK; |
|
1357 |
} |
|
1358 |
||
1359 |
cp.expandSignatures(); |
|
1360 |
CHECK; |
|
1361 |
cp.initMemberIndexes(); |
|
1362 |
CHECK; |
|
1363 |
||
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
1364 |
PRINTCR((1,"parsed %d constant pool entries in %d bytes", cp.nentries, (rp - rp0))); |
2 | 1365 |
|
1366 |
#define SNAME(n,s) #s "\0" |
|
1367 |
const char* symNames = ( |
|
1368 |
ALL_ATTR_DO(SNAME) |
|
1369 |
"<init>" |
|
1370 |
); |
|
1371 |
#undef SNAME |
|
1372 |
||
1373 |
for (int sn = 0; sn < cpool::s_LIMIT; sn++) { |
|
1374 |
assert(symNames[0] >= '0' && symNames[0] <= 'Z'); // sanity |
|
1375 |
bytes name; name.set(symNames); |
|
1376 |
if (name.len > 0 && name.ptr[0] != '0') { |
|
1377 |
cp.sym[sn] = cp.ensureUtf8(name); |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
1378 |
PRINTCR((4, "well-known sym %d=%s", sn, cp.sym[sn]->string())); |
2 | 1379 |
} |
1380 |
symNames += name.len + 1; // skip trailing null to next name |
|
1381 |
} |
|
1382 |
||
1383 |
band::initIndexes(this); |
|
1384 |
} |
|
1385 |
||
1386 |
static band* no_bands[] = { null }; // shared empty body |
|
1387 |
||
1388 |
inline |
|
1389 |
band& unpacker::attr_definitions::fixed_band(int e_class_xxx) { |
|
1390 |
return u->all_bands[xxx_flags_hi_bn + (e_class_xxx-e_class_flags_hi)]; |
|
1391 |
} |
|
1392 |
inline band& unpacker::attr_definitions::xxx_flags_hi() |
|
1393 |
{ return fixed_band(e_class_flags_hi); } |
|
1394 |
inline band& unpacker::attr_definitions::xxx_flags_lo() |
|
1395 |
{ return fixed_band(e_class_flags_lo); } |
|
1396 |
inline band& unpacker::attr_definitions::xxx_attr_count() |
|
1397 |
{ return fixed_band(e_class_attr_count); } |
|
1398 |
inline band& unpacker::attr_definitions::xxx_attr_indexes() |
|
1399 |
{ return fixed_band(e_class_attr_indexes); } |
|
1400 |
inline band& unpacker::attr_definitions::xxx_attr_calls() |
|
1401 |
{ return fixed_band(e_class_attr_calls); } |
|
1402 |
||
1403 |
||
1404 |
inline |
|
1405 |
unpacker::layout_definition* |
|
1406 |
unpacker::attr_definitions::defineLayout(int idx, |
|
1407 |
entry* nameEntry, |
|
1408 |
const char* layout) { |
|
1409 |
const char* name = nameEntry->value.b.strval(); |
|
1410 |
layout_definition* lo = defineLayout(idx, name, layout); |
|
1411 |
CHECK_0; |
|
1412 |
lo->nameEntry = nameEntry; |
|
1413 |
return lo; |
|
1414 |
} |
|
1415 |
||
1416 |
unpacker::layout_definition* |
|
1417 |
unpacker::attr_definitions::defineLayout(int idx, |
|
1418 |
const char* name, |
|
1419 |
const char* layout) { |
|
1420 |
assert(flag_limit != 0); // must be set up already |
|
1421 |
if (idx >= 0) { |
|
1422 |
// Fixed attr. |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
1423 |
if (idx >= (int)flag_limit) |
2 | 1424 |
abort("attribute index too large"); |
1425 |
if (isRedefined(idx)) |
|
1426 |
abort("redefined attribute index"); |
|
1427 |
redef |= ((julong)1<<idx); |
|
1428 |
} else { |
|
1429 |
idx = flag_limit + overflow_count.length(); |
|
1430 |
overflow_count.add(0); // make a new counter |
|
1431 |
} |
|
1432 |
layout_definition* lo = U_NEW(layout_definition, 1); |
|
1433 |
CHECK_0; |
|
1434 |
lo->idx = idx; |
|
1435 |
lo->name = name; |
|
1436 |
lo->layout = layout; |
|
1437 |
for (int adds = (idx+1) - layouts.length(); adds > 0; adds--) { |
|
1438 |
layouts.add(null); |
|
1439 |
} |
|
1440 |
CHECK_0; |
|
1441 |
layouts.get(idx) = lo; |
|
1442 |
return lo; |
|
1443 |
} |
|
1444 |
||
1445 |
band** |
|
1446 |
unpacker::attr_definitions::buildBands(unpacker::layout_definition* lo) { |
|
1447 |
int i; |
|
1448 |
if (lo->elems != null) |
|
1449 |
return lo->bands(); |
|
1450 |
if (lo->layout[0] == '\0') { |
|
1451 |
lo->elems = no_bands; |
|
1452 |
} else { |
|
1453 |
// Create bands for this attribute by parsing the layout. |
|
1454 |
bool hasCallables = lo->hasCallables(); |
|
1455 |
bands_made = 0x10000; // base number for bands made |
|
1456 |
const char* lp = lo->layout; |
|
1457 |
lp = parseLayout(lp, lo->elems, -1); |
|
1458 |
CHECK_0; |
|
1459 |
if (lp[0] != '\0' || band_stack.length() > 0) { |
|
1460 |
abort("garbage at end of layout"); |
|
1461 |
} |
|
1462 |
band_stack.popTo(0); |
|
1463 |
CHECK_0; |
|
1464 |
||
1465 |
// Fix up callables to point at their callees. |
|
1466 |
band** bands = lo->elems; |
|
1467 |
assert(bands == lo->bands()); |
|
1468 |
int num_callables = 0; |
|
1469 |
if (hasCallables) { |
|
1470 |
while (bands[num_callables] != null) { |
|
1471 |
if (bands[num_callables]->le_kind != EK_CBLE) { |
|
1472 |
abort("garbage mixed with callables"); |
|
1473 |
break; |
|
1474 |
} |
|
1475 |
num_callables += 1; |
|
1476 |
} |
|
1477 |
} |
|
1478 |
for (i = 0; i < calls_to_link.length(); i++) { |
|
1479 |
band& call = *(band*) calls_to_link.get(i); |
|
1480 |
assert(call.le_kind == EK_CALL); |
|
1481 |
// Determine the callee. |
|
1482 |
int call_num = call.le_len; |
|
1483 |
if (call_num < 0 || call_num >= num_callables) { |
|
1484 |
abort("bad call in layout"); |
|
1485 |
break; |
|
1486 |
} |
|
1487 |
band& cble = *bands[call_num]; |
|
1488 |
// Link the call to it. |
|
1489 |
call.le_body[0] = &cble; |
|
1490 |
// Distinguish backward calls and callables: |
|
1491 |
assert(cble.le_kind == EK_CBLE); |
|
1492 |
assert(cble.le_len == call_num); |
|
1493 |
cble.le_back |= call.le_back; |
|
1494 |
} |
|
1495 |
calls_to_link.popTo(0); |
|
1496 |
} |
|
1497 |
return lo->elems; |
|
1498 |
} |
|
1499 |
||
1500 |
/* attribute layout language parser |
|
1501 |
||
1502 |
attribute_layout: |
|
1503 |
( layout_element )* | ( callable )+ |
|
1504 |
layout_element: |
|
1505 |
( integral | replication | union | call | reference ) |
|
1506 |
||
1507 |
callable: |
|
1508 |
'[' body ']' |
|
1509 |
body: |
|
1510 |
( layout_element )+ |
|
1511 |
||
1512 |
integral: |
|
1513 |
( unsigned_int | signed_int | bc_index | bc_offset | flag ) |
|
1514 |
unsigned_int: |
|
1515 |
uint_type |
|
1516 |
signed_int: |
|
1517 |
'S' uint_type |
|
1518 |
any_int: |
|
1519 |
( unsigned_int | signed_int ) |
|
1520 |
bc_index: |
|
1521 |
( 'P' uint_type | 'PO' uint_type ) |
|
1522 |
bc_offset: |
|
1523 |
'O' any_int |
|
1524 |
flag: |
|
1525 |
'F' uint_type |
|
1526 |
uint_type: |
|
1527 |
( 'B' | 'H' | 'I' | 'V' ) |
|
1528 |
||
1529 |
replication: |
|
1530 |
'N' uint_type '[' body ']' |
|
1531 |
||
1532 |
union: |
|
1533 |
'T' any_int (union_case)* '(' ')' '[' (body)? ']' |
|
1534 |
union_case: |
|
1535 |
'(' union_case_tag (',' union_case_tag)* ')' '[' (body)? ']' |
|
1536 |
union_case_tag: |
|
1537 |
( numeral | numeral '-' numeral ) |
|
1538 |
call: |
|
1539 |
'(' numeral ')' |
|
1540 |
||
1541 |
reference: |
|
1542 |
reference_type ( 'N' )? uint_type |
|
1543 |
reference_type: |
|
1544 |
( constant_ref | schema_ref | utf8_ref | untyped_ref ) |
|
1545 |
constant_ref: |
|
1546 |
( 'KI' | 'KJ' | 'KF' | 'KD' | 'KS' | 'KQ' ) |
|
1547 |
schema_ref: |
|
1548 |
( 'RC' | 'RS' | 'RD' | 'RF' | 'RM' | 'RI' ) |
|
1549 |
utf8_ref: |
|
1550 |
'RU' |
|
1551 |
untyped_ref: |
|
1552 |
'RQ' |
|
1553 |
||
1554 |
numeral: |
|
1555 |
'(' ('-')? (digit)+ ')' |
|
1556 |
digit: |
|
1557 |
( '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' ) |
|
1558 |
||
1559 |
*/ |
|
1560 |
||
1561 |
const char* |
|
1562 |
unpacker::attr_definitions::parseIntLayout(const char* lp, band* &res, |
|
1563 |
byte le_kind, bool can_be_signed) { |
|
1564 |
const char* lp0 = lp; |
|
1565 |
band* b = U_NEW(band, 1); |
|
1566 |
CHECK_(lp); |
|
1567 |
char le = *lp++; |
|
1568 |
int spec = UNSIGNED5_spec; |
|
1569 |
if (le == 'S' && can_be_signed) { |
|
1570 |
// Note: This is the last use of sign. There is no 'EF_SIGN'. |
|
1571 |
spec = SIGNED5_spec; |
|
1572 |
le = *lp++; |
|
1573 |
} else if (le == 'B') { |
|
1574 |
spec = BYTE1_spec; // unsigned byte |
|
1575 |
} |
|
1576 |
b->init(u, bands_made++, spec); |
|
1577 |
b->le_kind = le_kind; |
|
1578 |
int le_len = 0; |
|
1579 |
switch (le) { |
|
1580 |
case 'B': le_len = 1; break; |
|
1581 |
case 'H': le_len = 2; break; |
|
1582 |
case 'I': le_len = 4; break; |
|
1583 |
case 'V': le_len = 0; break; |
|
1584 |
default: abort("bad layout element"); |
|
1585 |
} |
|
1586 |
b->le_len = le_len; |
|
1587 |
band_stack.add(b); |
|
1588 |
res = b; |
|
1589 |
return lp; |
|
1590 |
} |
|
1591 |
||
1592 |
const char* |
|
1593 |
unpacker::attr_definitions::parseNumeral(const char* lp, int &res) { |
|
1594 |
const char* lp0 = lp; |
|
1595 |
bool sgn = false; |
|
1596 |
if (*lp == '0') { res = 0; return lp+1; } // special case '0' |
|
1597 |
if (*lp == '-') { sgn = true; lp++; } |
|
1598 |
const char* dp = lp; |
|
1599 |
int con = 0; |
|
1600 |
while (*dp >= '0' && *dp <= '9') { |
|
1601 |
int con0 = con; |
|
1602 |
con *= 10; |
|
1603 |
con += (*dp++) - '0'; |
|
1604 |
if (con <= con0) { con = -1; break; } // numeral overflow |
|
1605 |
} |
|
1606 |
if (lp == dp) { |
|
1607 |
abort("missing numeral in layout"); |
|
1608 |
return ""; |
|
1609 |
} |
|
1610 |
lp = dp; |
|
1611 |
if (con < 0 && !(sgn && con == -con)) { |
|
1612 |
// (Portability note: Misses the error if int is not 32 bits.) |
|
1613 |
abort("numeral overflow"); |
|
1614 |
return "" ; |
|
1615 |
} |
|
1616 |
if (sgn) con = -con; |
|
1617 |
res = con; |
|
1618 |
return lp; |
|
1619 |
} |
|
1620 |
||
1621 |
band** |
|
1622 |
unpacker::attr_definitions::popBody(int bs_base) { |
|
1623 |
// Return everything that was pushed, as a null-terminated pointer array. |
|
1624 |
int bs_limit = band_stack.length(); |
|
1625 |
if (bs_base == bs_limit) { |
|
1626 |
return no_bands; |
|
1627 |
} else { |
|
1628 |
int nb = bs_limit - bs_base; |
|
5191
79b41f733e33
6902299: Java JAR "unpack200" must verify input parameters
ksrini
parents:
3463
diff
changeset
|
1629 |
band** res = U_NEW(band*, add_size(nb, 1)); |
2 | 1630 |
CHECK_(no_bands); |
1631 |
for (int i = 0; i < nb; i++) { |
|
1632 |
band* b = (band*) band_stack.get(bs_base + i); |
|
1633 |
res[i] = b; |
|
1634 |
} |
|
1635 |
band_stack.popTo(bs_base); |
|
1636 |
return res; |
|
1637 |
} |
|
1638 |
} |
|
1639 |
||
1640 |
const char* |
|
1641 |
unpacker::attr_definitions::parseLayout(const char* lp, band** &res, |
|
1642 |
int curCble) { |
|
1643 |
const char* lp0 = lp; |
|
1644 |
int bs_base = band_stack.length(); |
|
1645 |
bool top_level = (bs_base == 0); |
|
1646 |
band* b; |
|
1647 |
enum { can_be_signed = true }; // optional arg to parseIntLayout |
|
1648 |
||
1649 |
for (bool done = false; !done; ) { |
|
1650 |
switch (*lp++) { |
|
1651 |
case 'B': case 'H': case 'I': case 'V': // unsigned_int |
|
1652 |
case 'S': // signed_int |
|
1653 |
--lp; // reparse |
|
1654 |
case 'F': |
|
1655 |
lp = parseIntLayout(lp, b, EK_INT); |
|
1656 |
break; |
|
1657 |
case 'P': |
|
1658 |
{ |
|
1659 |
int le_bci = EK_BCI; |
|
1660 |
if (*lp == 'O') { |
|
1661 |
++lp; |
|
1662 |
le_bci = EK_BCID; |
|
1663 |
} |
|
1664 |
assert(*lp != 'S'); // no PSH, etc. |
|
1665 |
lp = parseIntLayout(lp, b, EK_INT); |
|
1666 |
b->le_bci = le_bci; |
|
1667 |
if (le_bci == EK_BCI) |
|
1668 |
b->defc = coding::findBySpec(BCI5_spec); |
|
1669 |
else |
|
1670 |
b->defc = coding::findBySpec(BRANCH5_spec); |
|
1671 |
} |
|
1672 |
break; |
|
1673 |
case 'O': |
|
1674 |
lp = parseIntLayout(lp, b, EK_INT, can_be_signed); |
|
1675 |
b->le_bci = EK_BCO; |
|
1676 |
b->defc = coding::findBySpec(BRANCH5_spec); |
|
1677 |
break; |
|
1678 |
case 'N': // replication: 'N' uint '[' elem ... ']' |
|
1679 |
lp = parseIntLayout(lp, b, EK_REPL); |
|
1680 |
assert(*lp == '['); |
|
1681 |
++lp; |
|
1682 |
lp = parseLayout(lp, b->le_body, curCble); |
|
1683 |
CHECK_(lp); |
|
1684 |
break; |
|
1685 |
case 'T': // union: 'T' any_int union_case* '(' ')' '[' body ']' |
|
1686 |
lp = parseIntLayout(lp, b, EK_UN, can_be_signed); |
|
1687 |
{ |
|
1688 |
int union_base = band_stack.length(); |
|
1689 |
for (;;) { // for each case |
|
1690 |
band& k_case = *U_NEW(band, 1); |
|
1691 |
CHECK_(lp); |
|
1692 |
band_stack.add(&k_case); |
|
1693 |
k_case.le_kind = EK_CASE; |
|
1694 |
k_case.bn = bands_made++; |
|
1695 |
if (*lp++ != '(') { |
|
1696 |
abort("bad union case"); |
|
1697 |
return ""; |
|
1698 |
} |
|
1699 |
if (*lp++ != ')') { |
|
1700 |
--lp; // reparse |
|
1701 |
// Read some case values. (Use band_stack for temp. storage.) |
|
1702 |
int case_base = band_stack.length(); |
|
1703 |
for (;;) { |
|
1704 |
int caseval = 0; |
|
1705 |
lp = parseNumeral(lp, caseval); |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
1706 |
band_stack.add((void*)(size_t)caseval); |
2 | 1707 |
if (*lp == '-') { |
1708 |
// new in version 160, allow (1-5) for (1,2,3,4,5) |
|
1709 |
if (u->majver < JAVA6_PACKAGE_MAJOR_VERSION) { |
|
1710 |
abort("bad range in union case label (old archive format)"); |
|
1711 |
return ""; |
|
1712 |
} |
|
1713 |
int caselimit = caseval; |
|
1714 |
lp++; |
|
1715 |
lp = parseNumeral(lp, caselimit); |
|
1716 |
if (caseval >= caselimit |
|
1717 |
|| (uint)(caselimit - caseval) > 0x10000) { |
|
1718 |
// Note: 0x10000 is arbitrary implementation restriction. |
|
1719 |
// We can remove it later if it's important to. |
|
1720 |
abort("bad range in union case label"); |
|
1721 |
return ""; |
|
1722 |
} |
|
1723 |
for (;;) { |
|
1724 |
++caseval; |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
1725 |
band_stack.add((void*)(size_t)caseval); |
2 | 1726 |
if (caseval == caselimit) break; |
1727 |
} |
|
1728 |
} |
|
1729 |
if (*lp != ',') break; |
|
1730 |
lp++; |
|
1731 |
} |
|
1732 |
if (*lp++ != ')') { |
|
1733 |
abort("bad case label"); |
|
1734 |
return ""; |
|
1735 |
} |
|
1736 |
// save away the case labels |
|
1737 |
int ntags = band_stack.length() - case_base; |
|
5191
79b41f733e33
6902299: Java JAR "unpack200" must verify input parameters
ksrini
parents:
3463
diff
changeset
|
1738 |
int* tags = U_NEW(int, add_size(ntags, 1)); |
2 | 1739 |
CHECK_(lp); |
1740 |
k_case.le_casetags = tags; |
|
1741 |
*tags++ = ntags; |
|
1742 |
for (int i = 0; i < ntags; i++) { |
|
1743 |
*tags++ = ptrlowbits(band_stack.get(case_base+i)); |
|
1744 |
} |
|
1745 |
band_stack.popTo(case_base); |
|
1746 |
CHECK_(lp); |
|
1747 |
} |
|
1748 |
// Got le_casetags. Now grab the body. |
|
1749 |
assert(*lp == '['); |
|
1750 |
++lp; |
|
1751 |
lp = parseLayout(lp, k_case.le_body, curCble); |
|
1752 |
CHECK_(lp); |
|
1753 |
if (k_case.le_casetags == null) break; // done |
|
1754 |
} |
|
1755 |
b->le_body = popBody(union_base); |
|
1756 |
} |
|
1757 |
break; |
|
1758 |
case '(': // call: '(' -?NN* ')' |
|
1759 |
{ |
|
1760 |
band& call = *U_NEW(band, 1); |
|
1761 |
CHECK_(lp); |
|
1762 |
band_stack.add(&call); |
|
1763 |
call.le_kind = EK_CALL; |
|
1764 |
call.bn = bands_made++; |
|
1765 |
call.le_body = U_NEW(band*, 2); // fill in later |
|
1766 |
int call_num = 0; |
|
1767 |
lp = parseNumeral(lp, call_num); |
|
1768 |
call.le_back = (call_num <= 0); |
|
1769 |
call_num += curCble; // numeral is self-relative offset |
|
1770 |
call.le_len = call_num; //use le_len as scratch |
|
1771 |
calls_to_link.add(&call); |
|
1772 |
CHECK_(lp); |
|
1773 |
if (*lp++ != ')') { |
|
1774 |
abort("bad call label"); |
|
1775 |
return ""; |
|
1776 |
} |
|
1777 |
} |
|
1778 |
break; |
|
1779 |
case 'K': // reference_type: constant_ref |
|
1780 |
case 'R': // reference_type: schema_ref |
|
1781 |
{ |
|
1782 |
int ixTag = CONSTANT_None; |
|
1783 |
if (lp[-1] == 'K') { |
|
1784 |
switch (*lp++) { |
|
1785 |
case 'I': ixTag = CONSTANT_Integer; break; |
|
1786 |
case 'J': ixTag = CONSTANT_Long; break; |
|
1787 |
case 'F': ixTag = CONSTANT_Float; break; |
|
1788 |
case 'D': ixTag = CONSTANT_Double; break; |
|
1789 |
case 'S': ixTag = CONSTANT_String; break; |
|
1790 |
case 'Q': ixTag = CONSTANT_Literal; break; |
|
1791 |
} |
|
1792 |
} else { |
|
1793 |
switch (*lp++) { |
|
1794 |
case 'C': ixTag = CONSTANT_Class; break; |
|
1795 |
case 'S': ixTag = CONSTANT_Signature; break; |
|
1796 |
case 'D': ixTag = CONSTANT_NameandType; break; |
|
1797 |
case 'F': ixTag = CONSTANT_Fieldref; break; |
|
1798 |
case 'M': ixTag = CONSTANT_Methodref; break; |
|
1799 |
case 'I': ixTag = CONSTANT_InterfaceMethodref; break; |
|
1800 |
case 'U': ixTag = CONSTANT_Utf8; break; //utf8_ref |
|
1801 |
case 'Q': ixTag = CONSTANT_All; break; //untyped_ref |
|
1802 |
} |
|
1803 |
} |
|
1804 |
if (ixTag == CONSTANT_None) { |
|
1805 |
abort("bad reference layout"); |
|
1806 |
break; |
|
1807 |
} |
|
1808 |
bool nullOK = false; |
|
1809 |
if (*lp == 'N') { |
|
1810 |
nullOK = true; |
|
1811 |
lp++; |
|
1812 |
} |
|
1813 |
lp = parseIntLayout(lp, b, EK_REF); |
|
1814 |
b->defc = coding::findBySpec(UNSIGNED5_spec); |
|
1815 |
b->initRef(ixTag, nullOK); |
|
1816 |
} |
|
1817 |
break; |
|
1818 |
case '[': |
|
1819 |
{ |
|
1820 |
// [callable1][callable2]... |
|
1821 |
if (!top_level) { |
|
1822 |
abort("bad nested callable"); |
|
1823 |
break; |
|
1824 |
} |
|
1825 |
curCble += 1; |
|
1826 |
NOT_PRODUCT(int call_num = band_stack.length() - bs_base); |
|
1827 |
band& cble = *U_NEW(band, 1); |
|
1828 |
CHECK_(lp); |
|
1829 |
band_stack.add(&cble); |
|
1830 |
cble.le_kind = EK_CBLE; |
|
1831 |
NOT_PRODUCT(cble.le_len = call_num); |
|
1832 |
cble.bn = bands_made++; |
|
1833 |
lp = parseLayout(lp, cble.le_body, curCble); |
|
1834 |
} |
|
1835 |
break; |
|
1836 |
case ']': |
|
1837 |
// Hit a closing brace. This ends whatever body we were in. |
|
1838 |
done = true; |
|
1839 |
break; |
|
1840 |
case '\0': |
|
1841 |
// Hit a null. Also ends the (top-level) body. |
|
1842 |
--lp; // back up, so caller can see the null also |
|
1843 |
done = true; |
|
1844 |
break; |
|
1845 |
default: |
|
1846 |
abort("bad layout"); |
|
1847 |
break; |
|
1848 |
} |
|
1849 |
CHECK_(lp); |
|
1850 |
} |
|
1851 |
||
1852 |
// Return the accumulated bands: |
|
1853 |
res = popBody(bs_base); |
|
1854 |
return lp; |
|
1855 |
} |
|
1856 |
||
1857 |
void unpacker::read_attr_defs() { |
|
1858 |
int i; |
|
1859 |
||
1860 |
// Tell each AD which attrc it is and where its fixed flags are: |
|
1861 |
attr_defs[ATTR_CONTEXT_CLASS].attrc = ATTR_CONTEXT_CLASS; |
|
1862 |
attr_defs[ATTR_CONTEXT_CLASS].xxx_flags_hi_bn = e_class_flags_hi; |
|
1863 |
attr_defs[ATTR_CONTEXT_FIELD].attrc = ATTR_CONTEXT_FIELD; |
|
1864 |
attr_defs[ATTR_CONTEXT_FIELD].xxx_flags_hi_bn = e_field_flags_hi; |
|
1865 |
attr_defs[ATTR_CONTEXT_METHOD].attrc = ATTR_CONTEXT_METHOD; |
|
1866 |
attr_defs[ATTR_CONTEXT_METHOD].xxx_flags_hi_bn = e_method_flags_hi; |
|
1867 |
attr_defs[ATTR_CONTEXT_CODE].attrc = ATTR_CONTEXT_CODE; |
|
1868 |
attr_defs[ATTR_CONTEXT_CODE].xxx_flags_hi_bn = e_code_flags_hi; |
|
1869 |
||
1870 |
// Decide whether bands for the optional high flag words are present. |
|
1871 |
attr_defs[ATTR_CONTEXT_CLASS] |
|
1872 |
.setHaveLongFlags((archive_options & AO_HAVE_CLASS_FLAGS_HI) != 0); |
|
1873 |
attr_defs[ATTR_CONTEXT_FIELD] |
|
1874 |
.setHaveLongFlags((archive_options & AO_HAVE_FIELD_FLAGS_HI) != 0); |
|
1875 |
attr_defs[ATTR_CONTEXT_METHOD] |
|
1876 |
.setHaveLongFlags((archive_options & AO_HAVE_METHOD_FLAGS_HI) != 0); |
|
1877 |
attr_defs[ATTR_CONTEXT_CODE] |
|
1878 |
.setHaveLongFlags((archive_options & AO_HAVE_CODE_FLAGS_HI) != 0); |
|
1879 |
||
1880 |
// Set up built-in attrs. |
|
1881 |
// (The simple ones are hard-coded. The metadata layouts are not.) |
|
1882 |
const char* md_layout = ( |
|
1883 |
// parameter annotations: |
|
1884 |
#define MDL0 \ |
|
1885 |
"[NB[(1)]]" |
|
1886 |
MDL0 |
|
1887 |
// annotations: |
|
1888 |
#define MDL1 \ |
|
1889 |
"[NH[(1)]]" \ |
|
1890 |
"[RSHNH[RUH(1)]]" |
|
1891 |
MDL1 |
|
1892 |
// member_value: |
|
1893 |
"[TB" |
|
1894 |
"(66,67,73,83,90)[KIH]" |
|
1895 |
"(68)[KDH]" |
|
1896 |
"(70)[KFH]" |
|
1897 |
"(74)[KJH]" |
|
1898 |
"(99)[RSH]" |
|
1899 |
"(101)[RSHRUH]" |
|
1900 |
"(115)[RUH]" |
|
1901 |
"(91)[NH[(0)]]" |
|
1902 |
"(64)[" |
|
1903 |
// nested annotation: |
|
1904 |
"RSH" |
|
1905 |
"NH[RUH(0)]" |
|
1906 |
"]" |
|
1907 |
"()[]" |
|
1908 |
"]" |
|
1909 |
); |
|
1910 |
||
1911 |
const char* md_layout_P = md_layout; |
|
1912 |
const char* md_layout_A = md_layout+strlen(MDL0); |
|
1913 |
const char* md_layout_V = md_layout+strlen(MDL0 MDL1); |
|
1914 |
assert(0 == strncmp(&md_layout_A[-3], ")]][", 4)); |
|
1915 |
assert(0 == strncmp(&md_layout_V[-3], ")]][", 4)); |
|
1916 |
||
1917 |
for (i = 0; i < ATTR_CONTEXT_LIMIT; i++) { |
|
1918 |
attr_definitions& ad = attr_defs[i]; |
|
1919 |
ad.defineLayout(X_ATTR_RuntimeVisibleAnnotations, |
|
1920 |
"RuntimeVisibleAnnotations", md_layout_A); |
|
1921 |
ad.defineLayout(X_ATTR_RuntimeInvisibleAnnotations, |
|
1922 |
"RuntimeInvisibleAnnotations", md_layout_A); |
|
1923 |
if (i != ATTR_CONTEXT_METHOD) continue; |
|
1924 |
ad.defineLayout(METHOD_ATTR_RuntimeVisibleParameterAnnotations, |
|
1925 |
"RuntimeVisibleParameterAnnotations", md_layout_P); |
|
1926 |
ad.defineLayout(METHOD_ATTR_RuntimeInvisibleParameterAnnotations, |
|
1927 |
"RuntimeInvisibleParameterAnnotations", md_layout_P); |
|
1928 |
ad.defineLayout(METHOD_ATTR_AnnotationDefault, |
|
1929 |
"AnnotationDefault", md_layout_V); |
|
1930 |
} |
|
1931 |
||
1932 |
attr_definition_headers.readData(attr_definition_count); |
|
1933 |
attr_definition_name.readData(attr_definition_count); |
|
1934 |
attr_definition_layout.readData(attr_definition_count); |
|
1935 |
||
1936 |
CHECK; |
|
1937 |
||
1938 |
// Initialize correct predef bits, to distinguish predefs from new defs. |
|
1939 |
#define ORBIT(n,s) |((julong)1<<n) |
|
1940 |
attr_defs[ATTR_CONTEXT_CLASS].predef |
|
1941 |
= (0 X_ATTR_DO(ORBIT) CLASS_ATTR_DO(ORBIT)); |
|
1942 |
attr_defs[ATTR_CONTEXT_FIELD].predef |
|
1943 |
= (0 X_ATTR_DO(ORBIT) FIELD_ATTR_DO(ORBIT)); |
|
1944 |
attr_defs[ATTR_CONTEXT_METHOD].predef |
|
1945 |
= (0 X_ATTR_DO(ORBIT) METHOD_ATTR_DO(ORBIT)); |
|
1946 |
attr_defs[ATTR_CONTEXT_CODE].predef |
|
1947 |
= (0 O_ATTR_DO(ORBIT) CODE_ATTR_DO(ORBIT)); |
|
1948 |
#undef ORBIT |
|
1949 |
// Clear out the redef bits, folding them back into predef. |
|
1950 |
for (i = 0; i < ATTR_CONTEXT_LIMIT; i++) { |
|
1951 |
attr_defs[i].predef |= attr_defs[i].redef; |
|
1952 |
attr_defs[i].redef = 0; |
|
1953 |
} |
|
1954 |
||
1955 |
// Now read the transmitted locally defined attrs. |
|
1956 |
// This will set redef bits again. |
|
1957 |
for (i = 0; i < attr_definition_count; i++) { |
|
1958 |
int header = attr_definition_headers.getByte(); |
|
1959 |
int attrc = ADH_BYTE_CONTEXT(header); |
|
1960 |
int idx = ADH_BYTE_INDEX(header); |
|
1961 |
entry* name = attr_definition_name.getRef(); |
|
1962 |
entry* layout = attr_definition_layout.getRef(); |
|
1963 |
CHECK; |
|
1964 |
attr_defs[attrc].defineLayout(idx, name, layout->value.b.strval()); |
|
1965 |
} |
|
1966 |
} |
|
1967 |
||
1968 |
#define NO_ENTRY_YET ((entry*)-1) |
|
1969 |
||
1970 |
static bool isDigitString(bytes& x, int beg, int end) { |
|
1971 |
if (beg == end) return false; // null string |
|
1972 |
byte* xptr = x.ptr; |
|
1973 |
for (int i = beg; i < end; i++) { |
|
1974 |
char ch = xptr[i]; |
|
1975 |
if (!(ch >= '0' && ch <= '9')) return false; |
|
1976 |
} |
|
1977 |
return true; |
|
1978 |
} |
|
1979 |
||
1980 |
enum { // constants for parsing class names |
|
1981 |
SLASH_MIN = '.', |
|
1982 |
SLASH_MAX = '/', |
|
1983 |
DOLLAR_MIN = 0, |
|
1984 |
DOLLAR_MAX = '-' |
|
1985 |
}; |
|
1986 |
||
1987 |
static int lastIndexOf(int chmin, int chmax, bytes& x, int pos) { |
|
1988 |
byte* ptr = x.ptr; |
|
1989 |
for (byte* cp = ptr + pos; --cp >= ptr; ) { |
|
1990 |
assert(x.inBounds(cp)); |
|
1991 |
if (*cp >= chmin && *cp <= chmax) |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
1992 |
return (int)(cp - ptr); |
2 | 1993 |
} |
1994 |
return -1; |
|
1995 |
} |
|
1996 |
||
1997 |
maybe_inline |
|
1998 |
inner_class* cpool::getIC(entry* inner) { |
|
1999 |
if (inner == null) return null; |
|
2000 |
assert(inner->tag == CONSTANT_Class); |
|
2001 |
if (inner->inord == NO_INORD) return null; |
|
2002 |
inner_class* ic = ic_index[inner->inord]; |
|
2003 |
assert(ic == null || ic->inner == inner); |
|
2004 |
return ic; |
|
2005 |
} |
|
2006 |
||
2007 |
maybe_inline |
|
2008 |
inner_class* cpool::getFirstChildIC(entry* outer) { |
|
2009 |
if (outer == null) return null; |
|
2010 |
assert(outer->tag == CONSTANT_Class); |
|
2011 |
if (outer->inord == NO_INORD) return null; |
|
2012 |
inner_class* ic = ic_child_index[outer->inord]; |
|
2013 |
assert(ic == null || ic->outer == outer); |
|
2014 |
return ic; |
|
2015 |
} |
|
2016 |
||
2017 |
maybe_inline |
|
2018 |
inner_class* cpool::getNextChildIC(inner_class* child) { |
|
2019 |
inner_class* ic = child->next_sibling; |
|
2020 |
assert(ic == null || ic->outer == child->outer); |
|
2021 |
return ic; |
|
2022 |
} |
|
2023 |
||
2024 |
void unpacker::read_ics() { |
|
2025 |
int i; |
|
2026 |
int index_size = cp.tag_count[CONSTANT_Class]; |
|
2027 |
inner_class** ic_index = U_NEW(inner_class*, index_size); |
|
2028 |
inner_class** ic_child_index = U_NEW(inner_class*, index_size); |
|
2029 |
cp.ic_index = ic_index; |
|
2030 |
cp.ic_child_index = ic_child_index; |
|
2031 |
ics = U_NEW(inner_class, ic_count); |
|
2032 |
ic_this_class.readData(ic_count); |
|
2033 |
ic_flags.readData(ic_count); |
|
2034 |
CHECK; |
|
2035 |
// Scan flags to get count of long-form bands. |
|
2036 |
int long_forms = 0; |
|
2037 |
for (i = 0; i < ic_count; i++) { |
|
2038 |
int flags = ic_flags.getInt(); // may be long form! |
|
2039 |
if ((flags & ACC_IC_LONG_FORM) != 0) { |
|
2040 |
long_forms += 1; |
|
2041 |
ics[i].name = NO_ENTRY_YET; |
|
2042 |
} |
|
2043 |
flags &= ~ACC_IC_LONG_FORM; |
|
2044 |
entry* inner = ic_this_class.getRef(); |
|
2045 |
CHECK; |
|
2046 |
uint inord = inner->inord; |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2047 |
assert(inord < (uint)cp.tag_count[CONSTANT_Class]); |
2 | 2048 |
if (ic_index[inord] != null) { |
2049 |
abort("identical inner class"); |
|
2050 |
break; |
|
2051 |
} |
|
2052 |
ic_index[inord] = &ics[i]; |
|
2053 |
ics[i].inner = inner; |
|
2054 |
ics[i].flags = flags; |
|
2055 |
assert(cp.getIC(inner) == &ics[i]); |
|
2056 |
} |
|
2057 |
CHECK; |
|
2058 |
//ic_this_class.done(); |
|
2059 |
//ic_flags.done(); |
|
2060 |
ic_outer_class.readData(long_forms); |
|
2061 |
ic_name.readData(long_forms); |
|
2062 |
for (i = 0; i < ic_count; i++) { |
|
2063 |
if (ics[i].name == NO_ENTRY_YET) { |
|
2064 |
// Long form. |
|
2065 |
ics[i].outer = ic_outer_class.getRefN(); |
|
2066 |
ics[i].name = ic_name.getRefN(); |
|
2067 |
} else { |
|
2068 |
// Fill in outer and name based on inner. |
|
2069 |
bytes& n = ics[i].inner->value.b; |
|
2070 |
bytes pkgOuter; |
|
2071 |
bytes number; |
|
2072 |
bytes name; |
|
2073 |
// Parse n into pkgOuter and name (and number). |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2074 |
PRINTCR((5, "parse short IC name %s", n.ptr)); |
2 | 2075 |
int dollar1, dollar2; // pointers to $ in the pattern |
2076 |
// parse n = (<pkg>/)*<outer>($<number>)?($<name>)? |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2077 |
int nlen = (int)n.len; |
2 | 2078 |
int pkglen = lastIndexOf(SLASH_MIN, SLASH_MAX, n, nlen) + 1; |
2079 |
dollar2 = lastIndexOf(DOLLAR_MIN, DOLLAR_MAX, n, nlen); |
|
2080 |
if (dollar2 < 0) { |
|
2081 |
abort(); |
|
2082 |
return; |
|
2083 |
} |
|
2084 |
assert(dollar2 >= pkglen); |
|
2085 |
if (isDigitString(n, dollar2+1, nlen)) { |
|
2086 |
// n = (<pkg>/)*<outer>$<number> |
|
2087 |
number = n.slice(dollar2+1, nlen); |
|
2088 |
name.set(null,0); |
|
2089 |
dollar1 = dollar2; |
|
2090 |
} else if (pkglen < (dollar1 |
|
2091 |
= lastIndexOf(DOLLAR_MIN, DOLLAR_MAX, n, dollar2-1)) |
|
2092 |
&& isDigitString(n, dollar1+1, dollar2)) { |
|
2093 |
// n = (<pkg>/)*<outer>$<number>$<name> |
|
2094 |
number = n.slice(dollar1+1, dollar2); |
|
2095 |
name = n.slice(dollar2+1, nlen); |
|
2096 |
} else { |
|
2097 |
// n = (<pkg>/)*<outer>$<name> |
|
2098 |
dollar1 = dollar2; |
|
2099 |
number.set(null,0); |
|
2100 |
name = n.slice(dollar2+1, nlen); |
|
2101 |
} |
|
2102 |
if (number.ptr == null) |
|
2103 |
pkgOuter = n.slice(0, dollar1); |
|
2104 |
else |
|
2105 |
pkgOuter.set(null,0); |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2106 |
PRINTCR((5,"=> %s$ 0%s $%s", |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2107 |
pkgOuter.string(), number.string(), name.string())); |
2 | 2108 |
|
2109 |
if (pkgOuter.ptr != null) |
|
2110 |
ics[i].outer = cp.ensureClass(pkgOuter); |
|
2111 |
||
2112 |
if (name.ptr != null) |
|
2113 |
ics[i].name = cp.ensureUtf8(name); |
|
2114 |
} |
|
2115 |
||
2116 |
// update child/sibling list |
|
2117 |
if (ics[i].outer != null) { |
|
2118 |
uint outord = ics[i].outer->inord; |
|
2119 |
if (outord != NO_INORD) { |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2120 |
assert(outord < (uint)cp.tag_count[CONSTANT_Class]); |
2 | 2121 |
ics[i].next_sibling = ic_child_index[outord]; |
2122 |
ic_child_index[outord] = &ics[i]; |
|
2123 |
} |
|
2124 |
} |
|
2125 |
} |
|
2126 |
//ic_outer_class.done(); |
|
2127 |
//ic_name.done(); |
|
2128 |
} |
|
2129 |
||
2130 |
void unpacker::read_classes() { |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2131 |
PRINTCR((1," ...scanning %d classes...", class_count)); |
2 | 2132 |
class_this.readData(class_count); |
2133 |
class_super.readData(class_count); |
|
2134 |
class_interface_count.readData(class_count); |
|
2135 |
class_interface.readData(class_interface_count.getIntTotal()); |
|
2136 |
||
2137 |
CHECK; |
|
2138 |
||
2139 |
#if 0 |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2140 |
int i; |
2 | 2141 |
// Make a little mark on super-classes. |
2142 |
for (i = 0; i < class_count; i++) { |
|
2143 |
entry* e = class_super.getRefN(); |
|
2144 |
if (e != null) e->bits |= entry::EB_SUPER; |
|
2145 |
} |
|
2146 |
class_super.rewind(); |
|
2147 |
#endif |
|
2148 |
||
2149 |
// Members. |
|
2150 |
class_field_count.readData(class_count); |
|
2151 |
class_method_count.readData(class_count); |
|
2152 |
||
2153 |
CHECK; |
|
2154 |
||
2155 |
int field_count = class_field_count.getIntTotal(); |
|
2156 |
int method_count = class_method_count.getIntTotal(); |
|
2157 |
||
2158 |
field_descr.readData(field_count); |
|
2159 |
read_attrs(ATTR_CONTEXT_FIELD, field_count); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2160 |
CHECK; |
2 | 2161 |
|
2162 |
method_descr.readData(method_count); |
|
2163 |
read_attrs(ATTR_CONTEXT_METHOD, method_count); |
|
2164 |
||
2165 |
CHECK; |
|
2166 |
||
2167 |
read_attrs(ATTR_CONTEXT_CLASS, class_count); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2168 |
CHECK; |
2 | 2169 |
|
2170 |
read_code_headers(); |
|
2171 |
||
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2172 |
PRINTCR((1,"scanned %d classes, %d fields, %d methods, %d code headers", |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2173 |
class_count, field_count, method_count, code_count)); |
2 | 2174 |
} |
2175 |
||
2176 |
maybe_inline |
|
2177 |
int unpacker::attr_definitions::predefCount(uint idx) { |
|
2178 |
return isPredefined(idx) ? flag_count[idx] : 0; |
|
2179 |
} |
|
2180 |
||
2181 |
void unpacker::read_attrs(int attrc, int obj_count) { |
|
2182 |
attr_definitions& ad = attr_defs[attrc]; |
|
2183 |
assert(ad.attrc == attrc); |
|
2184 |
||
2185 |
int i, idx, count; |
|
2186 |
||
2187 |
CHECK; |
|
2188 |
||
2189 |
bool haveLongFlags = ad.haveLongFlags(); |
|
2190 |
||
2191 |
band& xxx_flags_hi = ad.xxx_flags_hi(); |
|
2192 |
assert(endsWith(xxx_flags_hi.name, "_flags_hi")); |
|
2193 |
if (haveLongFlags) |
|
2194 |
xxx_flags_hi.readData(obj_count); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2195 |
CHECK; |
2 | 2196 |
|
2197 |
band& xxx_flags_lo = ad.xxx_flags_lo(); |
|
2198 |
assert(endsWith(xxx_flags_lo.name, "_flags_lo")); |
|
2199 |
xxx_flags_lo.readData(obj_count); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2200 |
CHECK; |
2 | 2201 |
|
2202 |
// pre-scan flags, counting occurrences of each index bit |
|
2203 |
julong indexMask = ad.flagIndexMask(); // which flag bits are index bits? |
|
2204 |
for (i = 0; i < obj_count; i++) { |
|
2205 |
julong indexBits = xxx_flags_hi.getLong(xxx_flags_lo, haveLongFlags); |
|
2206 |
if ((indexBits & ~indexMask) > (ushort)-1) { |
|
2207 |
abort("undefined attribute flag bit"); |
|
2208 |
return; |
|
2209 |
} |
|
2210 |
indexBits &= indexMask; // ignore classfile flag bits |
|
2211 |
for (idx = 0; indexBits != 0; idx++, indexBits >>= 1) { |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2212 |
ad.flag_count[idx] += (int)(indexBits & 1); |
2 | 2213 |
} |
2214 |
} |
|
2215 |
// we'll scan these again later for output: |
|
2216 |
xxx_flags_lo.rewind(); |
|
2217 |
xxx_flags_hi.rewind(); |
|
2218 |
||
2219 |
band& xxx_attr_count = ad.xxx_attr_count(); |
|
2220 |
assert(endsWith(xxx_attr_count.name, "_attr_count")); |
|
2221 |
// There is one count element for each 1<<16 bit set in flags: |
|
2222 |
xxx_attr_count.readData(ad.predefCount(X_ATTR_OVERFLOW)); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2223 |
CHECK; |
2 | 2224 |
|
2225 |
band& xxx_attr_indexes = ad.xxx_attr_indexes(); |
|
2226 |
assert(endsWith(xxx_attr_indexes.name, "_attr_indexes")); |
|
2227 |
int overflowIndexCount = xxx_attr_count.getIntTotal(); |
|
2228 |
xxx_attr_indexes.readData(overflowIndexCount); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2229 |
CHECK; |
2 | 2230 |
// pre-scan attr indexes, counting occurrences of each value |
2231 |
for (i = 0; i < overflowIndexCount; i++) { |
|
2232 |
idx = xxx_attr_indexes.getInt(); |
|
2233 |
if (!ad.isIndex(idx)) { |
|
2234 |
abort("attribute index out of bounds"); |
|
2235 |
return; |
|
2236 |
} |
|
2237 |
ad.getCount(idx) += 1; |
|
2238 |
} |
|
2239 |
xxx_attr_indexes.rewind(); // we'll scan it again later for output |
|
2240 |
||
2241 |
// We will need a backward call count for each used backward callable. |
|
2242 |
int backwardCounts = 0; |
|
2243 |
for (idx = 0; idx < ad.layouts.length(); idx++) { |
|
2244 |
layout_definition* lo = ad.getLayout(idx); |
|
2245 |
if (lo != null && ad.getCount(idx) != 0) { |
|
2246 |
// Build the bands lazily, only when they are used. |
|
2247 |
band** bands = ad.buildBands(lo); |
|
2248 |
CHECK; |
|
2249 |
if (lo->hasCallables()) { |
|
2250 |
for (i = 0; bands[i] != null; i++) { |
|
2251 |
if (bands[i]->le_back) { |
|
2252 |
assert(bands[i]->le_kind == EK_CBLE); |
|
2253 |
backwardCounts += 1; |
|
2254 |
} |
|
2255 |
} |
|
2256 |
} |
|
2257 |
} |
|
2258 |
} |
|
2259 |
ad.xxx_attr_calls().readData(backwardCounts); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2260 |
CHECK; |
2 | 2261 |
|
2262 |
// Read built-in bands. |
|
2263 |
// Mostly, these are hand-coded equivalents to readBandData(). |
|
2264 |
switch (attrc) { |
|
2265 |
case ATTR_CONTEXT_CLASS: |
|
2266 |
||
2267 |
count = ad.predefCount(CLASS_ATTR_SourceFile); |
|
2268 |
class_SourceFile_RUN.readData(count); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2269 |
CHECK; |
2 | 2270 |
|
2271 |
count = ad.predefCount(CLASS_ATTR_EnclosingMethod); |
|
2272 |
class_EnclosingMethod_RC.readData(count); |
|
2273 |
class_EnclosingMethod_RDN.readData(count); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2274 |
CHECK; |
2 | 2275 |
|
2276 |
count = ad.predefCount(X_ATTR_Signature); |
|
2277 |
class_Signature_RS.readData(count); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2278 |
CHECK; |
2 | 2279 |
|
2280 |
ad.readBandData(X_ATTR_RuntimeVisibleAnnotations); |
|
2281 |
ad.readBandData(X_ATTR_RuntimeInvisibleAnnotations); |
|
2282 |
||
2283 |
count = ad.predefCount(CLASS_ATTR_InnerClasses); |
|
2284 |
class_InnerClasses_N.readData(count); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2285 |
CHECK; |
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2286 |
|
2 | 2287 |
count = class_InnerClasses_N.getIntTotal(); |
2288 |
class_InnerClasses_RC.readData(count); |
|
2289 |
class_InnerClasses_F.readData(count); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2290 |
CHECK; |
2 | 2291 |
// Drop remaining columns wherever flags are zero: |
2292 |
count -= class_InnerClasses_F.getIntCount(0); |
|
2293 |
class_InnerClasses_outer_RCN.readData(count); |
|
2294 |
class_InnerClasses_name_RUN.readData(count); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2295 |
CHECK; |
2 | 2296 |
|
2297 |
count = ad.predefCount(CLASS_ATTR_ClassFile_version); |
|
2298 |
class_ClassFile_version_minor_H.readData(count); |
|
2299 |
class_ClassFile_version_major_H.readData(count); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2300 |
CHECK; |
2 | 2301 |
break; |
2302 |
||
2303 |
case ATTR_CONTEXT_FIELD: |
|
2304 |
||
2305 |
count = ad.predefCount(FIELD_ATTR_ConstantValue); |
|
2306 |
field_ConstantValue_KQ.readData(count); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2307 |
CHECK; |
2 | 2308 |
|
2309 |
count = ad.predefCount(X_ATTR_Signature); |
|
2310 |
field_Signature_RS.readData(count); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2311 |
CHECK; |
2 | 2312 |
|
2313 |
ad.readBandData(X_ATTR_RuntimeVisibleAnnotations); |
|
2314 |
ad.readBandData(X_ATTR_RuntimeInvisibleAnnotations); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2315 |
CHECK; |
2 | 2316 |
break; |
2317 |
||
2318 |
case ATTR_CONTEXT_METHOD: |
|
2319 |
||
2320 |
code_count = ad.predefCount(METHOD_ATTR_Code); |
|
2321 |
// Code attrs are handled very specially below... |
|
2322 |
||
2323 |
count = ad.predefCount(METHOD_ATTR_Exceptions); |
|
2324 |
method_Exceptions_N.readData(count); |
|
2325 |
count = method_Exceptions_N.getIntTotal(); |
|
2326 |
method_Exceptions_RC.readData(count); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2327 |
CHECK; |
2 | 2328 |
|
2329 |
count = ad.predefCount(X_ATTR_Signature); |
|
2330 |
method_Signature_RS.readData(count); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2331 |
CHECK; |
2 | 2332 |
|
2333 |
ad.readBandData(X_ATTR_RuntimeVisibleAnnotations); |
|
2334 |
ad.readBandData(X_ATTR_RuntimeInvisibleAnnotations); |
|
2335 |
ad.readBandData(METHOD_ATTR_RuntimeVisibleParameterAnnotations); |
|
2336 |
ad.readBandData(METHOD_ATTR_RuntimeInvisibleParameterAnnotations); |
|
2337 |
ad.readBandData(METHOD_ATTR_AnnotationDefault); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2338 |
CHECK; |
2 | 2339 |
break; |
2340 |
||
2341 |
case ATTR_CONTEXT_CODE: |
|
2342 |
// (keep this code aligned with its brother in unpacker::write_attrs) |
|
2343 |
count = ad.predefCount(CODE_ATTR_StackMapTable); |
|
2344 |
// disable this feature in old archives! |
|
2345 |
if (count != 0 && majver < JAVA6_PACKAGE_MAJOR_VERSION) { |
|
2346 |
abort("undefined StackMapTable attribute (old archive format)"); |
|
2347 |
return; |
|
2348 |
} |
|
2349 |
code_StackMapTable_N.readData(count); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2350 |
CHECK; |
2 | 2351 |
count = code_StackMapTable_N.getIntTotal(); |
2352 |
code_StackMapTable_frame_T.readData(count); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2353 |
CHECK; |
2 | 2354 |
// the rest of it depends in a complicated way on frame tags |
2355 |
{ |
|
2356 |
int fat_frame_count = 0; |
|
2357 |
int offset_count = 0; |
|
2358 |
int type_count = 0; |
|
2359 |
for (int k = 0; k < count; k++) { |
|
2360 |
int tag = code_StackMapTable_frame_T.getByte(); |
|
2361 |
if (tag <= 127) { |
|
2362 |
// (64-127) [(2)] |
|
2363 |
if (tag >= 64) type_count++; |
|
2364 |
} else if (tag <= 251) { |
|
2365 |
// (247) [(1)(2)] |
|
2366 |
// (248-251) [(1)] |
|
2367 |
if (tag >= 247) offset_count++; |
|
2368 |
if (tag == 247) type_count++; |
|
2369 |
} else if (tag <= 254) { |
|
2370 |
// (252) [(1)(2)] |
|
2371 |
// (253) [(1)(2)(2)] |
|
2372 |
// (254) [(1)(2)(2)(2)] |
|
2373 |
offset_count++; |
|
2374 |
type_count += (tag - 251); |
|
2375 |
} else { |
|
2376 |
// (255) [(1)NH[(2)]NH[(2)]] |
|
2377 |
fat_frame_count++; |
|
2378 |
} |
|
2379 |
} |
|
2380 |
||
2381 |
// done pre-scanning frame tags: |
|
2382 |
code_StackMapTable_frame_T.rewind(); |
|
2383 |
||
2384 |
// deal completely with fat frames: |
|
2385 |
offset_count += fat_frame_count; |
|
2386 |
code_StackMapTable_local_N.readData(fat_frame_count); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2387 |
CHECK; |
2 | 2388 |
type_count += code_StackMapTable_local_N.getIntTotal(); |
2389 |
code_StackMapTable_stack_N.readData(fat_frame_count); |
|
2390 |
type_count += code_StackMapTable_stack_N.getIntTotal(); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2391 |
CHECK; |
2 | 2392 |
// read the rest: |
2393 |
code_StackMapTable_offset.readData(offset_count); |
|
2394 |
code_StackMapTable_T.readData(type_count); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2395 |
CHECK; |
2 | 2396 |
// (7) [RCH] |
2397 |
count = code_StackMapTable_T.getIntCount(7); |
|
2398 |
code_StackMapTable_RC.readData(count); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2399 |
CHECK; |
2 | 2400 |
// (8) [PH] |
2401 |
count = code_StackMapTable_T.getIntCount(8); |
|
2402 |
code_StackMapTable_P.readData(count); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2403 |
CHECK; |
2 | 2404 |
} |
2405 |
||
2406 |
count = ad.predefCount(CODE_ATTR_LineNumberTable); |
|
2407 |
code_LineNumberTable_N.readData(count); |
|
2408 |
count = code_LineNumberTable_N.getIntTotal(); |
|
2409 |
code_LineNumberTable_bci_P.readData(count); |
|
2410 |
code_LineNumberTable_line.readData(count); |
|
2411 |
||
2412 |
count = ad.predefCount(CODE_ATTR_LocalVariableTable); |
|
2413 |
code_LocalVariableTable_N.readData(count); |
|
2414 |
count = code_LocalVariableTable_N.getIntTotal(); |
|
2415 |
code_LocalVariableTable_bci_P.readData(count); |
|
2416 |
code_LocalVariableTable_span_O.readData(count); |
|
2417 |
code_LocalVariableTable_name_RU.readData(count); |
|
2418 |
code_LocalVariableTable_type_RS.readData(count); |
|
2419 |
code_LocalVariableTable_slot.readData(count); |
|
2420 |
||
2421 |
count = ad.predefCount(CODE_ATTR_LocalVariableTypeTable); |
|
2422 |
code_LocalVariableTypeTable_N.readData(count); |
|
2423 |
count = code_LocalVariableTypeTable_N.getIntTotal(); |
|
2424 |
code_LocalVariableTypeTable_bci_P.readData(count); |
|
2425 |
code_LocalVariableTypeTable_span_O.readData(count); |
|
2426 |
code_LocalVariableTypeTable_name_RU.readData(count); |
|
2427 |
code_LocalVariableTypeTable_type_RS.readData(count); |
|
2428 |
code_LocalVariableTypeTable_slot.readData(count); |
|
2429 |
break; |
|
2430 |
} |
|
2431 |
||
2432 |
// Read compressor-defined bands. |
|
2433 |
for (idx = 0; idx < ad.layouts.length(); idx++) { |
|
2434 |
if (ad.getLayout(idx) == null) |
|
2435 |
continue; // none at this fixed index <32 |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2436 |
if (idx < (int)ad.flag_limit && ad.isPredefined(idx)) |
2 | 2437 |
continue; // already handled |
2438 |
if (ad.getCount(idx) == 0) |
|
2439 |
continue; // no attributes of this type (then why transmit layouts?) |
|
2440 |
ad.readBandData(idx); |
|
2441 |
} |
|
2442 |
} |
|
2443 |
||
2444 |
void unpacker::attr_definitions::readBandData(int idx) { |
|
2445 |
int j; |
|
2446 |
uint count = getCount(idx); |
|
2447 |
if (count == 0) return; |
|
2448 |
layout_definition* lo = getLayout(idx); |
|
2449 |
if (lo != null) { |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2450 |
PRINTCR((1, "counted %d [redefined = %d predefined = %d] attributes of type %s.%s", |
2 | 2451 |
count, isRedefined(idx), isPredefined(idx), |
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2452 |
ATTR_CONTEXT_NAME[attrc], lo->name)); |
2 | 2453 |
} |
2454 |
bool hasCallables = lo->hasCallables(); |
|
2455 |
band** bands = lo->bands(); |
|
2456 |
if (!hasCallables) { |
|
2457 |
// Read through the rest of the bands in a regular way. |
|
2458 |
readBandData(bands, count); |
|
2459 |
} else { |
|
2460 |
// Deal with the callables. |
|
2461 |
// First set up the forward entry count for each callable. |
|
2462 |
// This is stored on band::length of the callable. |
|
2463 |
bands[0]->expectMoreLength(count); |
|
2464 |
for (j = 0; bands[j] != null; j++) { |
|
2465 |
band& j_cble = *bands[j]; |
|
2466 |
assert(j_cble.le_kind == EK_CBLE); |
|
2467 |
if (j_cble.le_back) { |
|
2468 |
// Add in the predicted effects of backward calls, too. |
|
2469 |
int back_calls = xxx_attr_calls().getInt(); |
|
2470 |
j_cble.expectMoreLength(back_calls); |
|
2471 |
// In a moment, more forward calls may increment j_cble.length. |
|
2472 |
} |
|
2473 |
} |
|
2474 |
// Now consult whichever callables have non-zero entry counts. |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2475 |
readBandData(bands, (uint)-1); |
2 | 2476 |
} |
2477 |
} |
|
2478 |
||
2479 |
// Recursive helper to the previous function: |
|
2480 |
void unpacker::attr_definitions::readBandData(band** body, uint count) { |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2481 |
int j, k; |
2 | 2482 |
for (j = 0; body[j] != null; j++) { |
2483 |
band& b = *body[j]; |
|
2484 |
if (b.defc != null) { |
|
2485 |
// It has data, so read it. |
|
2486 |
b.readData(count); |
|
2487 |
} |
|
2488 |
switch (b.le_kind) { |
|
2489 |
case EK_REPL: |
|
2490 |
{ |
|
2491 |
int reps = b.getIntTotal(); |
|
2492 |
readBandData(b.le_body, reps); |
|
2493 |
} |
|
2494 |
break; |
|
2495 |
case EK_UN: |
|
2496 |
{ |
|
2497 |
int remaining = count; |
|
2498 |
for (k = 0; b.le_body[k] != null; k++) { |
|
2499 |
band& k_case = *b.le_body[k]; |
|
2500 |
int k_count = 0; |
|
2501 |
if (k_case.le_casetags == null) { |
|
2502 |
k_count = remaining; // last (empty) case |
|
2503 |
} else { |
|
2504 |
int* tags = k_case.le_casetags; |
|
2505 |
int ntags = *tags++; // 1st element is length (why not?) |
|
2506 |
while (ntags-- > 0) { |
|
2507 |
int tag = *tags++; |
|
2508 |
k_count += b.getIntCount(tag); |
|
2509 |
} |
|
2510 |
} |
|
2511 |
readBandData(k_case.le_body, k_count); |
|
2512 |
remaining -= k_count; |
|
2513 |
} |
|
2514 |
assert(remaining == 0); |
|
2515 |
} |
|
2516 |
break; |
|
2517 |
case EK_CALL: |
|
2518 |
// Push the count forward, if it is not a backward call. |
|
2519 |
if (!b.le_back) { |
|
2520 |
band& cble = *b.le_body[0]; |
|
2521 |
assert(cble.le_kind == EK_CBLE); |
|
2522 |
cble.expectMoreLength(count); |
|
2523 |
} |
|
2524 |
break; |
|
2525 |
case EK_CBLE: |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2526 |
assert((int)count == -1); // incoming count is meaningless |
2 | 2527 |
k = b.length; |
2528 |
assert(k >= 0); |
|
2529 |
// This is intended and required for non production mode. |
|
2530 |
assert((b.length = -1)); // make it unable to accept more calls now. |
|
2531 |
readBandData(b.le_body, k); |
|
2532 |
break; |
|
2533 |
} |
|
2534 |
} |
|
2535 |
} |
|
2536 |
||
2537 |
static inline |
|
2538 |
band** findMatchingCase(int matchTag, band** cases) { |
|
2539 |
for (int k = 0; cases[k] != null; k++) { |
|
2540 |
band& k_case = *cases[k]; |
|
2541 |
if (k_case.le_casetags != null) { |
|
2542 |
// If it has tags, it must match a tag. |
|
2543 |
int* tags = k_case.le_casetags; |
|
2544 |
int ntags = *tags++; // 1st element is length |
|
2545 |
for (; ntags > 0; ntags--) { |
|
2546 |
int tag = *tags++; |
|
2547 |
if (tag == matchTag) |
|
2548 |
break; |
|
2549 |
} |
|
2550 |
if (ntags == 0) |
|
2551 |
continue; // does not match |
|
2552 |
} |
|
2553 |
return k_case.le_body; |
|
2554 |
} |
|
2555 |
return null; |
|
2556 |
} |
|
2557 |
||
2558 |
// write attribute band data: |
|
2559 |
void unpacker::putlayout(band** body) { |
|
2560 |
int i; |
|
2561 |
int prevBII = -1; |
|
2562 |
int prevBCI = -1; |
|
2563 |
for (i = 0; body[i] != null; i++) { |
|
2564 |
band& b = *body[i]; |
|
2565 |
byte le_kind = b.le_kind; |
|
2566 |
||
2567 |
// Handle scalar part, if any. |
|
2568 |
int x = 0; |
|
2569 |
entry* e = null; |
|
2570 |
if (b.defc != null) { |
|
2571 |
// It has data, so unparse an element. |
|
2572 |
if (b.ixTag != CONSTANT_None) { |
|
2573 |
assert(le_kind == EK_REF); |
|
2574 |
if (b.ixTag == CONSTANT_Literal) |
|
2575 |
e = b.getRefUsing(cp.getKQIndex()); |
|
2576 |
else |
|
2577 |
e = b.getRefN(); |
|
2578 |
switch (b.le_len) { |
|
2579 |
case 0: break; |
|
2580 |
case 1: putu1ref(e); break; |
|
2581 |
case 2: putref(e); break; |
|
2582 |
case 4: putu2(0); putref(e); break; |
|
2583 |
default: assert(false); |
|
2584 |
} |
|
2585 |
} else { |
|
2586 |
assert(le_kind == EK_INT || le_kind == EK_REPL || le_kind == EK_UN); |
|
2587 |
x = b.getInt(); |
|
2588 |
||
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2589 |
assert(!b.le_bci || prevBCI == (int)to_bci(prevBII)); |
2 | 2590 |
switch (b.le_bci) { |
2591 |
case EK_BCI: // PH: transmit R(bci), store bci |
|
2592 |
x = to_bci(prevBII = x); |
|
2593 |
prevBCI = x; |
|
2594 |
break; |
|
2595 |
case EK_BCID: // POH: transmit D(R(bci)), store bci |
|
2596 |
x = to_bci(prevBII += x); |
|
2597 |
prevBCI = x; |
|
2598 |
break; |
|
2599 |
case EK_BCO: // OH: transmit D(R(bci)), store D(bci) |
|
2600 |
x = to_bci(prevBII += x) - prevBCI; |
|
2601 |
prevBCI += x; |
|
2602 |
break; |
|
2603 |
} |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2604 |
assert(!b.le_bci || prevBCI == (int)to_bci(prevBII)); |
2 | 2605 |
|
2606 |
switch (b.le_len) { |
|
2607 |
case 0: break; |
|
2608 |
case 1: putu1(x); break; |
|
2609 |
case 2: putu2(x); break; |
|
2610 |
case 4: putu4(x); break; |
|
2611 |
default: assert(false); |
|
2612 |
} |
|
2613 |
} |
|
2614 |
} |
|
2615 |
||
2616 |
// Handle subparts, if any. |
|
2617 |
switch (le_kind) { |
|
2618 |
case EK_REPL: |
|
2619 |
// x is the repeat count |
|
2620 |
while (x-- > 0) { |
|
2621 |
putlayout(b.le_body); |
|
2622 |
} |
|
2623 |
break; |
|
2624 |
case EK_UN: |
|
2625 |
// x is the tag |
|
2626 |
putlayout(findMatchingCase(x, b.le_body)); |
|
2627 |
break; |
|
2628 |
case EK_CALL: |
|
2629 |
{ |
|
2630 |
band& cble = *b.le_body[0]; |
|
2631 |
assert(cble.le_kind == EK_CBLE); |
|
2632 |
assert(cble.le_len == b.le_len); |
|
2633 |
putlayout(cble.le_body); |
|
2634 |
} |
|
2635 |
break; |
|
2636 |
||
2637 |
#ifndef PRODUCT |
|
2638 |
case EK_CBLE: |
|
2639 |
case EK_CASE: |
|
2640 |
assert(false); // should not reach here |
|
2641 |
#endif |
|
2642 |
} |
|
2643 |
} |
|
2644 |
} |
|
2645 |
||
2646 |
void unpacker::read_files() { |
|
2647 |
file_name.readData(file_count); |
|
2648 |
if ((archive_options & AO_HAVE_FILE_SIZE_HI) != 0) |
|
2649 |
file_size_hi.readData(file_count); |
|
2650 |
file_size_lo.readData(file_count); |
|
2651 |
if ((archive_options & AO_HAVE_FILE_MODTIME) != 0) |
|
2652 |
file_modtime.readData(file_count); |
|
2653 |
int allFiles = file_count + class_count; |
|
2654 |
if ((archive_options & AO_HAVE_FILE_OPTIONS) != 0) { |
|
2655 |
file_options.readData(file_count); |
|
2656 |
// FO_IS_CLASS_STUB might be set, causing overlap between classes and files |
|
2657 |
for (int i = 0; i < file_count; i++) { |
|
2658 |
if ((file_options.getInt() & FO_IS_CLASS_STUB) != 0) { |
|
2659 |
allFiles -= 1; // this one counts as both class and file |
|
2660 |
} |
|
2661 |
} |
|
2662 |
file_options.rewind(); |
|
2663 |
} |
|
2664 |
assert((default_file_options & FO_IS_CLASS_STUB) == 0); |
|
2665 |
files_remaining = allFiles; |
|
2666 |
} |
|
2667 |
||
2668 |
maybe_inline |
|
2669 |
void unpacker::get_code_header(int& max_stack, |
|
2670 |
int& max_na_locals, |
|
2671 |
int& handler_count, |
|
2672 |
int& cflags) { |
|
2673 |
int sc = code_headers.getByte(); |
|
2674 |
if (sc == 0) { |
|
2675 |
max_stack = max_na_locals = handler_count = cflags = -1; |
|
2676 |
return; |
|
2677 |
} |
|
2678 |
// Short code header is the usual case: |
|
2679 |
int nh; |
|
2680 |
int mod; |
|
2681 |
if (sc < 1 + 12*12) { |
|
2682 |
sc -= 1; |
|
2683 |
nh = 0; |
|
2684 |
mod = 12; |
|
2685 |
} else if (sc < 1 + 12*12 + 8*8) { |
|
2686 |
sc -= 1 + 12*12; |
|
2687 |
nh = 1; |
|
2688 |
mod = 8; |
|
2689 |
} else { |
|
2690 |
assert(sc < 1 + 12*12 + 8*8 + 7*7); |
|
2691 |
sc -= 1 + 12*12 + 8*8; |
|
2692 |
nh = 2; |
|
2693 |
mod = 7; |
|
2694 |
} |
|
2695 |
max_stack = sc % mod; |
|
2696 |
max_na_locals = sc / mod; // caller must add static, siglen |
|
2697 |
handler_count = nh; |
|
2698 |
if ((archive_options & AO_HAVE_ALL_CODE_FLAGS) != 0) |
|
2699 |
cflags = -1; |
|
2700 |
else |
|
2701 |
cflags = 0; // this one has no attributes |
|
2702 |
} |
|
2703 |
||
2704 |
// Cf. PackageReader.readCodeHeaders |
|
2705 |
void unpacker::read_code_headers() { |
|
2706 |
code_headers.readData(code_count); |
|
2707 |
CHECK; |
|
2708 |
int totalHandlerCount = 0; |
|
2709 |
int totalFlagsCount = 0; |
|
2710 |
for (int i = 0; i < code_count; i++) { |
|
2711 |
int max_stack, max_locals, handler_count, cflags; |
|
2712 |
get_code_header(max_stack, max_locals, handler_count, cflags); |
|
2713 |
if (max_stack < 0) code_max_stack.expectMoreLength(1); |
|
2714 |
if (max_locals < 0) code_max_na_locals.expectMoreLength(1); |
|
2715 |
if (handler_count < 0) code_handler_count.expectMoreLength(1); |
|
2716 |
else totalHandlerCount += handler_count; |
|
2717 |
if (cflags < 0) totalFlagsCount += 1; |
|
2718 |
} |
|
2719 |
code_headers.rewind(); // replay later during writing |
|
2720 |
||
2721 |
code_max_stack.readData(); |
|
2722 |
code_max_na_locals.readData(); |
|
2723 |
code_handler_count.readData(); |
|
2724 |
totalHandlerCount += code_handler_count.getIntTotal(); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2725 |
CHECK; |
2 | 2726 |
|
2727 |
// Read handler specifications. |
|
2728 |
// Cf. PackageReader.readCodeHandlers. |
|
2729 |
code_handler_start_P.readData(totalHandlerCount); |
|
2730 |
code_handler_end_PO.readData(totalHandlerCount); |
|
2731 |
code_handler_catch_PO.readData(totalHandlerCount); |
|
2732 |
code_handler_class_RCN.readData(totalHandlerCount); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2733 |
CHECK; |
2 | 2734 |
|
2735 |
read_attrs(ATTR_CONTEXT_CODE, totalFlagsCount); |
|
2607
7a11e5916dda
6792554: Java JAR Pack200 header checks are insufficent
ksrini
parents:
2602
diff
changeset
|
2736 |
CHECK; |
2 | 2737 |
} |
2738 |
||
2739 |
static inline bool is_in_range(uint n, uint min, uint max) { |
|
2740 |
return n - min <= max - min; // unsigned arithmetic! |
|
2741 |
} |
|
2742 |
static inline bool is_field_op(int bc) { |
|
2743 |
return is_in_range(bc, bc_getstatic, bc_putfield); |
|
2744 |
} |
|
2745 |
static inline bool is_invoke_init_op(int bc) { |
|
2746 |
return is_in_range(bc, _invokeinit_op, _invokeinit_limit-1); |
|
2747 |
} |
|
2748 |
static inline bool is_self_linker_op(int bc) { |
|
2749 |
return is_in_range(bc, _self_linker_op, _self_linker_limit-1); |
|
2750 |
} |
|
2751 |
static bool is_branch_op(int bc) { |
|
2752 |
return is_in_range(bc, bc_ifeq, bc_jsr) |
|
2753 |
|| is_in_range(bc, bc_ifnull, bc_jsr_w); |
|
2754 |
} |
|
2755 |
static bool is_local_slot_op(int bc) { |
|
2756 |
return is_in_range(bc, bc_iload, bc_aload) |
|
2757 |
|| is_in_range(bc, bc_istore, bc_astore) |
|
2758 |
|| bc == bc_iinc || bc == bc_ret; |
|
2759 |
} |
|
2760 |
band* unpacker::ref_band_for_op(int bc) { |
|
2761 |
switch (bc) { |
|
2762 |
case bc_ildc: |
|
2763 |
case bc_ildc_w: |
|
2764 |
return &bc_intref; |
|
2765 |
case bc_fldc: |
|
2766 |
case bc_fldc_w: |
|
2767 |
return &bc_floatref; |
|
2768 |
case bc_lldc2_w: |
|
2769 |
return &bc_longref; |
|
2770 |
case bc_dldc2_w: |
|
2771 |
return &bc_doubleref; |
|
2772 |
case bc_aldc: |
|
2773 |
case bc_aldc_w: |
|
2774 |
return &bc_stringref; |
|
2775 |
case bc_cldc: |
|
2776 |
case bc_cldc_w: |
|
2777 |
return &bc_classref; |
|
2778 |
||
2779 |
case bc_getstatic: |
|
2780 |
case bc_putstatic: |
|
2781 |
case bc_getfield: |
|
2782 |
case bc_putfield: |
|
2783 |
return &bc_fieldref; |
|
2784 |
||
2785 |
case bc_invokevirtual: |
|
2786 |
case bc_invokespecial: |
|
2787 |
case bc_invokestatic: |
|
2788 |
return &bc_methodref; |
|
2789 |
case bc_invokeinterface: |
|
2790 |
return &bc_imethodref; |
|
2791 |
||
2792 |
case bc_new: |
|
2793 |
case bc_anewarray: |
|
2794 |
case bc_checkcast: |
|
2795 |
case bc_instanceof: |
|
2796 |
case bc_multianewarray: |
|
2797 |
return &bc_classref; |
|
2798 |
} |
|
2799 |
return null; |
|
2800 |
} |
|
2801 |
||
2802 |
maybe_inline |
|
2803 |
band* unpacker::ref_band_for_self_op(int bc, bool& isAloadVar, int& origBCVar) { |
|
2804 |
if (!is_self_linker_op(bc)) return null; |
|
2805 |
int idx = (bc - _self_linker_op); |
|
2806 |
bool isSuper = (idx >= _self_linker_super_flag); |
|
2807 |
if (isSuper) idx -= _self_linker_super_flag; |
|
2808 |
bool isAload = (idx >= _self_linker_aload_flag); |
|
2809 |
if (isAload) idx -= _self_linker_aload_flag; |
|
2810 |
int origBC = _first_linker_op + idx; |
|
2811 |
bool isField = is_field_op(origBC); |
|
2812 |
isAloadVar = isAload; |
|
2813 |
origBCVar = _first_linker_op + idx; |
|
2814 |
if (!isSuper) |
|
2815 |
return isField? &bc_thisfield: &bc_thismethod; |
|
2816 |
else |
|
2817 |
return isField? &bc_superfield: &bc_supermethod; |
|
2818 |
} |
|
2819 |
||
2820 |
// Cf. PackageReader.readByteCodes |
|
2821 |
inline // called exactly once => inline |
|
2822 |
void unpacker::read_bcs() { |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2823 |
PRINTCR((3, "reading compressed bytecodes and operands for %d codes...", |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2824 |
code_count)); |
2 | 2825 |
|
2826 |
// read from bc_codes and bc_case_count |
|
2827 |
fillbytes all_switch_ops; |
|
2828 |
all_switch_ops.init(); |
|
2829 |
CHECK; |
|
2830 |
||
2831 |
// Read directly from rp/rplimit. |
|
2832 |
//Do this later: bc_codes.readData(...) |
|
2833 |
byte* rp0 = rp; |
|
2834 |
||
2835 |
band* bc_which; |
|
2836 |
byte* opptr = rp; |
|
2837 |
byte* oplimit = rplimit; |
|
2838 |
||
2839 |
bool isAload; // passed by ref and then ignored |
|
2840 |
int junkBC; // passed by ref and then ignored |
|
2841 |
for (int k = 0; k < code_count; k++) { |
|
2842 |
// Scan one method: |
|
2843 |
for (;;) { |
|
2844 |
if (opptr+2 > oplimit) { |
|
2845 |
rp = opptr; |
|
2846 |
ensure_input(2); |
|
2847 |
oplimit = rplimit; |
|
2848 |
rp = rp0; // back up |
|
2849 |
} |
|
2850 |
if (opptr == oplimit) { abort(); break; } |
|
2851 |
int bc = *opptr++ & 0xFF; |
|
2852 |
bool isWide = false; |
|
2853 |
if (bc == bc_wide) { |
|
2854 |
if (opptr == oplimit) { abort(); break; } |
|
2855 |
bc = *opptr++ & 0xFF; |
|
2856 |
isWide = true; |
|
2857 |
} |
|
2858 |
// Adjust expectations of various band sizes. |
|
2859 |
switch (bc) { |
|
2860 |
case bc_tableswitch: |
|
2861 |
case bc_lookupswitch: |
|
2862 |
all_switch_ops.addByte(bc); |
|
2863 |
break; |
|
2864 |
case bc_iinc: |
|
2865 |
bc_local.expectMoreLength(1); |
|
2866 |
bc_which = isWide ? &bc_short : &bc_byte; |
|
2867 |
bc_which->expectMoreLength(1); |
|
2868 |
break; |
|
2869 |
case bc_sipush: |
|
2870 |
bc_short.expectMoreLength(1); |
|
2871 |
break; |
|
2872 |
case bc_bipush: |
|
2873 |
bc_byte.expectMoreLength(1); |
|
2874 |
break; |
|
2875 |
case bc_newarray: |
|
2876 |
bc_byte.expectMoreLength(1); |
|
2877 |
break; |
|
2878 |
case bc_multianewarray: |
|
2879 |
assert(ref_band_for_op(bc) == &bc_classref); |
|
2880 |
bc_classref.expectMoreLength(1); |
|
2881 |
bc_byte.expectMoreLength(1); |
|
2882 |
break; |
|
2883 |
case bc_ref_escape: |
|
2884 |
bc_escrefsize.expectMoreLength(1); |
|
2885 |
bc_escref.expectMoreLength(1); |
|
2886 |
break; |
|
2887 |
case bc_byte_escape: |
|
2888 |
bc_escsize.expectMoreLength(1); |
|
2889 |
// bc_escbyte will have to be counted too |
|
2890 |
break; |
|
2891 |
default: |
|
2892 |
if (is_invoke_init_op(bc)) { |
|
2893 |
bc_initref.expectMoreLength(1); |
|
2894 |
break; |
|
2895 |
} |
|
2896 |
bc_which = ref_band_for_self_op(bc, isAload, junkBC); |
|
2897 |
if (bc_which != null) { |
|
2898 |
bc_which->expectMoreLength(1); |
|
2899 |
break; |
|
2900 |
} |
|
2901 |
if (is_branch_op(bc)) { |
|
2902 |
bc_label.expectMoreLength(1); |
|
2903 |
break; |
|
2904 |
} |
|
2905 |
bc_which = ref_band_for_op(bc); |
|
2906 |
if (bc_which != null) { |
|
2907 |
bc_which->expectMoreLength(1); |
|
2908 |
assert(bc != bc_multianewarray); // handled elsewhere |
|
2909 |
break; |
|
2910 |
} |
|
2911 |
if (is_local_slot_op(bc)) { |
|
2912 |
bc_local.expectMoreLength(1); |
|
2913 |
break; |
|
2914 |
} |
|
2915 |
break; |
|
2916 |
case bc_end_marker: |
|
2917 |
// Increment k and test against code_count. |
|
2918 |
goto doneScanningMethod; |
|
2919 |
} |
|
2920 |
} |
|
2921 |
doneScanningMethod:{} |
|
2922 |
if (aborting()) break; |
|
2923 |
} |
|
2924 |
||
2925 |
// Go through the formality, so we can use it in a regular fashion later: |
|
2926 |
assert(rp == rp0); |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2927 |
bc_codes.readData((int)(opptr - rp)); |
2 | 2928 |
|
2929 |
int i = 0; |
|
2930 |
||
2931 |
// To size instruction bands correctly, we need info on switches: |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2932 |
bc_case_count.readData((int)all_switch_ops.size()); |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2933 |
for (i = 0; i < (int)all_switch_ops.size(); i++) { |
2 | 2934 |
int caseCount = bc_case_count.getInt(); |
2935 |
int bc = all_switch_ops.getByte(i); |
|
2936 |
bc_label.expectMoreLength(1+caseCount); // default label + cases |
|
2937 |
bc_case_value.expectMoreLength(bc == bc_tableswitch ? 1 : caseCount); |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2938 |
PRINTCR((2, "switch bc=%d caseCount=%d", bc, caseCount)); |
2 | 2939 |
} |
2940 |
bc_case_count.rewind(); // uses again for output |
|
2941 |
||
2942 |
all_switch_ops.free(); |
|
2943 |
||
2944 |
for (i = e_bc_case_value; i <= e_bc_escsize; i++) { |
|
2945 |
all_bands[i].readData(); |
|
2946 |
} |
|
2947 |
||
2948 |
// The bc_escbyte band is counted by the immediately previous band. |
|
2949 |
bc_escbyte.readData(bc_escsize.getIntTotal()); |
|
2950 |
||
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2951 |
PRINTCR((3, "scanned %d opcode and %d operand bytes for %d codes...", |
2 | 2952 |
(int)(bc_codes.size()), |
2953 |
(int)(bc_escsize.maxRP() - bc_case_value.minRP()), |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2954 |
code_count)); |
2 | 2955 |
} |
2956 |
||
2957 |
void unpacker::read_bands() { |
|
2958 |
byte* rp0 = rp; |
|
2959 |
||
2960 |
read_file_header(); |
|
2961 |
CHECK; |
|
2962 |
||
2963 |
if (cp.nentries == 0) { |
|
2964 |
// read_file_header failed to read a CP, because it copied a JAR. |
|
2965 |
return; |
|
2966 |
} |
|
2967 |
||
2968 |
// Do this after the file header has been read: |
|
2969 |
check_options(); |
|
2970 |
||
2971 |
read_cp(); |
|
2972 |
CHECK; |
|
2973 |
read_attr_defs(); |
|
2974 |
CHECK; |
|
2975 |
read_ics(); |
|
2976 |
CHECK; |
|
2977 |
read_classes(); |
|
2978 |
CHECK; |
|
2979 |
read_bcs(); |
|
2980 |
CHECK; |
|
2981 |
read_files(); |
|
2982 |
} |
|
2983 |
||
2984 |
/// CP routines |
|
2985 |
||
2986 |
entry*& cpool::hashTabRef(byte tag, bytes& b) { |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2987 |
PRINTCR((5, "hashTabRef tag=%d %s[%d]", tag, b.string(), b.len)); |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2988 |
uint hash = tag + (int)b.len; |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
2989 |
for (int i = 0; i < (int)b.len; i++) { |
2 | 2990 |
hash = hash * 31 + (0xFF & b.ptr[i]); |
2991 |
} |
|
2992 |
entry** ht = hashTab; |
|
2993 |
int hlen = hashTabLength; |
|
2994 |
assert((hlen & (hlen-1)) == 0); // must be power of 2 |
|
2995 |
uint hash1 = hash & (hlen-1); // == hash % hlen |
|
2996 |
uint hash2 = 0; // lazily computed (requires mod op.) |
|
2997 |
int probes = 0; |
|
2998 |
while (ht[hash1] != null) { |
|
2999 |
entry& e = *ht[hash1]; |
|
3000 |
if (e.value.b.equals(b) && e.tag == tag) |
|
3001 |
break; |
|
3002 |
if (hash2 == 0) |
|
3003 |
// Note: hash2 must be relatively prime to hlen, hence the "|1". |
|
3004 |
hash2 = (((hash % 499) & (hlen-1)) | 1); |
|
3005 |
hash1 += hash2; |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3006 |
if (hash1 >= (uint)hlen) hash1 -= hlen; |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3007 |
assert(hash1 < (uint)hlen); |
2 | 3008 |
assert(++probes < hlen); |
3009 |
} |
|
3010 |
#ifndef PRODUCT |
|
3011 |
hash_probes[0] += 1; |
|
3012 |
hash_probes[1] += probes; |
|
3013 |
#endif |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3014 |
PRINTCR((5, " => @%d %p", hash1, ht[hash1])); |
2 | 3015 |
return ht[hash1]; |
3016 |
} |
|
3017 |
||
3018 |
maybe_inline |
|
3019 |
static void insert_extra(entry* e, ptrlist& extras) { |
|
3020 |
// This ordering helps implement the Pack200 requirement |
|
3021 |
// of a predictable CP order in the class files produced. |
|
3022 |
e->inord = NO_INORD; // mark as an "extra" |
|
3023 |
extras.add(e); |
|
3024 |
// Note: We will sort the list (by string-name) later. |
|
3025 |
} |
|
3026 |
||
3027 |
entry* cpool::ensureUtf8(bytes& b) { |
|
3028 |
entry*& ix = hashTabRef(CONSTANT_Utf8, b); |
|
3029 |
if (ix != null) return ix; |
|
3030 |
// Make one. |
|
3031 |
if (nentries == maxentries) { |
|
3032 |
abort("cp utf8 overflow"); |
|
3033 |
return &entries[tag_base[CONSTANT_Utf8]]; // return something |
|
3034 |
} |
|
3035 |
entry& e = entries[nentries++]; |
|
3036 |
e.tag = CONSTANT_Utf8; |
|
3037 |
u->saveTo(e.value.b, b); |
|
3038 |
assert(&e >= first_extra_entry); |
|
3039 |
insert_extra(&e, tag_extras[CONSTANT_Utf8]); |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3040 |
PRINTCR((4,"ensureUtf8 miss %s", e.string())); |
2 | 3041 |
return ix = &e; |
3042 |
} |
|
3043 |
||
3044 |
entry* cpool::ensureClass(bytes& b) { |
|
3045 |
entry*& ix = hashTabRef(CONSTANT_Class, b); |
|
3046 |
if (ix != null) return ix; |
|
3047 |
// Make one. |
|
3048 |
if (nentries == maxentries) { |
|
3049 |
abort("cp class overflow"); |
|
3050 |
return &entries[tag_base[CONSTANT_Class]]; // return something |
|
3051 |
} |
|
3052 |
entry& e = entries[nentries++]; |
|
3053 |
e.tag = CONSTANT_Class; |
|
3054 |
e.nrefs = 1; |
|
3055 |
e.refs = U_NEW(entry*, 1); |
|
3056 |
ix = &e; // hold my spot in the index |
|
3057 |
entry* utf = ensureUtf8(b); |
|
3058 |
e.refs[0] = utf; |
|
3059 |
e.value.b = utf->value.b; |
|
3060 |
assert(&e >= first_extra_entry); |
|
3061 |
insert_extra(&e, tag_extras[CONSTANT_Class]); |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3062 |
PRINTCR((4,"ensureClass miss %s", e.string())); |
2 | 3063 |
return &e; |
3064 |
} |
|
3065 |
||
3066 |
void cpool::expandSignatures() { |
|
3067 |
int i; |
|
3068 |
int nsigs = 0; |
|
3069 |
int nreused = 0; |
|
3070 |
int first_sig = tag_base[CONSTANT_Signature]; |
|
3071 |
int sig_limit = tag_count[CONSTANT_Signature] + first_sig; |
|
3072 |
fillbytes buf; |
|
3073 |
buf.init(1<<10); |
|
3074 |
CHECK; |
|
3075 |
for (i = first_sig; i < sig_limit; i++) { |
|
3076 |
entry& e = entries[i]; |
|
3077 |
assert(e.tag == CONSTANT_Signature); |
|
3078 |
int refnum = 0; |
|
3079 |
bytes form = e.refs[refnum++]->asUtf8(); |
|
3080 |
buf.empty(); |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3081 |
for (int j = 0; j < (int)form.len; j++) { |
2 | 3082 |
int c = form.ptr[j]; |
3083 |
buf.addByte(c); |
|
3084 |
if (c == 'L') { |
|
3085 |
entry* cls = e.refs[refnum++]; |
|
3086 |
buf.append(cls->className()->asUtf8()); |
|
3087 |
} |
|
3088 |
} |
|
3089 |
assert(refnum == e.nrefs); |
|
3090 |
bytes& sig = buf.b; |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3091 |
PRINTCR((5,"signature %d %s -> %s", i, form.ptr, sig.ptr)); |
2 | 3092 |
|
3093 |
// try to find a pre-existing Utf8: |
|
3094 |
entry* &e2 = hashTabRef(CONSTANT_Utf8, sig); |
|
3095 |
if (e2 != null) { |
|
3096 |
assert(e2->isUtf8(sig)); |
|
3097 |
e.value.b = e2->value.b; |
|
3098 |
e.refs[0] = e2; |
|
3099 |
e.nrefs = 1; |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3100 |
PRINTCR((5,"signature replaced %d => %s", i, e.string())); |
2 | 3101 |
nreused++; |
3102 |
} else { |
|
3103 |
// there is no other replacement; reuse this CP entry as a Utf8 |
|
3104 |
u->saveTo(e.value.b, sig); |
|
3105 |
e.tag = CONSTANT_Utf8; |
|
3106 |
e.nrefs = 0; |
|
3107 |
e2 = &e; |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3108 |
PRINTCR((5,"signature changed %d => %s", e.inord, e.string())); |
2 | 3109 |
} |
3110 |
nsigs++; |
|
3111 |
} |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3112 |
PRINTCR((1,"expanded %d signatures (reused %d utfs)", nsigs, nreused)); |
2 | 3113 |
buf.free(); |
3114 |
||
3115 |
// go expunge all references to remaining signatures: |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3116 |
for (i = 0; i < (int)nentries; i++) { |
2 | 3117 |
entry& e = entries[i]; |
3118 |
for (int j = 0; j < e.nrefs; j++) { |
|
3119 |
entry*& e2 = e.refs[j]; |
|
3120 |
if (e2 != null && e2->tag == CONSTANT_Signature) |
|
3121 |
e2 = e2->refs[0]; |
|
3122 |
} |
|
3123 |
} |
|
3124 |
} |
|
3125 |
||
3126 |
void cpool::initMemberIndexes() { |
|
3127 |
// This function does NOT refer to any class schema. |
|
3128 |
// It is totally internal to the cpool. |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3129 |
int i, j; |
2 | 3130 |
|
3131 |
// Get the pre-existing indexes: |
|
3132 |
int nclasses = tag_count[CONSTANT_Class]; |
|
3133 |
entry* classes = tag_base[CONSTANT_Class] + entries; |
|
3134 |
int nfields = tag_count[CONSTANT_Fieldref]; |
|
3135 |
entry* fields = tag_base[CONSTANT_Fieldref] + entries; |
|
3136 |
int nmethods = tag_count[CONSTANT_Methodref]; |
|
3137 |
entry* methods = tag_base[CONSTANT_Methodref] + entries; |
|
3138 |
||
3139 |
int* field_counts = T_NEW(int, nclasses); |
|
3140 |
int* method_counts = T_NEW(int, nclasses); |
|
3141 |
cpindex* all_indexes = U_NEW(cpindex, nclasses*2); |
|
5191
79b41f733e33
6902299: Java JAR "unpack200" must verify input parameters
ksrini
parents:
3463
diff
changeset
|
3142 |
entry** field_ix = U_NEW(entry*, add_size(nfields, nclasses)); |
79b41f733e33
6902299: Java JAR "unpack200" must verify input parameters
ksrini
parents:
3463
diff
changeset
|
3143 |
entry** method_ix = U_NEW(entry*, add_size(nmethods, nclasses)); |
2 | 3144 |
|
3145 |
for (j = 0; j < nfields; j++) { |
|
3146 |
entry& f = fields[j]; |
|
3147 |
i = f.memberClass()->inord; |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3148 |
assert(i < nclasses); |
2 | 3149 |
field_counts[i]++; |
3150 |
} |
|
3151 |
for (j = 0; j < nmethods; j++) { |
|
3152 |
entry& m = methods[j]; |
|
3153 |
i = m.memberClass()->inord; |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3154 |
assert(i < nclasses); |
2 | 3155 |
method_counts[i]++; |
3156 |
} |
|
3157 |
||
3158 |
int fbase = 0, mbase = 0; |
|
3159 |
for (i = 0; i < nclasses; i++) { |
|
3160 |
int fc = field_counts[i]; |
|
3161 |
int mc = method_counts[i]; |
|
3162 |
all_indexes[i*2+0].init(fc, field_ix+fbase, |
|
3163 |
CONSTANT_Fieldref + SUBINDEX_BIT); |
|
3164 |
all_indexes[i*2+1].init(mc, method_ix+mbase, |
|
3165 |
CONSTANT_Methodref + SUBINDEX_BIT); |
|
3166 |
// reuse field_counts and member_counts as fill pointers: |
|
3167 |
field_counts[i] = fbase; |
|
3168 |
method_counts[i] = mbase; |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3169 |
PRINTCR((3, "class %d fields @%d[%d] methods @%d[%d]", |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3170 |
i, fbase, fc, mbase, mc)); |
2 | 3171 |
fbase += fc+1; |
3172 |
mbase += mc+1; |
|
3173 |
// (the +1 leaves a space between every subarray) |
|
3174 |
} |
|
3175 |
assert(fbase == nfields+nclasses); |
|
3176 |
assert(mbase == nmethods+nclasses); |
|
3177 |
||
3178 |
for (j = 0; j < nfields; j++) { |
|
3179 |
entry& f = fields[j]; |
|
3180 |
i = f.memberClass()->inord; |
|
3181 |
field_ix[field_counts[i]++] = &f; |
|
3182 |
} |
|
3183 |
for (j = 0; j < nmethods; j++) { |
|
3184 |
entry& m = methods[j]; |
|
3185 |
i = m.memberClass()->inord; |
|
3186 |
method_ix[method_counts[i]++] = &m; |
|
3187 |
} |
|
3188 |
||
3189 |
member_indexes = all_indexes; |
|
3190 |
||
3191 |
#ifndef PRODUCT |
|
3192 |
// Test the result immediately on every class and field. |
|
3193 |
int fvisited = 0, mvisited = 0; |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3194 |
int prevord, len; |
2 | 3195 |
for (i = 0; i < nclasses; i++) { |
3196 |
entry* cls = &classes[i]; |
|
3197 |
cpindex* fix = getFieldIndex(cls); |
|
3198 |
cpindex* mix = getMethodIndex(cls); |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3199 |
PRINTCR((2, "field and method index for %s [%d] [%d]", |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3200 |
cls->string(), mix->len, fix->len)); |
2 | 3201 |
prevord = -1; |
3202 |
for (j = 0, len = fix->len; j < len; j++) { |
|
3203 |
entry* f = fix->get(j); |
|
3204 |
assert(f != null); |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3205 |
PRINTCR((3, "- field %s", f->string())); |
2 | 3206 |
assert(f->memberClass() == cls); |
3207 |
assert(prevord < (int)f->inord); |
|
3208 |
prevord = f->inord; |
|
3209 |
fvisited++; |
|
3210 |
} |
|
3211 |
assert(fix->base2[j] == null); |
|
3212 |
prevord = -1; |
|
3213 |
for (j = 0, len = mix->len; j < len; j++) { |
|
3214 |
entry* m = mix->get(j); |
|
3215 |
assert(m != null); |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3216 |
PRINTCR((3, "- method %s", m->string())); |
2 | 3217 |
assert(m->memberClass() == cls); |
3218 |
assert(prevord < (int)m->inord); |
|
3219 |
prevord = m->inord; |
|
3220 |
mvisited++; |
|
3221 |
} |
|
3222 |
assert(mix->base2[j] == null); |
|
3223 |
} |
|
3224 |
assert(fvisited == nfields); |
|
3225 |
assert(mvisited == nmethods); |
|
3226 |
#endif |
|
3227 |
||
3228 |
// Free intermediate buffers. |
|
3229 |
u->free_temps(); |
|
3230 |
} |
|
3231 |
||
3232 |
void entry::requestOutputIndex(cpool& cp, int req) { |
|
3233 |
assert(outputIndex <= NOT_REQUESTED); // must not have assigned indexes yet |
|
3234 |
if (tag == CONSTANT_Signature) { |
|
3235 |
ref(0)->requestOutputIndex(cp, req); |
|
3236 |
return; |
|
3237 |
} |
|
3238 |
assert(req == REQUESTED || req == REQUESTED_LDC); |
|
3239 |
if (outputIndex != NOT_REQUESTED) { |
|
3240 |
if (req == REQUESTED_LDC) |
|
3241 |
outputIndex = req; // this kind has precedence |
|
3242 |
return; |
|
3243 |
} |
|
3244 |
outputIndex = req; |
|
3245 |
//assert(!cp.outputEntries.contains(this)); |
|
3246 |
assert(tag != CONSTANT_Signature); |
|
3247 |
cp.outputEntries.add(this); |
|
3248 |
for (int j = 0; j < nrefs; j++) { |
|
3249 |
ref(j)->requestOutputIndex(cp); |
|
3250 |
} |
|
3251 |
} |
|
3252 |
||
3253 |
void cpool::resetOutputIndexes() { |
|
3254 |
int i; |
|
3255 |
int noes = outputEntries.length(); |
|
3256 |
entry** oes = (entry**) outputEntries.base(); |
|
3257 |
for (i = 0; i < noes; i++) { |
|
3258 |
entry& e = *oes[i]; |
|
3259 |
e.outputIndex = NOT_REQUESTED; |
|
3260 |
} |
|
3261 |
outputIndexLimit = 0; |
|
3262 |
outputEntries.empty(); |
|
3263 |
#ifndef PRODUCT |
|
3264 |
// they must all be clear now |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3265 |
for (i = 0; i < (int)nentries; i++) |
2 | 3266 |
assert(entries[i].outputIndex == NOT_REQUESTED); |
3267 |
#endif |
|
3268 |
} |
|
3269 |
||
3270 |
static const byte TAG_ORDER[CONSTANT_Limit] = { |
|
3271 |
0, 1, 0, 2, 3, 4, 5, 7, 6, 10, 11, 12, 9, 8 |
|
3272 |
}; |
|
3273 |
||
3274 |
extern "C" |
|
3275 |
int outputEntry_cmp(const void* e1p, const void* e2p) { |
|
3276 |
// Sort entries according to the Pack200 rules for deterministic |
|
3277 |
// constant pool ordering. |
|
3278 |
// |
|
3279 |
// The four sort keys as follows, in order of decreasing importance: |
|
3280 |
// 1. ldc first, then non-ldc guys |
|
3281 |
// 2. normal cp_All entries by input order (i.e., address order) |
|
3282 |
// 3. after that, extra entries by lexical order (as in tag_extras[*]) |
|
3283 |
entry& e1 = *(entry*) *(void**) e1p; |
|
3284 |
entry& e2 = *(entry*) *(void**) e2p; |
|
3285 |
int oi1 = e1.outputIndex; |
|
3286 |
int oi2 = e2.outputIndex; |
|
3287 |
assert(oi1 == REQUESTED || oi1 == REQUESTED_LDC); |
|
3288 |
assert(oi2 == REQUESTED || oi2 == REQUESTED_LDC); |
|
3289 |
if (oi1 != oi2) { |
|
3290 |
if (oi1 == REQUESTED_LDC) return 0-1; |
|
3291 |
if (oi2 == REQUESTED_LDC) return 1-0; |
|
3292 |
// Else fall through; neither is an ldc request. |
|
3293 |
} |
|
3294 |
if (e1.inord != NO_INORD || e2.inord != NO_INORD) { |
|
3295 |
// One or both is normal. Use input order. |
|
3296 |
if (&e1 > &e2) return 1-0; |
|
3297 |
if (&e1 < &e2) return 0-1; |
|
3298 |
return 0; // equal pointers |
|
3299 |
} |
|
3300 |
// Both are extras. Sort by tag and then by value. |
|
3301 |
if (e1.tag != e2.tag) { |
|
3302 |
return TAG_ORDER[e1.tag] - TAG_ORDER[e2.tag]; |
|
3303 |
} |
|
3304 |
// If the tags are the same, use string comparison. |
|
3305 |
return compare_Utf8_chars(e1.value.b, e2.value.b); |
|
3306 |
} |
|
3307 |
||
3308 |
void cpool::computeOutputIndexes() { |
|
3309 |
int i; |
|
3310 |
||
3311 |
#ifndef PRODUCT |
|
3312 |
// outputEntries must be a complete list of those requested: |
|
3313 |
static uint checkStart = 0; |
|
3314 |
int checkStep = 1; |
|
3315 |
if (nentries > 100) checkStep = nentries / 100; |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3316 |
for (i = (int)(checkStart++ % checkStep); i < (int)nentries; i += checkStep) { |
2 | 3317 |
entry& e = entries[i]; |
3318 |
if (e.outputIndex != NOT_REQUESTED) { |
|
3319 |
assert(outputEntries.contains(&e)); |
|
3320 |
} else { |
|
3321 |
assert(!outputEntries.contains(&e)); |
|
3322 |
} |
|
3323 |
} |
|
3324 |
||
3325 |
// check hand-initialization of TAG_ORDER |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3326 |
for (i = 0; i < (int)N_TAGS_IN_ORDER; i++) { |
2 | 3327 |
byte tag = TAGS_IN_ORDER[i]; |
3328 |
assert(TAG_ORDER[tag] == i+1); |
|
3329 |
} |
|
3330 |
#endif |
|
3331 |
||
3332 |
int noes = outputEntries.length(); |
|
3333 |
entry** oes = (entry**) outputEntries.base(); |
|
3334 |
||
3335 |
// Sort the output constant pool into the order required by Pack200. |
|
3336 |
PTRLIST_QSORT(outputEntries, outputEntry_cmp); |
|
3337 |
||
3338 |
// Allocate a new index for each entry that needs one. |
|
3339 |
// We do this in two passes, one for LDC entries and one for the rest. |
|
3340 |
int nextIndex = 1; // always skip index #0 in output cpool |
|
3341 |
for (i = 0; i < noes; i++) { |
|
3342 |
entry& e = *oes[i]; |
|
3343 |
assert(e.outputIndex == REQUESTED || e.outputIndex == REQUESTED_LDC); |
|
3344 |
e.outputIndex = nextIndex++; |
|
3345 |
if (e.isDoubleWord()) nextIndex++; // do not use the next index |
|
3346 |
} |
|
3347 |
outputIndexLimit = nextIndex; |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3348 |
PRINTCR((3,"renumbering CP to %d entries", outputIndexLimit)); |
2 | 3349 |
} |
3350 |
||
3351 |
#ifndef PRODUCT |
|
3352 |
// debugging goo |
|
3353 |
||
3354 |
unpacker* debug_u; |
|
3355 |
||
3356 |
static bytes& getbuf(int len) { // for debugging only! |
|
3357 |
static int bn = 0; |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3358 |
static bytes bufs[8]; |
2 | 3359 |
bytes& buf = bufs[bn++ & 7]; |
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3360 |
while ((int)buf.len < len+10) |
2 | 3361 |
buf.realloc(buf.len ? buf.len * 2 : 1000); |
3362 |
buf.ptr[0] = 0; // for the sake of strcat |
|
3363 |
return buf; |
|
3364 |
} |
|
3365 |
||
3366 |
char* entry::string() { |
|
3367 |
bytes buf; |
|
3368 |
switch (tag) { |
|
3369 |
case CONSTANT_None: |
|
3370 |
return (char*)"<empty>"; |
|
3371 |
case CONSTANT_Signature: |
|
3372 |
if (value.b.ptr == null) |
|
3373 |
return ref(0)->string(); |
|
3374 |
// else fall through: |
|
3375 |
case CONSTANT_Utf8: |
|
3376 |
buf = value.b; |
|
3377 |
break; |
|
3378 |
case CONSTANT_Integer: |
|
3379 |
case CONSTANT_Float: |
|
3380 |
buf = getbuf(12); |
|
3381 |
sprintf((char*)buf.ptr, "0x%08x", value.i); |
|
3382 |
break; |
|
3383 |
case CONSTANT_Long: |
|
3384 |
case CONSTANT_Double: |
|
3385 |
buf = getbuf(24); |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3386 |
sprintf((char*)buf.ptr, "0x" LONG_LONG_HEX_FORMAT, value.l); |
2 | 3387 |
break; |
3388 |
default: |
|
3389 |
if (nrefs == 0) { |
|
3390 |
buf = getbuf(20); |
|
3391 |
sprintf((char*)buf.ptr, "<tag=%d>", tag); |
|
3392 |
} else if (nrefs == 1) { |
|
3393 |
return refs[0]->string(); |
|
3394 |
} else { |
|
3395 |
char* s1 = refs[0]->string(); |
|
3396 |
char* s2 = refs[1]->string(); |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3397 |
buf = getbuf((int)strlen(s1) + 1 + (int)strlen(s2) + 4 + 1); |
2 | 3398 |
buf.strcat(s1).strcat(" ").strcat(s2); |
3399 |
if (nrefs > 2) buf.strcat(" ..."); |
|
3400 |
} |
|
3401 |
} |
|
3402 |
return (char*)buf.ptr; |
|
3403 |
} |
|
3404 |
||
3405 |
void print_cp_entry(int i) { |
|
3406 |
entry& e = debug_u->cp.entries[i]; |
|
3407 |
char buf[30]; |
|
3408 |
sprintf(buf, ((uint)e.tag < CONSTANT_Limit)? TAG_NAME[e.tag]: "%d", e.tag); |
|
3409 |
printf(" %d\t%s %s\n", i, buf, e.string()); |
|
3410 |
} |
|
3411 |
||
3412 |
void print_cp_entries(int beg, int end) { |
|
3413 |
for (int i = beg; i < end; i++) |
|
3414 |
print_cp_entry(i); |
|
3415 |
} |
|
3416 |
||
3417 |
void print_cp() { |
|
3418 |
print_cp_entries(0, debug_u->cp.nentries); |
|
3419 |
} |
|
3420 |
||
3421 |
#endif |
|
3422 |
||
3423 |
// Unpacker Start |
|
3424 |
||
3425 |
const char str_tf[] = "true\0false"; |
|
3426 |
#undef STR_TRUE |
|
3427 |
#undef STR_FALSE |
|
3428 |
#define STR_TRUE (&str_tf[0]) |
|
3429 |
#define STR_FALSE (&str_tf[5]) |
|
3430 |
||
3431 |
const char* unpacker::get_option(const char* prop) { |
|
3432 |
if (prop == null ) return null; |
|
3433 |
if (strcmp(prop, UNPACK_DEFLATE_HINT) == 0) { |
|
3434 |
return deflate_hint_or_zero == 0? null : STR_TF(deflate_hint_or_zero > 0); |
|
3435 |
#ifdef HAVE_STRIP |
|
3436 |
} else if (strcmp(prop, UNPACK_STRIP_COMPILE) == 0) { |
|
3437 |
return STR_TF(strip_compile); |
|
3438 |
} else if (strcmp(prop, UNPACK_STRIP_DEBUG) == 0) { |
|
3439 |
return STR_TF(strip_debug); |
|
3440 |
} else if (strcmp(prop, UNPACK_STRIP_JCOV) == 0) { |
|
3441 |
return STR_TF(strip_jcov); |
|
3442 |
#endif /*HAVE_STRIP*/ |
|
3443 |
} else if (strcmp(prop, UNPACK_REMOVE_PACKFILE) == 0) { |
|
3444 |
return STR_TF(remove_packfile); |
|
3445 |
} else if (strcmp(prop, DEBUG_VERBOSE) == 0) { |
|
3446 |
return saveIntStr(verbose); |
|
3447 |
} else if (strcmp(prop, UNPACK_MODIFICATION_TIME) == 0) { |
|
3448 |
return (modification_time_or_zero == 0)? null: |
|
3449 |
saveIntStr(modification_time_or_zero); |
|
3450 |
} else if (strcmp(prop, UNPACK_LOG_FILE) == 0) { |
|
3451 |
return log_file; |
|
3452 |
} else { |
|
3453 |
return NULL; // unknown option ignore |
|
3454 |
} |
|
3455 |
} |
|
3456 |
||
3457 |
bool unpacker::set_option(const char* prop, const char* value) { |
|
3458 |
if (prop == NULL) return false; |
|
3459 |
if (strcmp(prop, UNPACK_DEFLATE_HINT) == 0) { |
|
3460 |
deflate_hint_or_zero = ( (value == null || strcmp(value, "keep") == 0) |
|
3461 |
? 0: BOOL_TF(value) ? +1: -1); |
|
3462 |
#ifdef HAVE_STRIP |
|
3463 |
} else if (strcmp(prop, UNPACK_STRIP_COMPILE) == 0) { |
|
3464 |
strip_compile = STR_TF(value); |
|
3465 |
} else if (strcmp(prop, UNPACK_STRIP_DEBUG) == 0) { |
|
3466 |
strip_debug = STR_TF(value); |
|
3467 |
} else if (strcmp(prop, UNPACK_STRIP_JCOV) == 0) { |
|
3468 |
strip_jcov = STR_TF(value); |
|
3469 |
#endif /*HAVE_STRIP*/ |
|
3470 |
} else if (strcmp(prop, UNPACK_REMOVE_PACKFILE) == 0) { |
|
3471 |
remove_packfile = STR_TF(value); |
|
3472 |
} else if (strcmp(prop, DEBUG_VERBOSE) == 0) { |
|
3473 |
verbose = (value == null)? 0: atoi(value); |
|
3474 |
} else if (strcmp(prop, DEBUG_VERBOSE ".bands") == 0) { |
|
3475 |
#ifndef PRODUCT |
|
3476 |
verbose_bands = (value == null)? 0: atoi(value); |
|
3477 |
#endif |
|
3478 |
} else if (strcmp(prop, UNPACK_MODIFICATION_TIME) == 0) { |
|
3479 |
if (value == null || (strcmp(value, "keep") == 0)) { |
|
3480 |
modification_time_or_zero = 0; |
|
3481 |
} else if (strcmp(value, "now") == 0) { |
|
3482 |
time_t now; |
|
3483 |
time(&now); |
|
3484 |
modification_time_or_zero = (int) now; |
|
3485 |
} else { |
|
3486 |
modification_time_or_zero = atoi(value); |
|
3487 |
if (modification_time_or_zero == 0) |
|
3488 |
modification_time_or_zero = 1; // make non-zero |
|
3489 |
} |
|
3490 |
} else if (strcmp(prop, UNPACK_LOG_FILE) == 0) { |
|
3491 |
log_file = (value == null)? value: saveStr(value); |
|
3492 |
} else { |
|
3493 |
return false; // unknown option ignore |
|
3494 |
} |
|
3495 |
return true; |
|
3496 |
} |
|
3497 |
||
3498 |
// Deallocate all internal storage and reset to a clean state. |
|
3499 |
// Do not disturb any input or output connections, including |
|
3500 |
// infileptr, infileno, inbytes, read_input_fn, jarout, or errstrm. |
|
3501 |
// Do not reset any unpack options. |
|
3502 |
void unpacker::reset() { |
|
3503 |
bytes_read_before_reset += bytes_read; |
|
3504 |
bytes_written_before_reset += bytes_written; |
|
3505 |
files_written_before_reset += files_written; |
|
3506 |
classes_written_before_reset += classes_written; |
|
3507 |
segments_read_before_reset += 1; |
|
3508 |
if (verbose >= 2) { |
|
3509 |
fprintf(errstrm, |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3510 |
"After segment %d, " |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3511 |
LONG_LONG_FORMAT " bytes read and " |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3512 |
LONG_LONG_FORMAT " bytes written.\n", |
2 | 3513 |
segments_read_before_reset-1, |
3514 |
bytes_read_before_reset, bytes_written_before_reset); |
|
3515 |
fprintf(errstrm, |
|
3516 |
"After segment %d, %d files (of which %d are classes) written to output.\n", |
|
3517 |
segments_read_before_reset-1, |
|
3518 |
files_written_before_reset, classes_written_before_reset); |
|
3519 |
if (archive_next_count != 0) { |
|
3520 |
fprintf(errstrm, |
|
3521 |
"After segment %d, %d segment%s remaining (estimated).\n", |
|
3522 |
segments_read_before_reset-1, |
|
3523 |
archive_next_count, archive_next_count==1?"":"s"); |
|
3524 |
} |
|
3525 |
} |
|
3526 |
||
3527 |
unpacker save_u = (*this); // save bytewise image |
|
3528 |
infileptr = null; // make asserts happy |
|
3529 |
jniobj = null; // make asserts happy |
|
3530 |
jarout = null; // do not close the output jar |
|
3531 |
gzin = null; // do not close the input gzip stream |
|
3532 |
bytes esn; |
|
3533 |
if (errstrm_name != null) { |
|
3534 |
esn.saveFrom(errstrm_name); |
|
3535 |
} else { |
|
3536 |
esn.set(null, 0); |
|
3537 |
} |
|
3538 |
this->free(); |
|
3539 |
mtrace('s', 0, 0); // note the boundary between segments |
|
3540 |
this->init(read_input_fn); |
|
3541 |
||
3542 |
// restore selected interface state: |
|
3543 |
#define SAVE(x) this->x = save_u.x |
|
3544 |
SAVE(jniobj); |
|
3545 |
SAVE(jnienv); |
|
3546 |
SAVE(infileptr); // buffered |
|
3547 |
SAVE(infileno); // unbuffered |
|
3548 |
SAVE(inbytes); // direct |
|
3549 |
SAVE(jarout); |
|
3550 |
SAVE(gzin); |
|
3551 |
//SAVE(read_input_fn); |
|
3552 |
SAVE(errstrm); |
|
3553 |
SAVE(verbose); // verbose level, 0 means no output |
|
3554 |
SAVE(strip_compile); |
|
3555 |
SAVE(strip_debug); |
|
3556 |
SAVE(strip_jcov); |
|
3557 |
SAVE(remove_packfile); |
|
3558 |
SAVE(deflate_hint_or_zero); // ==0 means not set, otherwise -1 or 1 |
|
3559 |
SAVE(modification_time_or_zero); |
|
3560 |
SAVE(bytes_read_before_reset); |
|
3561 |
SAVE(bytes_written_before_reset); |
|
3562 |
SAVE(files_written_before_reset); |
|
3563 |
SAVE(classes_written_before_reset); |
|
3564 |
SAVE(segments_read_before_reset); |
|
3565 |
#undef SAVE |
|
3566 |
if (esn.len > 0) { |
|
3567 |
errstrm_name = saveStr(esn.strval()); |
|
3568 |
esn.free(); |
|
3569 |
} |
|
3570 |
log_file = errstrm_name; |
|
3571 |
// Note: If we use strip_names, watch out: They get nuked here. |
|
3572 |
} |
|
3573 |
||
3574 |
void unpacker::init(read_input_fn_t input_fn) { |
|
3575 |
int i; |
|
3576 |
NOT_PRODUCT(debug_u = this); |
|
3577 |
BYTES_OF(*this).clear(); |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3578 |
#ifndef PRODUCT |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3579 |
free(); // just to make sure freeing is idempotent |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3580 |
#endif |
2 | 3581 |
this->u = this; // self-reference for U_NEW macro |
3582 |
errstrm = stdout; // default error-output |
|
3583 |
log_file = LOGFILE_STDOUT; |
|
3584 |
read_input_fn = input_fn; |
|
3585 |
all_bands = band::makeBands(this); |
|
3586 |
// Make a default jar buffer; caller may safely overwrite it. |
|
3587 |
jarout = U_NEW(jar, 1); |
|
3588 |
jarout->init(this); |
|
3589 |
for (i = 0; i < ATTR_CONTEXT_LIMIT; i++) |
|
3590 |
attr_defs[i].u = u; // set up outer ptr |
|
3591 |
} |
|
3592 |
||
3593 |
const char* unpacker::get_abort_message() { |
|
3594 |
return abort_message; |
|
3595 |
} |
|
3596 |
||
3597 |
void unpacker::dump_options() { |
|
3598 |
static const char* opts[] = { |
|
3599 |
UNPACK_LOG_FILE, |
|
3600 |
UNPACK_DEFLATE_HINT, |
|
3601 |
#ifdef HAVE_STRIP |
|
3602 |
UNPACK_STRIP_COMPILE, |
|
3603 |
UNPACK_STRIP_DEBUG, |
|
3604 |
UNPACK_STRIP_JCOV, |
|
3605 |
#endif /*HAVE_STRIP*/ |
|
3606 |
UNPACK_REMOVE_PACKFILE, |
|
3607 |
DEBUG_VERBOSE, |
|
3608 |
UNPACK_MODIFICATION_TIME, |
|
3609 |
null |
|
3610 |
}; |
|
3611 |
for (int i = 0; opts[i] != null; i++) { |
|
3612 |
const char* str = get_option(opts[i]); |
|
3613 |
if (str == null) { |
|
3614 |
if (verbose == 0) continue; |
|
3615 |
str = "(not set)"; |
|
3616 |
} |
|
3617 |
fprintf(errstrm, "%s=%s\n", opts[i], str); |
|
3618 |
} |
|
3619 |
} |
|
3620 |
||
3621 |
||
3622 |
// Usage: unpack a byte buffer |
|
3623 |
// packptr is a reference to byte buffer containing a |
|
3624 |
// packed file and len is the length of the buffer. |
|
3625 |
// If null, the callback is used to fill an internal buffer. |
|
3626 |
void unpacker::start(void* packptr, size_t len) { |
|
3627 |
NOT_PRODUCT(debug_u = this); |
|
3628 |
if (packptr != null && len != 0) { |
|
3629 |
inbytes.set((byte*) packptr, len); |
|
3630 |
} |
|
3631 |
read_bands(); |
|
3632 |
} |
|
3633 |
||
3634 |
void unpacker::check_options() { |
|
3635 |
const char* strue = "true"; |
|
3636 |
const char* sfalse = "false"; |
|
3637 |
if (deflate_hint_or_zero != 0) { |
|
3638 |
bool force_deflate_hint = (deflate_hint_or_zero > 0); |
|
3639 |
if (force_deflate_hint) |
|
3640 |
default_file_options |= FO_DEFLATE_HINT; |
|
3641 |
else |
|
3642 |
default_file_options &= ~FO_DEFLATE_HINT; |
|
3643 |
// Turn off per-file deflate hint by force. |
|
3644 |
suppress_file_options |= FO_DEFLATE_HINT; |
|
3645 |
} |
|
3646 |
if (modification_time_or_zero != 0) { |
|
3647 |
default_file_modtime = modification_time_or_zero; |
|
3648 |
// Turn off per-file modtime by force. |
|
3649 |
archive_options &= ~AO_HAVE_FILE_MODTIME; |
|
3650 |
} |
|
3651 |
// %%% strip_compile, etc... |
|
3652 |
} |
|
3653 |
||
3654 |
// classfile writing |
|
3655 |
||
3656 |
void unpacker::reset_cur_classfile() { |
|
3657 |
// set defaults |
|
3658 |
cur_class_minver = default_class_minver; |
|
3659 |
cur_class_majver = default_class_majver; |
|
3660 |
||
3661 |
// reset constant pool state |
|
3662 |
cp.resetOutputIndexes(); |
|
3663 |
||
3664 |
// reset fixups |
|
3665 |
class_fixup_type.empty(); |
|
3666 |
class_fixup_offset.empty(); |
|
3667 |
class_fixup_ref.empty(); |
|
3668 |
requested_ics.empty(); |
|
3669 |
} |
|
3670 |
||
3671 |
cpindex* cpool::getKQIndex() { |
|
3672 |
char ch = '?'; |
|
3673 |
if (u->cur_descr != null) { |
|
3674 |
entry* type = u->cur_descr->descrType(); |
|
3675 |
ch = type->value.b.ptr[0]; |
|
3676 |
} |
|
3677 |
byte tag = CONSTANT_Integer; |
|
3678 |
switch (ch) { |
|
3679 |
case 'L': tag = CONSTANT_String; break; |
|
3680 |
case 'I': tag = CONSTANT_Integer; break; |
|
3681 |
case 'J': tag = CONSTANT_Long; break; |
|
3682 |
case 'F': tag = CONSTANT_Float; break; |
|
3683 |
case 'D': tag = CONSTANT_Double; break; |
|
3684 |
case 'B': case 'S': case 'C': |
|
3685 |
case 'Z': tag = CONSTANT_Integer; break; |
|
3686 |
default: abort("bad KQ reference"); break; |
|
3687 |
} |
|
3688 |
return getIndex(tag); |
|
3689 |
} |
|
3690 |
||
3691 |
uint unpacker::to_bci(uint bii) { |
|
3692 |
uint len = bcimap.length(); |
|
3693 |
uint* map = (uint*) bcimap.base(); |
|
3694 |
assert(len > 0); // must be initialized before using to_bci |
|
3695 |
if (bii < len) |
|
3696 |
return map[bii]; |
|
3697 |
// Else it's a fractional or out-of-range BCI. |
|
3698 |
uint key = bii-len; |
|
3699 |
for (int i = len; ; i--) { |
|
3700 |
if (map[i-1]-(i-1) <= key) |
|
3701 |
break; |
|
3702 |
else |
|
3703 |
--bii; |
|
3704 |
} |
|
3705 |
return bii; |
|
3706 |
} |
|
3707 |
||
3708 |
void unpacker::put_stackmap_type() { |
|
3709 |
int tag = code_StackMapTable_T.getByte(); |
|
3710 |
putu1(tag); |
|
3711 |
switch (tag) { |
|
3712 |
case 7: // (7) [RCH] |
|
3713 |
putref(code_StackMapTable_RC.getRef()); |
|
3714 |
break; |
|
3715 |
case 8: // (8) [PH] |
|
3716 |
putu2(to_bci(code_StackMapTable_P.getInt())); |
|
3717 |
break; |
|
3718 |
} |
|
3719 |
} |
|
3720 |
||
3721 |
// Functions for writing code. |
|
3722 |
||
3723 |
maybe_inline |
|
3724 |
void unpacker::put_label(int curIP, int size) { |
|
3725 |
code_fixup_type.addByte(size); |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3726 |
code_fixup_offset.add((int)put_empty(size)); |
2 | 3727 |
code_fixup_source.add(curIP); |
3728 |
} |
|
3729 |
||
3730 |
inline // called exactly once => inline |
|
3731 |
void unpacker::write_bc_ops() { |
|
3732 |
bcimap.empty(); |
|
3733 |
code_fixup_type.empty(); |
|
3734 |
code_fixup_offset.empty(); |
|
3735 |
code_fixup_source.empty(); |
|
3736 |
||
3737 |
band* bc_which; |
|
3738 |
||
3739 |
byte* opptr = bc_codes.curRP(); |
|
3740 |
// No need for oplimit, since the codes are pre-counted. |
|
3741 |
||
3742 |
size_t codeBase = wpoffset(); |
|
3743 |
||
3744 |
bool isAload; // copy-out result |
|
3745 |
int origBC; |
|
3746 |
||
3747 |
entry* thisClass = cur_class; |
|
3748 |
entry* superClass = cur_super; |
|
3749 |
entry* newClass = null; // class of last _new opcode |
|
3750 |
||
3751 |
// overwrite any prior index on these bands; it changes w/ current class: |
|
3752 |
bc_thisfield.setIndex( cp.getFieldIndex( thisClass)); |
|
3753 |
bc_thismethod.setIndex( cp.getMethodIndex(thisClass)); |
|
3754 |
if (superClass != null) { |
|
3755 |
bc_superfield.setIndex( cp.getFieldIndex( superClass)); |
|
3756 |
bc_supermethod.setIndex(cp.getMethodIndex(superClass)); |
|
3757 |
} else { |
|
3758 |
NOT_PRODUCT(bc_superfield.setIndex(null)); |
|
3759 |
NOT_PRODUCT(bc_supermethod.setIndex(null)); |
|
3760 |
} |
|
3761 |
||
3762 |
for (int curIP = 0; ; curIP++) { |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3763 |
int curPC = (int)(wpoffset() - codeBase); |
2 | 3764 |
bcimap.add(curPC); |
3765 |
ensure_put_space(10); // covers most instrs w/o further bounds check |
|
3766 |
int bc = *opptr++ & 0xFF; |
|
3767 |
||
3768 |
putu1_fast(bc); |
|
3769 |
// Note: See '--wp' below for pseudo-bytecodes like bc_end_marker. |
|
3770 |
||
3771 |
bool isWide = false; |
|
3772 |
if (bc == bc_wide) { |
|
3773 |
bc = *opptr++ & 0xFF; |
|
3774 |
putu1_fast(bc); |
|
3775 |
isWide = true; |
|
3776 |
} |
|
3777 |
switch (bc) { |
|
3778 |
case bc_end_marker: |
|
3779 |
--wp; // not really part of the code |
|
3780 |
assert(opptr <= bc_codes.maxRP()); |
|
3781 |
bc_codes.curRP() = opptr; // advance over this in bc_codes |
|
3782 |
goto doneScanningMethod; |
|
3783 |
case bc_tableswitch: // apc: (df, lo, hi, (hi-lo+1)*(label)) |
|
3784 |
case bc_lookupswitch: // apc: (df, nc, nc*(case, label)) |
|
3785 |
{ |
|
3786 |
int caseCount = bc_case_count.getInt(); |
|
3787 |
while (((wpoffset() - codeBase) % 4) != 0) putu1_fast(0); |
|
3788 |
ensure_put_space(30 + caseCount*8); |
|
3789 |
put_label(curIP, 4); //int df = bc_label.getInt(); |
|
3790 |
if (bc == bc_tableswitch) { |
|
3791 |
int lo = bc_case_value.getInt(); |
|
3792 |
int hi = lo + caseCount-1; |
|
3793 |
putu4(lo); |
|
3794 |
putu4(hi); |
|
3795 |
for (int j = 0; j < caseCount; j++) { |
|
3796 |
put_label(curIP, 4); //int lVal = bc_label.getInt(); |
|
3797 |
//int cVal = lo + j; |
|
3798 |
} |
|
3799 |
} else { |
|
3800 |
putu4(caseCount); |
|
3801 |
for (int j = 0; j < caseCount; j++) { |
|
3802 |
int cVal = bc_case_value.getInt(); |
|
3803 |
putu4(cVal); |
|
3804 |
put_label(curIP, 4); //int lVal = bc_label.getInt(); |
|
3805 |
} |
|
3806 |
} |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3807 |
assert((int)to_bci(curIP) == curPC); |
2 | 3808 |
continue; |
3809 |
} |
|
3810 |
case bc_iinc: |
|
3811 |
{ |
|
3812 |
int local = bc_local.getInt(); |
|
3813 |
int delta = (isWide ? bc_short : bc_byte).getInt(); |
|
3814 |
if (isWide) { |
|
3815 |
putu2(local); |
|
3816 |
putu2(delta); |
|
3817 |
} else { |
|
3818 |
putu1_fast(local); |
|
3819 |
putu1_fast(delta); |
|
3820 |
} |
|
3821 |
continue; |
|
3822 |
} |
|
3823 |
case bc_sipush: |
|
3824 |
{ |
|
3825 |
int val = bc_short.getInt(); |
|
3826 |
putu2(val); |
|
3827 |
continue; |
|
3828 |
} |
|
3829 |
case bc_bipush: |
|
3830 |
case bc_newarray: |
|
3831 |
{ |
|
3832 |
int val = bc_byte.getByte(); |
|
3833 |
putu1_fast(val); |
|
3834 |
continue; |
|
3835 |
} |
|
3836 |
case bc_ref_escape: |
|
3837 |
{ |
|
3838 |
// Note that insnMap has one entry for this. |
|
3839 |
--wp; // not really part of the code |
|
3840 |
int size = bc_escrefsize.getInt(); |
|
3841 |
entry* ref = bc_escref.getRefN(); |
|
3842 |
CHECK; |
|
3843 |
switch (size) { |
|
3844 |
case 1: putu1ref(ref); break; |
|
3845 |
case 2: putref(ref); break; |
|
3846 |
default: assert(false); |
|
3847 |
} |
|
3848 |
continue; |
|
3849 |
} |
|
3850 |
case bc_byte_escape: |
|
3851 |
{ |
|
3852 |
// Note that insnMap has one entry for all these bytes. |
|
3853 |
--wp; // not really part of the code |
|
3854 |
int size = bc_escsize.getInt(); |
|
3855 |
ensure_put_space(size); |
|
3856 |
for (int j = 0; j < size; j++) |
|
3857 |
putu1_fast(bc_escbyte.getByte()); |
|
3858 |
continue; |
|
3859 |
} |
|
3860 |
default: |
|
3861 |
if (is_invoke_init_op(bc)) { |
|
3862 |
origBC = bc_invokespecial; |
|
3863 |
entry* classRef; |
|
3864 |
switch (bc - _invokeinit_op) { |
|
3865 |
case _invokeinit_self_option: classRef = thisClass; break; |
|
3866 |
case _invokeinit_super_option: classRef = superClass; break; |
|
3867 |
default: assert(bc == _invokeinit_op+_invokeinit_new_option); |
|
3868 |
case _invokeinit_new_option: classRef = newClass; break; |
|
3869 |
} |
|
3870 |
wp[-1] = origBC; // overwrite with origBC |
|
3871 |
int coding = bc_initref.getInt(); |
|
3872 |
// Find the nth overloading of <init> in classRef. |
|
3873 |
entry* ref = null; |
|
3874 |
cpindex* ix = (classRef == null)? null: cp.getMethodIndex(classRef); |
|
3875 |
for (int j = 0, which_init = 0; ; j++) { |
|
3876 |
ref = (ix == null)? null: ix->get(j); |
|
3877 |
if (ref == null) break; // oops, bad input |
|
3878 |
assert(ref->tag == CONSTANT_Methodref); |
|
3879 |
if (ref->memberDescr()->descrName() == cp.sym[cpool::s_lt_init_gt]) { |
|
3880 |
if (which_init++ == coding) break; |
|
3881 |
} |
|
3882 |
} |
|
3883 |
putref(ref); |
|
3884 |
continue; |
|
3885 |
} |
|
3886 |
bc_which = ref_band_for_self_op(bc, isAload, origBC); |
|
3887 |
if (bc_which != null) { |
|
3888 |
if (!isAload) { |
|
3889 |
wp[-1] = origBC; // overwrite with origBC |
|
3890 |
} else { |
|
3891 |
wp[-1] = bc_aload_0; // overwrite with _aload_0 |
|
3892 |
// Note: insnMap keeps the _aload_0 separate. |
|
3893 |
bcimap.add(++curPC); |
|
3894 |
++curIP; |
|
3895 |
putu1_fast(origBC); |
|
3896 |
} |
|
3897 |
entry* ref = bc_which->getRef(); |
|
3898 |
CHECK; |
|
3899 |
putref(ref); |
|
3900 |
continue; |
|
3901 |
} |
|
3902 |
if (is_branch_op(bc)) { |
|
3903 |
//int lVal = bc_label.getInt(); |
|
3904 |
if (bc < bc_goto_w) { |
|
3905 |
put_label(curIP, 2); //putu2(lVal & 0xFFFF); |
|
3906 |
} else { |
|
3907 |
assert(bc <= bc_jsr_w); |
|
3908 |
put_label(curIP, 4); //putu4(lVal); |
|
3909 |
} |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3910 |
assert((int)to_bci(curIP) == curPC); |
2 | 3911 |
continue; |
3912 |
} |
|
3913 |
bc_which = ref_band_for_op(bc); |
|
3914 |
if (bc_which != null) { |
|
3915 |
entry* ref = bc_which->getRefCommon(bc_which->ix, bc_which->nullOK); |
|
3916 |
CHECK; |
|
3917 |
if (ref == null && bc_which == &bc_classref) { |
|
3918 |
// Shorthand for class self-references. |
|
3919 |
ref = thisClass; |
|
3920 |
} |
|
3921 |
origBC = bc; |
|
3922 |
switch (bc) { |
|
3923 |
case bc_ildc: |
|
3924 |
case bc_cldc: |
|
3925 |
case bc_fldc: |
|
3926 |
case bc_aldc: |
|
3927 |
origBC = bc_ldc; |
|
3928 |
break; |
|
3929 |
case bc_ildc_w: |
|
3930 |
case bc_cldc_w: |
|
3931 |
case bc_fldc_w: |
|
3932 |
case bc_aldc_w: |
|
3933 |
origBC = bc_ldc_w; |
|
3934 |
break; |
|
3935 |
case bc_lldc2_w: |
|
3936 |
case bc_dldc2_w: |
|
3937 |
origBC = bc_ldc2_w; |
|
3938 |
break; |
|
3939 |
case bc_new: |
|
3940 |
newClass = ref; |
|
3941 |
break; |
|
3942 |
} |
|
3943 |
wp[-1] = origBC; // overwrite with origBC |
|
3944 |
if (origBC == bc_ldc) { |
|
3945 |
putu1ref(ref); |
|
3946 |
} else { |
|
3947 |
putref(ref); |
|
3948 |
} |
|
3949 |
if (origBC == bc_multianewarray) { |
|
3950 |
// Copy the trailing byte also. |
|
3951 |
int val = bc_byte.getByte(); |
|
3952 |
putu1_fast(val); |
|
3953 |
} else if (origBC == bc_invokeinterface) { |
|
3954 |
int argSize = ref->memberDescr()->descrType()->typeSize(); |
|
3955 |
putu1_fast(1 + argSize); |
|
3956 |
putu1_fast(0); |
|
3957 |
} |
|
3958 |
continue; |
|
3959 |
} |
|
3960 |
if (is_local_slot_op(bc)) { |
|
3961 |
int local = bc_local.getInt(); |
|
3962 |
if (isWide) { |
|
3963 |
putu2(local); |
|
3964 |
if (bc == bc_iinc) { |
|
3965 |
int iVal = bc_short.getInt(); |
|
3966 |
putu2(iVal); |
|
3967 |
} |
|
3968 |
} else { |
|
3969 |
putu1_fast(local); |
|
3970 |
if (bc == bc_iinc) { |
|
3971 |
int iVal = bc_byte.getByte(); |
|
3972 |
putu1_fast(iVal); |
|
3973 |
} |
|
3974 |
} |
|
3975 |
continue; |
|
3976 |
} |
|
3977 |
// Random bytecode. Just copy it. |
|
3978 |
assert(bc < bc_bytecode_limit); |
|
3979 |
} |
|
3980 |
} |
|
3981 |
doneScanningMethod:{} |
|
3982 |
//bcimap.add(curPC); // PC limit is already also in map, from bc_end_marker |
|
3983 |
||
3984 |
// Armed with a bcimap, we can now fix up all the labels. |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
3985 |
for (int i = 0; i < (int)code_fixup_type.size(); i++) { |
2 | 3986 |
int type = code_fixup_type.getByte(i); |
3987 |
byte* bp = wp_at(code_fixup_offset.get(i)); |
|
3988 |
int curIP = code_fixup_source.get(i); |
|
3989 |
int destIP = curIP + bc_label.getInt(); |
|
3990 |
int span = to_bci(destIP) - to_bci(curIP); |
|
3991 |
switch (type) { |
|
3992 |
case 2: putu2_at(bp, (ushort)span); break; |
|
3993 |
case 4: putu4_at(bp, span); break; |
|
3994 |
default: assert(false); |
|
3995 |
} |
|
3996 |
} |
|
3997 |
} |
|
3998 |
||
3999 |
inline // called exactly once => inline |
|
4000 |
void unpacker::write_code() { |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
4001 |
int j; |
2 | 4002 |
|
4003 |
int max_stack, max_locals, handler_count, cflags; |
|
4004 |
get_code_header(max_stack, max_locals, handler_count, cflags); |
|
4005 |
||
4006 |
if (max_stack < 0) max_stack = code_max_stack.getInt(); |
|
4007 |
if (max_locals < 0) max_locals = code_max_na_locals.getInt(); |
|
4008 |
if (handler_count < 0) handler_count = code_handler_count.getInt(); |
|
4009 |
||
4010 |
int siglen = cur_descr->descrType()->typeSize(); |
|
4011 |
CHECK; |
|
4012 |
if ((cur_descr_flags & ACC_STATIC) == 0) siglen++; |
|
4013 |
max_locals += siglen; |
|
4014 |
||
4015 |
putu2(max_stack); |
|
4016 |
putu2(max_locals); |
|
4017 |
size_t bcbase = put_empty(4); |
|
4018 |
||
4019 |
// Write the bytecodes themselves. |
|
4020 |
write_bc_ops(); |
|
4021 |
CHECK; |
|
4022 |
||
4023 |
byte* bcbasewp = wp_at(bcbase); |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
4024 |
putu4_at(bcbasewp, (int)(wp - (bcbasewp+4))); // size of code attr |
2 | 4025 |
|
4026 |
putu2(handler_count); |
|
4027 |
for (j = 0; j < handler_count; j++) { |
|
4028 |
int bii = code_handler_start_P.getInt(); |
|
4029 |
putu2(to_bci(bii)); |
|
4030 |
bii += code_handler_end_PO.getInt(); |
|
4031 |
putu2(to_bci(bii)); |
|
4032 |
bii += code_handler_catch_PO.getInt(); |
|
4033 |
putu2(to_bci(bii)); |
|
4034 |
putref(code_handler_class_RCN.getRefN()); |
|
4035 |
CHECK; |
|
4036 |
} |
|
4037 |
||
4038 |
julong indexBits = cflags; |
|
4039 |
if (cflags < 0) { |
|
4040 |
bool haveLongFlags = attr_defs[ATTR_CONTEXT_CODE].haveLongFlags(); |
|
4041 |
indexBits = code_flags_hi.getLong(code_flags_lo, haveLongFlags); |
|
4042 |
} |
|
4043 |
write_attrs(ATTR_CONTEXT_CODE, indexBits); |
|
4044 |
} |
|
4045 |
||
4046 |
int unpacker::write_attrs(int attrc, julong indexBits) { |
|
4047 |
CHECK_0; |
|
4048 |
if (indexBits == 0) { |
|
4049 |
// Quick short-circuit. |
|
4050 |
putu2(0); |
|
4051 |
return 0; |
|
4052 |
} |
|
4053 |
||
4054 |
attr_definitions& ad = attr_defs[attrc]; |
|
4055 |
||
4056 |
int i, j, j2, idx, count; |
|
4057 |
||
4058 |
int oiCount = 0; |
|
4059 |
if (ad.isPredefined(X_ATTR_OVERFLOW) |
|
4060 |
&& (indexBits & ((julong)1<<X_ATTR_OVERFLOW)) != 0) { |
|
4061 |
indexBits -= ((julong)1<<X_ATTR_OVERFLOW); |
|
4062 |
oiCount = ad.xxx_attr_count().getInt(); |
|
4063 |
} |
|
4064 |
||
4065 |
int bitIndexes[X_ATTR_LIMIT_FLAGS_HI]; |
|
4066 |
int biCount = 0; |
|
4067 |
||
4068 |
// Fill bitIndexes with index bits, in order. |
|
4069 |
for (idx = 0; indexBits != 0; idx++, indexBits >>= 1) { |
|
4070 |
if ((indexBits & 1) != 0) |
|
4071 |
bitIndexes[biCount++] = idx; |
|
4072 |
} |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
4073 |
assert(biCount <= (int)lengthof(bitIndexes)); |
2 | 4074 |
|
4075 |
// Write a provisional attribute count, perhaps to be corrected later. |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
4076 |
int naOffset = (int)wpoffset(); |
2 | 4077 |
int na0 = biCount + oiCount; |
4078 |
putu2(na0); |
|
4079 |
||
4080 |
int na = 0; |
|
4081 |
for (i = 0; i < na0; i++) { |
|
4082 |
if (i < biCount) |
|
4083 |
idx = bitIndexes[i]; |
|
4084 |
else |
|
4085 |
idx = ad.xxx_attr_indexes().getInt(); |
|
4086 |
assert(ad.isIndex(idx)); |
|
4087 |
entry* aname = null; |
|
4088 |
entry* ref; // scratch |
|
4089 |
size_t abase = put_empty(2+4); |
|
4090 |
CHECK_0; |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
4091 |
if (idx < (int)ad.flag_limit && ad.isPredefined(idx)) { |
2 | 4092 |
// Switch on the attrc and idx simultaneously. |
4093 |
switch (ADH_BYTE(attrc, idx)) { |
|
4094 |
||
4095 |
case ADH_BYTE(ATTR_CONTEXT_CLASS, X_ATTR_OVERFLOW): |
|
4096 |
case ADH_BYTE(ATTR_CONTEXT_FIELD, X_ATTR_OVERFLOW): |
|
4097 |
case ADH_BYTE(ATTR_CONTEXT_METHOD, X_ATTR_OVERFLOW): |
|
4098 |
case ADH_BYTE(ATTR_CONTEXT_CODE, X_ATTR_OVERFLOW): |
|
4099 |
// no attribute at all, so back up on this one |
|
4100 |
wp = wp_at(abase); |
|
4101 |
continue; |
|
4102 |
||
4103 |
case ADH_BYTE(ATTR_CONTEXT_CLASS, CLASS_ATTR_ClassFile_version): |
|
4104 |
cur_class_minver = class_ClassFile_version_minor_H.getInt(); |
|
4105 |
cur_class_majver = class_ClassFile_version_major_H.getInt(); |
|
4106 |
// back up; not a real attribute |
|
4107 |
wp = wp_at(abase); |
|
4108 |
continue; |
|
4109 |
||
4110 |
case ADH_BYTE(ATTR_CONTEXT_CLASS, CLASS_ATTR_InnerClasses): |
|
4111 |
// note the existence of this attr, but save for later |
|
4112 |
if (cur_class_has_local_ics) |
|
4113 |
abort("too many InnerClasses attrs"); |
|
4114 |
cur_class_has_local_ics = true; |
|
4115 |
wp = wp_at(abase); |
|
4116 |
continue; |
|
4117 |
||
4118 |
case ADH_BYTE(ATTR_CONTEXT_CLASS, CLASS_ATTR_SourceFile): |
|
4119 |
aname = cp.sym[cpool::s_SourceFile]; |
|
4120 |
ref = class_SourceFile_RUN.getRefN(); |
|
4121 |
CHECK_0; |
|
4122 |
if (ref == null) { |
|
4123 |
bytes& n = cur_class->ref(0)->value.b; |
|
4124 |
// parse n = (<pkg>/)*<outer>?($<id>)* |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
4125 |
int pkglen = lastIndexOf(SLASH_MIN, SLASH_MAX, n, (int)n.len)+1; |
2 | 4126 |
bytes prefix = n.slice(pkglen, n.len); |
4127 |
for (;;) { |
|
4128 |
// Work backwards, finding all '$', '#', etc. |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
4129 |
int dollar = lastIndexOf(DOLLAR_MIN, DOLLAR_MAX, prefix, (int)prefix.len); |
2 | 4130 |
if (dollar < 0) break; |
4131 |
prefix = prefix.slice(0, dollar); |
|
4132 |
} |
|
4133 |
const char* suffix = ".java"; |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
4134 |
int len = (int)(prefix.len + strlen(suffix)); |
5191
79b41f733e33
6902299: Java JAR "unpack200" must verify input parameters
ksrini
parents:
3463
diff
changeset
|
4135 |
bytes name; name.set(T_NEW(byte, add_size(len, 1)), len); |
2 | 4136 |
name.strcat(prefix).strcat(suffix); |
4137 |
ref = cp.ensureUtf8(name); |
|
4138 |
} |
|
4139 |
putref(ref); |
|
4140 |
break; |
|
4141 |
||
4142 |
case ADH_BYTE(ATTR_CONTEXT_CLASS, CLASS_ATTR_EnclosingMethod): |
|
4143 |
aname = cp.sym[cpool::s_EnclosingMethod]; |
|
4144 |
putref(class_EnclosingMethod_RC.getRefN()); |
|
4145 |
putref(class_EnclosingMethod_RDN.getRefN()); |
|
4146 |
break; |
|
4147 |
||
4148 |
case ADH_BYTE(ATTR_CONTEXT_FIELD, FIELD_ATTR_ConstantValue): |
|
4149 |
aname = cp.sym[cpool::s_ConstantValue]; |
|
4150 |
putref(field_ConstantValue_KQ.getRefUsing(cp.getKQIndex())); |
|
4151 |
break; |
|
4152 |
||
4153 |
case ADH_BYTE(ATTR_CONTEXT_METHOD, METHOD_ATTR_Code): |
|
4154 |
aname = cp.sym[cpool::s_Code]; |
|
4155 |
write_code(); |
|
4156 |
break; |
|
4157 |
||
4158 |
case ADH_BYTE(ATTR_CONTEXT_METHOD, METHOD_ATTR_Exceptions): |
|
4159 |
aname = cp.sym[cpool::s_Exceptions]; |
|
4160 |
putu2(count = method_Exceptions_N.getInt()); |
|
4161 |
for (j = 0; j < count; j++) { |
|
4162 |
putref(method_Exceptions_RC.getRefN()); |
|
4163 |
} |
|
4164 |
break; |
|
4165 |
||
4166 |
case ADH_BYTE(ATTR_CONTEXT_CODE, CODE_ATTR_StackMapTable): |
|
4167 |
aname = cp.sym[cpool::s_StackMapTable]; |
|
4168 |
// (keep this code aligned with its brother in unpacker::read_attrs) |
|
4169 |
putu2(count = code_StackMapTable_N.getInt()); |
|
4170 |
for (j = 0; j < count; j++) { |
|
4171 |
int tag = code_StackMapTable_frame_T.getByte(); |
|
4172 |
putu1(tag); |
|
4173 |
if (tag <= 127) { |
|
4174 |
// (64-127) [(2)] |
|
4175 |
if (tag >= 64) put_stackmap_type(); |
|
4176 |
} else if (tag <= 251) { |
|
4177 |
// (247) [(1)(2)] |
|
4178 |
// (248-251) [(1)] |
|
4179 |
if (tag >= 247) putu2(code_StackMapTable_offset.getInt()); |
|
4180 |
if (tag == 247) put_stackmap_type(); |
|
4181 |
} else if (tag <= 254) { |
|
4182 |
// (252) [(1)(2)] |
|
4183 |
// (253) [(1)(2)(2)] |
|
4184 |
// (254) [(1)(2)(2)(2)] |
|
4185 |
putu2(code_StackMapTable_offset.getInt()); |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
4186 |
for (int k = (tag - 251); k > 0; k--) { |
2 | 4187 |
put_stackmap_type(); |
4188 |
} |
|
4189 |
} else { |
|
4190 |
// (255) [(1)NH[(2)]NH[(2)]] |
|
4191 |
putu2(code_StackMapTable_offset.getInt()); |
|
4192 |
putu2(j2 = code_StackMapTable_local_N.getInt()); |
|
4193 |
while (j2-- > 0) put_stackmap_type(); |
|
4194 |
putu2(j2 = code_StackMapTable_stack_N.getInt()); |
|
4195 |
while (j2-- > 0) put_stackmap_type(); |
|
4196 |
} |
|
4197 |
} |
|
4198 |
break; |
|
4199 |
||
4200 |
case ADH_BYTE(ATTR_CONTEXT_CODE, CODE_ATTR_LineNumberTable): |
|
4201 |
aname = cp.sym[cpool::s_LineNumberTable]; |
|
4202 |
putu2(count = code_LineNumberTable_N.getInt()); |
|
4203 |
for (j = 0; j < count; j++) { |
|
4204 |
putu2(to_bci(code_LineNumberTable_bci_P.getInt())); |
|
4205 |
putu2(code_LineNumberTable_line.getInt()); |
|
4206 |
} |
|
4207 |
break; |
|
4208 |
||
4209 |
case ADH_BYTE(ATTR_CONTEXT_CODE, CODE_ATTR_LocalVariableTable): |
|
4210 |
aname = cp.sym[cpool::s_LocalVariableTable]; |
|
4211 |
putu2(count = code_LocalVariableTable_N.getInt()); |
|
4212 |
for (j = 0; j < count; j++) { |
|
4213 |
int bii = code_LocalVariableTable_bci_P.getInt(); |
|
4214 |
int bci = to_bci(bii); |
|
4215 |
putu2(bci); |
|
4216 |
bii += code_LocalVariableTable_span_O.getInt(); |
|
4217 |
putu2(to_bci(bii) - bci); |
|
4218 |
putref(code_LocalVariableTable_name_RU.getRefN()); |
|
4219 |
putref(code_LocalVariableTable_type_RS.getRefN()); |
|
4220 |
putu2(code_LocalVariableTable_slot.getInt()); |
|
4221 |
} |
|
4222 |
break; |
|
4223 |
||
4224 |
case ADH_BYTE(ATTR_CONTEXT_CODE, CODE_ATTR_LocalVariableTypeTable): |
|
4225 |
aname = cp.sym[cpool::s_LocalVariableTypeTable]; |
|
4226 |
putu2(count = code_LocalVariableTypeTable_N.getInt()); |
|
4227 |
for (j = 0; j < count; j++) { |
|
4228 |
int bii = code_LocalVariableTypeTable_bci_P.getInt(); |
|
4229 |
int bci = to_bci(bii); |
|
4230 |
putu2(bci); |
|
4231 |
bii += code_LocalVariableTypeTable_span_O.getInt(); |
|
4232 |
putu2(to_bci(bii) - bci); |
|
4233 |
putref(code_LocalVariableTypeTable_name_RU.getRefN()); |
|
4234 |
putref(code_LocalVariableTypeTable_type_RS.getRefN()); |
|
4235 |
putu2(code_LocalVariableTypeTable_slot.getInt()); |
|
4236 |
} |
|
4237 |
break; |
|
4238 |
||
4239 |
case ADH_BYTE(ATTR_CONTEXT_CLASS, X_ATTR_Signature): |
|
4240 |
aname = cp.sym[cpool::s_Signature]; |
|
4241 |
putref(class_Signature_RS.getRefN()); |
|
4242 |
break; |
|
4243 |
||
4244 |
case ADH_BYTE(ATTR_CONTEXT_FIELD, X_ATTR_Signature): |
|
4245 |
aname = cp.sym[cpool::s_Signature]; |
|
4246 |
putref(field_Signature_RS.getRefN()); |
|
4247 |
break; |
|
4248 |
||
4249 |
case ADH_BYTE(ATTR_CONTEXT_METHOD, X_ATTR_Signature): |
|
4250 |
aname = cp.sym[cpool::s_Signature]; |
|
4251 |
putref(method_Signature_RS.getRefN()); |
|
4252 |
break; |
|
4253 |
||
4254 |
case ADH_BYTE(ATTR_CONTEXT_CLASS, X_ATTR_Deprecated): |
|
4255 |
case ADH_BYTE(ATTR_CONTEXT_FIELD, X_ATTR_Deprecated): |
|
4256 |
case ADH_BYTE(ATTR_CONTEXT_METHOD, X_ATTR_Deprecated): |
|
4257 |
aname = cp.sym[cpool::s_Deprecated]; |
|
4258 |
// no data |
|
4259 |
break; |
|
4260 |
} |
|
4261 |
} |
|
4262 |
||
4263 |
if (aname == null) { |
|
4264 |
// Unparse a compressor-defined attribute. |
|
4265 |
layout_definition* lo = ad.getLayout(idx); |
|
4266 |
if (lo == null) { |
|
4267 |
abort("bad layout index"); |
|
4268 |
break; |
|
4269 |
} |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
4270 |
assert((int)lo->idx == idx); |
2 | 4271 |
aname = lo->nameEntry; |
4272 |
if (aname == null) { |
|
4273 |
bytes nameb; nameb.set(lo->name); |
|
4274 |
aname = cp.ensureUtf8(nameb); |
|
4275 |
// Cache the name entry for next time. |
|
4276 |
lo->nameEntry = aname; |
|
4277 |
} |
|
4278 |
// Execute all the layout elements. |
|
4279 |
band** bands = lo->bands(); |
|
4280 |
if (lo->hasCallables()) { |
|
4281 |
band& cble = *bands[0]; |
|
4282 |
assert(cble.le_kind == EK_CBLE); |
|
4283 |
bands = cble.le_body; |
|
4284 |
} |
|
4285 |
putlayout(bands); |
|
4286 |
} |
|
4287 |
||
4288 |
if (aname == null) |
|
4289 |
abort("bad attribute index"); |
|
4290 |
CHECK_0; |
|
4291 |
||
4292 |
byte* wp1 = wp; |
|
4293 |
wp = wp_at(abase); |
|
4294 |
||
4295 |
// DTRT if this attr is on the strip-list. |
|
4296 |
// (Note that we emptied the data out of the band first.) |
|
4297 |
if (ad.strip_names.contains(aname)) { |
|
4298 |
continue; |
|
4299 |
} |
|
4300 |
||
4301 |
// patch the name and length |
|
4302 |
putref(aname); |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
4303 |
putu4((int)(wp1 - (wp+4))); // put the attr size |
2 | 4304 |
wp = wp1; |
4305 |
na++; // count the attrs actually written |
|
4306 |
} |
|
4307 |
||
4308 |
if (na != na0) |
|
4309 |
// Refresh changed count. |
|
4310 |
putu2_at(wp_at(naOffset), na); |
|
4311 |
return na; |
|
4312 |
} |
|
4313 |
||
4314 |
void unpacker::write_members(int num, int attrc) { |
|
4315 |
CHECK; |
|
4316 |
attr_definitions& ad = attr_defs[attrc]; |
|
4317 |
band& member_flags_hi = ad.xxx_flags_hi(); |
|
4318 |
band& member_flags_lo = ad.xxx_flags_lo(); |
|
4319 |
band& member_descr = (&member_flags_hi)[e_field_descr-e_field_flags_hi]; |
|
4320 |
assert(endsWith(member_descr.name, "_descr")); |
|
4321 |
assert(endsWith(member_flags_lo.name, "_flags_lo")); |
|
4322 |
assert(endsWith(member_flags_lo.name, "_flags_lo")); |
|
4323 |
bool haveLongFlags = ad.haveLongFlags(); |
|
4324 |
||
4325 |
putu2(num); |
|
4326 |
julong indexMask = attr_defs[attrc].flagIndexMask(); |
|
4327 |
for (int i = 0; i < num; i++) { |
|
4328 |
julong mflags = member_flags_hi.getLong(member_flags_lo, haveLongFlags); |
|
4329 |
entry* mdescr = member_descr.getRef(); |
|
4330 |
cur_descr = mdescr; |
|
4331 |
putu2(cur_descr_flags = (ushort)(mflags & ~indexMask)); |
|
4332 |
CHECK; |
|
4333 |
putref(mdescr->descrName()); |
|
4334 |
putref(mdescr->descrType()); |
|
4335 |
write_attrs(attrc, (mflags & indexMask)); |
|
4336 |
CHECK; |
|
4337 |
} |
|
4338 |
cur_descr = null; |
|
4339 |
} |
|
4340 |
||
4341 |
extern "C" |
|
4342 |
int raw_address_cmp(const void* p1p, const void* p2p) { |
|
4343 |
void* p1 = *(void**) p1p; |
|
4344 |
void* p2 = *(void**) p2p; |
|
4345 |
return (p1 > p2)? 1: (p1 < p2)? -1: 0; |
|
4346 |
} |
|
4347 |
||
4348 |
void unpacker::write_classfile_tail() { |
|
4349 |
cur_classfile_tail.empty(); |
|
4350 |
set_output(&cur_classfile_tail); |
|
4351 |
||
4352 |
int i, num; |
|
4353 |
||
4354 |
attr_definitions& ad = attr_defs[ATTR_CONTEXT_CLASS]; |
|
4355 |
||
4356 |
bool haveLongFlags = ad.haveLongFlags(); |
|
4357 |
julong kflags = class_flags_hi.getLong(class_flags_lo, haveLongFlags); |
|
4358 |
julong indexMask = ad.flagIndexMask(); |
|
4359 |
||
4360 |
cur_class = class_this.getRef(); |
|
4361 |
cur_super = class_super.getRef(); |
|
4362 |
||
4363 |
CHECK; |
|
4364 |
||
4365 |
if (cur_super == cur_class) cur_super = null; |
|
4366 |
// special representation for java/lang/Object |
|
4367 |
||
4368 |
putu2((ushort)(kflags & ~indexMask)); |
|
4369 |
putref(cur_class); |
|
4370 |
putref(cur_super); |
|
4371 |
||
4372 |
putu2(num = class_interface_count.getInt()); |
|
4373 |
for (i = 0; i < num; i++) { |
|
4374 |
putref(class_interface.getRef()); |
|
4375 |
} |
|
4376 |
||
4377 |
write_members(class_field_count.getInt(), ATTR_CONTEXT_FIELD); |
|
4378 |
write_members(class_method_count.getInt(), ATTR_CONTEXT_METHOD); |
|
4379 |
CHECK; |
|
4380 |
||
4381 |
cur_class_has_local_ics = false; // may be set true by write_attrs |
|
4382 |
||
4383 |
||
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
4384 |
int naOffset = (int)wpoffset(); |
2 | 4385 |
int na = write_attrs(ATTR_CONTEXT_CLASS, (kflags & indexMask)); |
4386 |
||
4387 |
||
4388 |
// at the very last, choose which inner classes (if any) pertain to k: |
|
4389 |
#ifdef ASSERT |
|
4390 |
for (i = 0; i < ic_count; i++) { |
|
4391 |
assert(!ics[i].requested); |
|
4392 |
} |
|
4393 |
#endif |
|
4394 |
// First, consult the global table and the local constant pool, |
|
4395 |
// and decide on the globally implied inner classes. |
|
4396 |
// (Note that we read the cpool's outputIndex fields, but we |
|
4397 |
// do not yet write them, since the local IC attribute might |
|
4398 |
// reverse a global decision to declare an IC.) |
|
4399 |
assert(requested_ics.length() == 0); // must start out empty |
|
4400 |
// Always include all members of the current class. |
|
4401 |
for (inner_class* child = cp.getFirstChildIC(cur_class); |
|
4402 |
child != null; |
|
4403 |
child = cp.getNextChildIC(child)) { |
|
4404 |
child->requested = true; |
|
4405 |
requested_ics.add(child); |
|
4406 |
} |
|
4407 |
// And, for each inner class mentioned in the constant pool, |
|
4408 |
// include it and all its outers. |
|
4409 |
int noes = cp.outputEntries.length(); |
|
4410 |
entry** oes = (entry**) cp.outputEntries.base(); |
|
4411 |
for (i = 0; i < noes; i++) { |
|
4412 |
entry& e = *oes[i]; |
|
4413 |
if (e.tag != CONSTANT_Class) continue; // wrong sort |
|
4414 |
for (inner_class* ic = cp.getIC(&e); |
|
4415 |
ic != null; |
|
4416 |
ic = cp.getIC(ic->outer)) { |
|
4417 |
if (ic->requested) break; // already processed |
|
4418 |
ic->requested = true; |
|
4419 |
requested_ics.add(ic); |
|
4420 |
} |
|
4421 |
} |
|
4422 |
int local_ics = requested_ics.length(); |
|
4423 |
// Second, consult a local attribute (if any) and adjust the global set. |
|
4424 |
inner_class* extra_ics = null; |
|
4425 |
int num_extra_ics = 0; |
|
4426 |
if (cur_class_has_local_ics) { |
|
4427 |
// adjust the set of ICs by symmetric set difference w/ the locals |
|
4428 |
num_extra_ics = class_InnerClasses_N.getInt(); |
|
4429 |
if (num_extra_ics == 0) { |
|
4430 |
// Explicit zero count has an irregular meaning: It deletes the attr. |
|
4431 |
local_ics = 0; // (short-circuit all tests of requested bits) |
|
4432 |
} else { |
|
4433 |
extra_ics = T_NEW(inner_class, num_extra_ics); |
|
4434 |
// Note: extra_ics will be freed up by next call to get_next_file(). |
|
4435 |
} |
|
4436 |
} |
|
4437 |
for (i = 0; i < num_extra_ics; i++) { |
|
4438 |
inner_class& extra_ic = extra_ics[i]; |
|
4439 |
extra_ic.inner = class_InnerClasses_RC.getRef(); |
|
4440 |
CHECK; |
|
4441 |
// Find the corresponding equivalent global IC: |
|
4442 |
inner_class* global_ic = cp.getIC(extra_ic.inner); |
|
4443 |
int flags = class_InnerClasses_F.getInt(); |
|
4444 |
if (flags == 0) { |
|
4445 |
// The extra IC is simply a copy of a global IC. |
|
4446 |
if (global_ic == null) { |
|
4447 |
abort("bad reference to inner class"); |
|
4448 |
break; |
|
4449 |
} |
|
4450 |
extra_ic = (*global_ic); // fill in rest of fields |
|
4451 |
} else { |
|
4452 |
flags &= ~ACC_IC_LONG_FORM; // clear high bit if set to get clean zero |
|
4453 |
extra_ic.flags = flags; |
|
4454 |
extra_ic.outer = class_InnerClasses_outer_RCN.getRefN(); |
|
4455 |
extra_ic.name = class_InnerClasses_name_RUN.getRefN(); |
|
4456 |
// Detect if this is an exact copy of the global tuple. |
|
4457 |
if (global_ic != null) { |
|
4458 |
if (global_ic->flags != extra_ic.flags || |
|
4459 |
global_ic->outer != extra_ic.outer || |
|
4460 |
global_ic->name != extra_ic.name) { |
|
4461 |
global_ic = null; // not really the same, so break the link |
|
4462 |
} |
|
4463 |
} |
|
4464 |
} |
|
4465 |
if (global_ic != null && global_ic->requested) { |
|
4466 |
// This local repetition reverses the globally implied request. |
|
4467 |
global_ic->requested = false; |
|
4468 |
extra_ic.requested = false; |
|
4469 |
local_ics -= 1; |
|
4470 |
} else { |
|
4471 |
// The global either does not exist, or is not yet requested. |
|
4472 |
extra_ic.requested = true; |
|
4473 |
local_ics += 1; |
|
4474 |
} |
|
4475 |
} |
|
4476 |
// Finally, if there are any that survived, put them into an attribute. |
|
4477 |
// (Note that a zero-count attribute is always deleted.) |
|
4478 |
// The putref calls below will tell the constant pool to add any |
|
4479 |
// necessary local CP references to support the InnerClasses attribute. |
|
4480 |
// This step must be the last round of additions to the local CP. |
|
4481 |
if (local_ics > 0) { |
|
4482 |
// append the new attribute: |
|
4483 |
putref(cp.sym[cpool::s_InnerClasses]); |
|
4484 |
putu4(2 + 2*4*local_ics); |
|
4485 |
putu2(local_ics); |
|
4486 |
PTRLIST_QSORT(requested_ics, raw_address_cmp); |
|
4487 |
int num_global_ics = requested_ics.length(); |
|
4488 |
for (i = -num_global_ics; i < num_extra_ics; i++) { |
|
4489 |
inner_class* ic; |
|
4490 |
if (i < 0) |
|
4491 |
ic = (inner_class*) requested_ics.get(num_global_ics+i); |
|
4492 |
else |
|
4493 |
ic = &extra_ics[i]; |
|
4494 |
if (ic->requested) { |
|
4495 |
putref(ic->inner); |
|
4496 |
putref(ic->outer); |
|
4497 |
putref(ic->name); |
|
4498 |
putu2(ic->flags); |
|
4499 |
NOT_PRODUCT(local_ics--); |
|
4500 |
} |
|
4501 |
} |
|
4502 |
assert(local_ics == 0); // must balance |
|
4503 |
putu2_at(wp_at(naOffset), ++na); // increment class attr count |
|
4504 |
} |
|
4505 |
||
4506 |
// Tidy up global 'requested' bits: |
|
4507 |
for (i = requested_ics.length(); --i >= 0; ) { |
|
4508 |
inner_class* ic = (inner_class*) requested_ics.get(i); |
|
4509 |
ic->requested = false; |
|
4510 |
} |
|
4511 |
requested_ics.empty(); |
|
4512 |
||
4513 |
CHECK; |
|
4514 |
close_output(); |
|
4515 |
||
4516 |
// rewrite CP references in the tail |
|
4517 |
cp.computeOutputIndexes(); |
|
4518 |
int nextref = 0; |
|
4519 |
for (i = 0; i < (int)class_fixup_type.size(); i++) { |
|
4520 |
int type = class_fixup_type.getByte(i); |
|
4521 |
byte* fixp = wp_at(class_fixup_offset.get(i)); |
|
4522 |
entry* e = (entry*)class_fixup_ref.get(nextref++); |
|
4523 |
int idx = e->getOutputIndex(); |
|
4524 |
switch (type) { |
|
4525 |
case 1: putu1_at(fixp, idx); break; |
|
4526 |
case 2: putu2_at(fixp, idx); break; |
|
4527 |
default: assert(false); // should not reach here |
|
4528 |
} |
|
4529 |
} |
|
4530 |
CHECK; |
|
4531 |
} |
|
4532 |
||
4533 |
void unpacker::write_classfile_head() { |
|
4534 |
cur_classfile_head.empty(); |
|
4535 |
set_output(&cur_classfile_head); |
|
4536 |
||
4537 |
putu4(JAVA_MAGIC); |
|
4538 |
putu2(cur_class_minver); |
|
4539 |
putu2(cur_class_majver); |
|
4540 |
putu2(cp.outputIndexLimit); |
|
4541 |
||
4542 |
int checkIndex = 1; |
|
4543 |
int noes = cp.outputEntries.length(); |
|
4544 |
entry** oes = (entry**) cp.outputEntries.base(); |
|
4545 |
for (int i = 0; i < noes; i++) { |
|
4546 |
entry& e = *oes[i]; |
|
4547 |
assert(e.getOutputIndex() == checkIndex++); |
|
4548 |
byte tag = e.tag; |
|
4549 |
assert(tag != CONSTANT_Signature); |
|
4550 |
putu1(tag); |
|
4551 |
switch (tag) { |
|
4552 |
case CONSTANT_Utf8: |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
4553 |
putu2((int)e.value.b.len); |
2 | 4554 |
put_bytes(e.value.b); |
4555 |
break; |
|
4556 |
case CONSTANT_Integer: |
|
4557 |
case CONSTANT_Float: |
|
4558 |
putu4(e.value.i); |
|
4559 |
break; |
|
4560 |
case CONSTANT_Long: |
|
4561 |
case CONSTANT_Double: |
|
4562 |
putu8(e.value.l); |
|
4563 |
assert(checkIndex++); |
|
4564 |
break; |
|
4565 |
case CONSTANT_Class: |
|
4566 |
case CONSTANT_String: |
|
4567 |
// just write the ref |
|
4568 |
putu2(e.refs[0]->getOutputIndex()); |
|
4569 |
break; |
|
4570 |
case CONSTANT_Fieldref: |
|
4571 |
case CONSTANT_Methodref: |
|
4572 |
case CONSTANT_InterfaceMethodref: |
|
4573 |
case CONSTANT_NameandType: |
|
4574 |
putu2(e.refs[0]->getOutputIndex()); |
|
4575 |
putu2(e.refs[1]->getOutputIndex()); |
|
4576 |
break; |
|
4577 |
default: |
|
4578 |
abort(ERROR_INTERNAL); |
|
4579 |
} |
|
4580 |
} |
|
4581 |
||
4582 |
#ifndef PRODUCT |
|
4583 |
total_cp_size[0] += cp.outputIndexLimit; |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
4584 |
total_cp_size[1] += (int)cur_classfile_head.size(); |
2 | 4585 |
#endif |
4586 |
close_output(); |
|
4587 |
} |
|
4588 |
||
4589 |
unpacker::file* unpacker::get_next_file() { |
|
4590 |
CHECK_0; |
|
4591 |
free_temps(); |
|
4592 |
if (files_remaining == 0) { |
|
4593 |
// Leave a clue that we're exhausted. |
|
4594 |
cur_file.name = null; |
|
4595 |
cur_file.size = null; |
|
4596 |
if (archive_size != 0) { |
|
4597 |
julong predicted_size = unsized_bytes_read + archive_size; |
|
4598 |
if (predicted_size != bytes_read) |
|
4599 |
abort("archive header had incorrect size"); |
|
4600 |
} |
|
4601 |
return null; |
|
4602 |
} |
|
4603 |
files_remaining -= 1; |
|
4604 |
assert(files_written < file_count || classes_written < class_count); |
|
4605 |
cur_file.name = ""; |
|
4606 |
cur_file.size = 0; |
|
4607 |
cur_file.modtime = default_file_modtime; |
|
4608 |
cur_file.options = default_file_options; |
|
4609 |
cur_file.data[0].set(null, 0); |
|
4610 |
cur_file.data[1].set(null, 0); |
|
4611 |
if (files_written < file_count) { |
|
4612 |
entry* e = file_name.getRef(); |
|
4613 |
CHECK_0; |
|
4614 |
cur_file.name = e->utf8String(); |
|
4615 |
bool haveLongSize = ((archive_options & AO_HAVE_FILE_SIZE_HI) != 0); |
|
4616 |
cur_file.size = file_size_hi.getLong(file_size_lo, haveLongSize); |
|
4617 |
if ((archive_options & AO_HAVE_FILE_MODTIME) != 0) |
|
4618 |
cur_file.modtime += file_modtime.getInt(); //relative to archive modtime |
|
4619 |
if ((archive_options & AO_HAVE_FILE_OPTIONS) != 0) |
|
4620 |
cur_file.options |= file_options.getInt() & ~suppress_file_options; |
|
4621 |
} else if (classes_written < class_count) { |
|
4622 |
// there is a class for a missing file record |
|
4623 |
cur_file.options |= FO_IS_CLASS_STUB; |
|
4624 |
} |
|
4625 |
if ((cur_file.options & FO_IS_CLASS_STUB) != 0) { |
|
4626 |
assert(classes_written < class_count); |
|
4627 |
classes_written += 1; |
|
4628 |
if (cur_file.size != 0) { |
|
4629 |
abort("class file size transmitted"); |
|
4630 |
return null; |
|
4631 |
} |
|
4632 |
reset_cur_classfile(); |
|
4633 |
||
4634 |
// write the meat of the classfile: |
|
4635 |
write_classfile_tail(); |
|
4636 |
cur_file.data[1] = cur_classfile_tail.b; |
|
4637 |
CHECK_0; |
|
4638 |
||
4639 |
// write the CP of the classfile, second: |
|
4640 |
write_classfile_head(); |
|
4641 |
cur_file.data[0] = cur_classfile_head.b; |
|
4642 |
CHECK_0; |
|
4643 |
||
4644 |
cur_file.size += cur_file.data[0].len; |
|
4645 |
cur_file.size += cur_file.data[1].len; |
|
4646 |
if (cur_file.name[0] == '\0') { |
|
4647 |
bytes& prefix = cur_class->ref(0)->value.b; |
|
4648 |
const char* suffix = ".class"; |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
4649 |
int len = (int)(prefix.len + strlen(suffix)); |
5191
79b41f733e33
6902299: Java JAR "unpack200" must verify input parameters
ksrini
parents:
3463
diff
changeset
|
4650 |
bytes name; name.set(T_NEW(byte, add_size(len, 1)), len); |
2 | 4651 |
cur_file.name = name.strcat(prefix).strcat(suffix).strval(); |
4652 |
} |
|
4653 |
} else { |
|
4654 |
// If there is buffered file data, produce a pointer to it. |
|
4655 |
if (cur_file.size != (size_t) cur_file.size) { |
|
4656 |
// Silly size specified. |
|
4657 |
abort("resource file too large"); |
|
4658 |
return null; |
|
4659 |
} |
|
4660 |
size_t rpleft = input_remaining(); |
|
4661 |
if (rpleft > 0) { |
|
4662 |
if (rpleft > cur_file.size) |
|
4663 |
rpleft = (size_t) cur_file.size; |
|
4664 |
cur_file.data[0].set(rp, rpleft); |
|
4665 |
rp += rpleft; |
|
4666 |
} |
|
4667 |
if (rpleft < cur_file.size) { |
|
4668 |
// Caller must read the rest. |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
4669 |
size_t fleft = (size_t)cur_file.size - rpleft; |
2 | 4670 |
bytes_read += fleft; // Credit it to the overall archive size. |
4671 |
} |
|
4672 |
} |
|
4673 |
CHECK_0; |
|
4674 |
bytes_written += cur_file.size; |
|
4675 |
files_written += 1; |
|
4676 |
return &cur_file; |
|
4677 |
} |
|
4678 |
||
4679 |
// Write a file to jarout. |
|
4680 |
void unpacker::write_file_to_jar(unpacker::file* f) { |
|
4681 |
size_t htsize = f->data[0].len + f->data[1].len; |
|
4682 |
julong fsize = f->size; |
|
4683 |
#ifndef PRODUCT |
|
4684 |
if (nowrite NOT_PRODUCT(|| skipfiles-- > 0)) { |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
4685 |
PRINTCR((2,"would write %d bytes to %s", (int) fsize, f->name)); |
2 | 4686 |
return; |
4687 |
} |
|
4688 |
#endif |
|
4689 |
if (htsize == fsize) { |
|
4690 |
jarout->addJarEntry(f->name, f->deflate_hint(), f->modtime, |
|
4691 |
f->data[0], f->data[1]); |
|
4692 |
} else { |
|
4693 |
assert(input_remaining() == 0); |
|
4694 |
bytes part1, part2; |
|
4695 |
part1.len = f->data[0].len; |
|
4696 |
part1.set(T_NEW(byte, part1.len), part1.len); |
|
4697 |
part1.copyFrom(f->data[0]); |
|
4698 |
assert(f->data[1].len == 0); |
|
4699 |
part2.set(null, 0); |
|
4700 |
size_t fleft = (size_t) fsize - part1.len; |
|
4701 |
assert(bytes_read > fleft); // part2 already credited by get_next_file |
|
4702 |
bytes_read -= fleft; |
|
4703 |
if (fleft > 0) { |
|
4704 |
// Must read some more. |
|
4705 |
if (live_input) { |
|
4706 |
// Stop using the input buffer. Make a new one: |
|
4707 |
if (free_input) input.free(); |
|
4708 |
input.init(fleft > (1<<12) ? fleft : (1<<12)); |
|
4709 |
free_input = true; |
|
4710 |
live_input = false; |
|
4711 |
} else { |
|
4712 |
// Make it large enough. |
|
4713 |
assert(free_input); // must be reallocable |
|
4714 |
input.ensureSize(fleft); |
|
4715 |
} |
|
4716 |
rplimit = rp = input.base(); |
|
5191
79b41f733e33
6902299: Java JAR "unpack200" must verify input parameters
ksrini
parents:
3463
diff
changeset
|
4717 |
CHECK; |
2 | 4718 |
input.setLimit(rp + fleft); |
4719 |
if (!ensure_input(fleft)) |
|
4720 |
abort("EOF reading resource file"); |
|
4721 |
part2.ptr = input_scan(); |
|
4722 |
part2.len = input_remaining(); |
|
4723 |
rplimit = rp = input.base(); |
|
4724 |
} |
|
4725 |
jarout->addJarEntry(f->name, f->deflate_hint(), f->modtime, |
|
4726 |
part1, part2); |
|
4727 |
} |
|
4728 |
if (verbose >= 3) { |
|
1082
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
4729 |
fprintf(errstrm, "Wrote " |
53833ff90c45
6496269: Many warnings generated from com/sun/java/util/jar/pack/*.cpp when compiled on Linux
ohair
parents:
2
diff
changeset
|
4730 |
LONG_LONG_FORMAT " bytes to: %s\n", fsize, f->name); |
2 | 4731 |
} |
4732 |
} |
|
4733 |
||
4734 |
// Redirect the stdio to the specified file in the unpack.log.file option |
|
4735 |
void unpacker::redirect_stdio() { |
|
4736 |
if (log_file == null) { |
|
4737 |
log_file = LOGFILE_STDOUT; |
|
4738 |
} |
|
4739 |
if (log_file == errstrm_name) |
|
4740 |
// Nothing more to be done. |
|
4741 |
return; |
|
4742 |
errstrm_name = log_file; |
|
4743 |
if (strcmp(log_file, LOGFILE_STDERR) == 0) { |
|
4744 |
errstrm = stderr; |
|
4745 |
return; |
|
4746 |
} else if (strcmp(log_file, LOGFILE_STDOUT) == 0) { |
|
4747 |
errstrm = stdout; |
|
4748 |
return; |
|
4749 |
} else if (log_file[0] != '\0' && (errstrm = fopen(log_file,"a+")) != NULL) { |
|
4750 |
return; |
|
4751 |
} else { |
|
4752 |
char log_file_name[PATH_MAX+100]; |
|
4753 |
char tmpdir[PATH_MAX]; |
|
4754 |
#ifdef WIN32 |
|
4755 |
int n = GetTempPath(PATH_MAX,tmpdir); //API returns with trailing '\' |
|
4756 |
if (n < 1 || n > PATH_MAX) { |
|
4757 |
sprintf(tmpdir,"C:\\"); |
|
4758 |
} |
|
4759 |
sprintf(log_file_name, "%sunpack.log", tmpdir); |
|
4760 |
#else |
|
4761 |
sprintf(tmpdir,"/tmp"); |
|
4762 |
sprintf(log_file_name, "/tmp/unpack.log"); |
|
4763 |
#endif |
|
4764 |
if ((errstrm = fopen(log_file_name, "a+")) != NULL) { |
|
4765 |
log_file = errstrm_name = saveStr(log_file_name); |
|
4766 |
return ; |
|
4767 |
} |
|
4768 |
||
4769 |
char *tname = tempnam(tmpdir,"#upkg"); |
|
4770 |
sprintf(log_file_name, "%s", tname); |
|
4771 |
if ((errstrm = fopen(log_file_name, "a+")) != NULL) { |
|
4772 |
log_file = errstrm_name = saveStr(log_file_name); |
|
4773 |
return ; |
|
4774 |
} |
|
4775 |
#ifndef WIN32 |
|
4776 |
sprintf(log_file_name, "/dev/null"); |
|
4777 |
// On windows most likely it will fail. |
|
4778 |
if ( (errstrm = fopen(log_file_name, "a+")) != NULL) { |
|
4779 |
log_file = errstrm_name = saveStr(log_file_name); |
|
4780 |
return ; |
|
4781 |
} |
|
4782 |
#endif |
|
4783 |
// Last resort |
|
4784 |
// (Do not use stdout, since it might be jarout->jarfp.) |
|
4785 |
errstrm = stderr; |
|
4786 |
log_file = errstrm_name = LOGFILE_STDERR; |
|
4787 |
} |
|
4788 |
} |
|
4789 |
||
4790 |
#ifndef PRODUCT |
|
4791 |
int unpacker::printcr_if_verbose(int level, const char* fmt ...) { |
|
4792 |
if (verbose < level+10) return 0; |
|
4793 |
va_list vl; |
|
4794 |
va_start(vl, fmt); |
|
4795 |
char fmtbuf[300]; |
|
4796 |
strcpy(fmtbuf+100, fmt); |
|
4797 |
strcat(fmtbuf+100, "\n"); |
|
4798 |
char* fmt2 = fmtbuf+100; |
|
4799 |
while (level-- > 0) *--fmt2 = ' '; |
|
4800 |
vfprintf(errstrm, fmt2, vl); |
|
4801 |
return 1; // for ?: usage |
|
4802 |
} |
|
4803 |
#endif |
|
4804 |
||
4805 |
void unpacker::abort(const char* message) { |
|
4806 |
if (message == null) message = "error unpacking archive"; |
|
4807 |
#ifdef UNPACK_JNI |
|
4808 |
if (message[0] == '@') { // secret convention for sprintf |
|
4809 |
bytes saved; |
|
4810 |
saved.saveFrom(message+1); |
|
4811 |
mallocs.add(message = saved.strval()); |
|
4812 |
} |
|
4813 |
abort_message = message; |
|
4814 |
return; |
|
4815 |
#else |
|
4816 |
if (message[0] == '@') ++message; |
|
4817 |
fprintf(errstrm, "%s\n", message); |
|
4818 |
#ifndef PRODUCT |
|
4819 |
fflush(errstrm); |
|
4820 |
::abort(); |
|
4821 |
#else |
|
4822 |
exit(-1); |
|
4823 |
#endif |
|
4824 |
#endif // JNI |
|
4825 |
} |