?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* src/pbc_merge.c:
[parrot.git] / src / pbc_merge.c
bloba02de91e0d86bae803385f8e3aa755bb353bf4a4
1 /*
2 Copyright (C) 2005-2008, The Perl Foundation.
3 $Id$
4
5 =head1 NAME
6
7 pbc_merge - Merge multiple Parrot bytecode (PBC) files into
8 a single PBC file.
9
10 =head1 SYNOPSIS
11
12 pbc_merge -o out.pbc input1.pbc input2.pbc ...
13
14 =head1 DESCRIPTION
15
16 This program takes two or more PBC files and produces a single
17 merged output PBC file with a single fix-up table and constants
18 table.
19
20 =head2 Command-Line Options
21
22 =over 4
23
24 =item C<-o out.pbc>
25
26 The name of the PBC file to produce, containing the merged
27 segments from the input PBC files.
28
29 =back
30
31 =head2 Functions
32
33 =over 4
34
35 =cut
36
37 */
38
39
40 #include "parrot/parrot.h"
41 #include "parrot/embed.h"
42 #include "parrot/oplib/ops.h"
43
44
45 /* This struct describes an input file. */
46 typedef struct pbc_merge_input {
47 const char *filename; /* Filename of the input file. */
48 PackFile *pf; /* The loaded packfile. */
49 opcode_t code_start; /* Where the bytecode is located in the merged
50 bytecode. */
51 opcode_t const_start; /* Where the const table is located in the merged
52 one. */
53 } pbc_merge_input;
54
55 /* HEADERIZER HFILE: none */
56
57 /* HEADERIZER BEGIN: static */
58 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END. Your changes will be lost. */
59
60 PARROT_DOES_NOT_RETURN
61 static void help(PARROT_INTERP)
62 __attribute__nonnull__(1);
63
64 PARROT_WARN_UNUSED_RESULT
65 PARROT_CANNOT_RETURN_NULL
66 static PackFile* pbc_merge_begin(PARROT_INTERP,
67 ARGMOD(pbc_merge_input **inputs),
68 int num_inputs)
69 __attribute__nonnull__(1)
70 __attribute__nonnull__(2)
71 FUNC_MODIFIES(*inputs);
72
73 PARROT_WARN_UNUSED_RESULT
74 PARROT_CANNOT_RETURN_NULL
75 static PackFile_ByteCode* pbc_merge_bytecode(PARROT_INTERP,
76 ARGMOD(pbc_merge_input **inputs),
77 int num_inputs,
78 ARGMOD(PackFile *pf))
79 __attribute__nonnull__(1)
80 __attribute__nonnull__(2)
81 __attribute__nonnull__(4)
82 FUNC_MODIFIES(*inputs)
83 FUNC_MODIFIES(*pf);
84
85 PARROT_WARN_UNUSED_RESULT
86 PARROT_CANNOT_RETURN_NULL
87 static PackFile_ConstTable* pbc_merge_constants(PARROT_INTERP,
88 ARGMOD(pbc_merge_input **inputs),
89 int num_inputs,
90 ARGMOD(PackFile *pf),
91 ARGMOD(PackFile_ByteCode *bc))
92 __attribute__nonnull__(1)
93 __attribute__nonnull__(2)
94 __attribute__nonnull__(4)
95 __attribute__nonnull__(5)
96 FUNC_MODIFIES(*inputs)
97 FUNC_MODIFIES(*pf)
98 FUNC_MODIFIES(*bc);
99
100 static void pbc_merge_ctpointers(PARROT_INTERP,
101 ARGMOD(pbc_merge_input **inputs),
102 int num_inputs,
103 ARGMOD(PackFile_ByteCode *bc))
104 __attribute__nonnull__(1)
105 __attribute__nonnull__(2)
106 __attribute__nonnull__(4)
107 FUNC_MODIFIES(*inputs)
108 FUNC_MODIFIES(*bc);
109
110 static void pbc_merge_debugs(PARROT_INTERP,
111 ARGMOD(pbc_merge_input **inputs),
112 int num_inputs,
113 ARGMOD(PackFile *pf),
114 ARGMOD(PackFile_ByteCode *bc))
115 __attribute__nonnull__(1)
116 __attribute__nonnull__(2)
117 __attribute__nonnull__(4)
118 __attribute__nonnull__(5)
119 FUNC_MODIFIES(*inputs)
120 FUNC_MODIFIES(*pf)
121 FUNC_MODIFIES(*bc);
122
123 static void pbc_merge_fixups(PARROT_INTERP,
124 ARGIN(pbc_merge_input **inputs),
125 int num_inputs,
126 ARGMOD(PackFile *pf),
127 ARGMOD(PackFile_ByteCode *bc))
128 __attribute__nonnull__(1)
129 __attribute__nonnull__(2)
130 __attribute__nonnull__(4)
131 __attribute__nonnull__(5)
132 FUNC_MODIFIES(*pf)
133 FUNC_MODIFIES(*bc);
134
135 PARROT_WARN_UNUSED_RESULT
136 PARROT_CANNOT_RETURN_NULL
137 static PackFile* pbc_merge_loadpbc(PARROT_INTERP,
138 ARGIN(const char *fullname))
139 __attribute__nonnull__(1)
140 __attribute__nonnull__(2);
141
142 static void pbc_merge_pic_index(PARROT_INTERP,
143 ARGMOD(pbc_merge_input **inputs),
144 int num_inputs,
145 ARGMOD(PackFile *pf),
146 ARGMOD(PackFile_ByteCode *bc))
147 __attribute__nonnull__(1)
148 __attribute__nonnull__(2)
149 __attribute__nonnull__(4)
150 __attribute__nonnull__(5)
151 FUNC_MODIFIES(*inputs)
152 FUNC_MODIFIES(*pf)
153 FUNC_MODIFIES(*bc);
154
155 static void pbc_merge_write(PARROT_INTERP,
156 ARGMOD(PackFile *pf),
157 ARGIN(const char *filename))
158 __attribute__nonnull__(1)
159 __attribute__nonnull__(2)
160 __attribute__nonnull__(3)
161 FUNC_MODIFIES(*pf);
162
163 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END. Your changes will be lost. */
164 /* HEADERIZER END: static */
165
166 /*
167
168 =item C<static void help>
169
170 Print out the user help info.
171
172 =cut
173
174 */
175
176 PARROT_DOES_NOT_RETURN
177 static void
178 help(PARROT_INTERP)
179 {
180 printf("pbc_merge - merge multiple parrot bytecode files into one\n");
181 printf("Usage:\n");
182 printf(" pbc_merge -o out.pbc file1.pbc file2.pbc ...\n\n");
183 Parrot_exit(interp, 0);
184 }
185
186 /*
187
188 =item C<static PackFile* pbc_merge_loadpbc>
189
190 This function loads a PBC file and unpacks it. We can't
191 use Parrot_readbc because that is specified to also
192 fixup the segments, which we don't want.
193
194 =cut
195
196 */
197
198 PARROT_WARN_UNUSED_RESULT
199 PARROT_CANNOT_RETURN_NULL
200 static PackFile*
201 pbc_merge_loadpbc(PARROT_INTERP, ARGIN(const char *fullname))
202 {
203 INTVAL program_size, wanted;
204 char *program_code;
205 PackFile *pf;
206 FILE * io = NULL;
207 INTVAL is_mapped = 0;
208 size_t chunk_size;
209 char *cursor;
210 INTVAL read_result;
211
212 /* Check the file exists. */
213 STRING * const fs = string_make(interp, fullname,
214 strlen(fullname), NULL, 0);
215 if (!Parrot_stat_info_intval(interp, fs, STAT_EXISTS)) {
216 PIO_eprintf(interp, "PBC Merge: Can't stat %s, code %i.\n",
217 fullname, errno);
218 Parrot_exit(interp, 1);
219 }
220
221 /* Get program size. */
222 program_size = Parrot_stat_info_intval(interp, fs, STAT_FILESIZE);
223
224 /* Attempt to open file and handle any errors. */
225 io = fopen(fullname, "rb");
226 if (!io) {
227 PIO_eprintf(interp, "PBC Merge: Can't open %s, code %i.\n",
228 fullname, errno);
229 Parrot_exit(interp, 1);
230 }
231
232 /* Read in program. Nabbed from Parrot_readpbc. */
233 chunk_size = program_size > 0 ? program_size : 1024;
234 program_code = (char *)mem_sys_allocate(chunk_size);
235 wanted = program_size;
236 program_size = 0;
237 cursor = (char *)program_code;
238
239 while ((read_result = fread(cursor, 1, chunk_size, io)) > 0) {
240 program_size += read_result;
241 if (program_size == wanted)
242 break;
243 chunk_size = 1024;
244 program_code =
245 (char *)mem_sys_realloc(program_code, program_size + chunk_size);
246
247 if (!program_code) {
248 PIO_eprintf(interp,
249 "PBC Merge: Could not reallocate buffer");
250 Parrot_exit(interp, 1);
251 }
252
253 cursor = (char *)program_code + program_size;
254 }
255
256 if (read_result < 0) {
257 PIO_eprintf(interp,
258 "PBC Merge: Problem reading packfile from PIO.\n");
259 Parrot_exit(interp, 1);
260 }
261 fclose(io);
262
263 /* Now that we have the bytecode, let's unpack it. */
264 pf = PackFile_new(interp, is_mapped);
265 if (!PackFile_unpack(interp,
266 pf, (opcode_t *)program_code, program_size)) {
267 PIO_eprintf(interp, "PBC Merge: Can't unpack packfile %s.\n",
268 fullname);
269 Parrot_exit(interp, 1);
270 }
271
272 /* Return the packfile. */
273 return pf;
274 }
275
276
277 /*
278
279 =item C<static PackFile_ByteCode* pbc_merge_bytecode>
280
281 This function merges the bytecode from the input packfiles, storing the
282 offsets that each bit of bytecode now exists at.
283
284 =cut
285
286 */
287
288 PARROT_WARN_UNUSED_RESULT
289 PARROT_CANNOT_RETURN_NULL
290 static PackFile_ByteCode*
291 pbc_merge_bytecode(PARROT_INTERP, ARGMOD(pbc_merge_input **inputs),
292 int num_inputs, ARGMOD(PackFile *pf))
293 {
294 opcode_t *bc = mem_allocate_typed(opcode_t);
295 opcode_t cursor = 0;
296 int i;
297
298 /* Add a bytecode segment. */
299 PackFile_ByteCode * const bc_seg =
300 (PackFile_ByteCode *)PackFile_Segment_new_seg(interp,
301 &pf->directory, PF_BYTEC_SEG, BYTE_CODE_SEGMENT_NAME, 1);
302 if (bc_seg == NULL) {
303 PIO_eprintf(interp, "PBC Merge: Error creating bytecode segment.");
304 Parrot_exit(interp, 1);
305 }
306
307 /* Loop over input files. */
308 for (i = 0; i < num_inputs; i++) {
309 /* Get the bytecode segment from the input file. */
310 PackFile_ByteCode * const in_seg = inputs[i]->pf->cur_cs;
311 if (in_seg == NULL) {
312 PIO_eprintf(interp,
313 "PBC Merge: Cannot locate bytecode segment in %s",
314 inputs[i]->filename);
315 Parrot_exit(interp, 1);
316 }
317
318 /* Re-allocate the current buffer. */
319 mem_realloc_n_typed(bc, cursor + in_seg->base.size, opcode_t);
320 if (bc == NULL) {
321 PIO_eprintf(interp, "PBC Merge: Cannot reallocate memory\n");
322 Parrot_exit(interp, 1);
323 }
324
325 /* Copy data and store cursor. */
326 memcpy(bc + cursor, in_seg->base.data,
327 in_seg->base.size * sizeof (opcode_t));
328 inputs[i]->code_start = cursor;
329
330 /* Update cursor. */
331 cursor += in_seg->base.size;
332 }
333
334 /* Stash produced bytecode. */
335 bc_seg->base.data = bc;
336 bc_seg->base.size = cursor;
337 bc_seg->base.name = str_dup("MERGED");
338 return bc_seg;
339 }
340
341
342 /*
343
344 =item C<static PackFile_ConstTable* pbc_merge_constants>
345
346 This function merges the constants tables from the input PBC files.
347
348 =cut
349
350 */
351
352 PARROT_WARN_UNUSED_RESULT
353 PARROT_CANNOT_RETURN_NULL
354 static PackFile_ConstTable*
355 pbc_merge_constants(PARROT_INTERP, ARGMOD(pbc_merge_input **inputs),
356 int num_inputs, ARGMOD(PackFile *pf), ARGMOD(PackFile_ByteCode *bc))
357 {
358 PackFile_Constant **constants = mem_allocate_typed(PackFile_Constant *);
359 opcode_t cursor = 0;
360 int i, j;
361
362 /* Add a constant table segment. */
363 PackFile_ConstTable * const const_seg = (PackFile_ConstTable*)PackFile_Segment_new_seg(
364 interp, &pf->directory, PF_CONST_SEG, CONSTANT_SEGMENT_NAME, 1);
365 if (const_seg == NULL) {
366 PIO_eprintf(interp,
367 "PBC Merge: Error creating constant table segment.");
368 Parrot_exit(interp, 1);
369 }
370
371 /* Loop over input files. */
372 for (i = 0; i < num_inputs; i++) {
373 /* Get the constant table segment from the input file. */
374 PackFile_ConstTable * const in_seg = inputs[i]->pf->cur_cs->const_table;
375 if (in_seg == NULL) {
376 PIO_eprintf(interp,
377 "PBC Merge: Cannot locate constant table segment in %s\n",
378 inputs[i]->filename);
379 Parrot_exit(interp, 1);
380 }
381
382 /* Store cursor as position where constant table starts. */
383 inputs[i]->const_start = cursor;
384
385 /* Allocate space for the constant list, provided we have some. */
386 if (in_seg->const_count > 0) {
387 constants = (PackFile_Constant **)mem_sys_realloc(constants,
388 (cursor + in_seg->const_count) * sizeof (Parrot_Pointer));
389 if (constants == NULL) {
390 PIO_eprintf(interp, "PBC Merge: Out of memory");
391 Parrot_exit(interp, 1);
392 }
393 }
394
395 /* Loop over the constants and copy them to the output PBC. */
396 for (j = 0; j < in_seg->const_count; j++) {
397 /* Get the entry and allocate space for copy. */
398 PackFile_Constant *cur_entry = in_seg->constants[j];
399 PackFile_Constant *copy = mem_allocate_typed(
400 PackFile_Constant);
401 if (copy == NULL) {
402 PIO_eprintf(interp, "PBC Merge: Out of memory");
403 Parrot_exit(interp, 1);
404 }
405
406 STRUCT_COPY(copy, cur_entry);
407
408 /* If it's a sub PMC, need to deal with offsets. */
409 if (copy->type == PFC_PMC) {
410 switch (copy->u.key->vtable->base_type) {
411 case enum_class_Sub:
412 case enum_class_Closure:
413 case enum_class_Coroutine:
414 {
415 Parrot_sub * const sub = PMC_sub(copy->u.key);
416 sub->start_offs += inputs[i]->code_start;
417 sub->end_offs += inputs[i]->code_start;
418 }
419 break;
420 default:
421 break;
422 }
423 }
424
425 /* Slot it into the list. */
426 constants[cursor] = copy;
427 cursor++;
428 }
429 }
430
431 /* Stash merged constants table and count and return the new segment. */
432 const_seg->constants = constants;
433 const_seg->const_count = cursor;
434 const_seg->code = bc;
435 bc->const_table = const_seg;
436 return const_seg;
437 }
438
439
440 /*
441
442 =item C<static void pbc_merge_fixups>
443
444 This function merges the fixups tables from the input PBC files.
445
446 =cut
447
448 */
449
450 static void
451 pbc_merge_fixups(PARROT_INTERP, ARGIN(pbc_merge_input **inputs),
452 int num_inputs, ARGMOD(PackFile *pf), ARGMOD(PackFile_ByteCode *bc))
453 {
454 PackFile_FixupTable *fixup_seg;
455 PackFile_FixupEntry **fixups = mem_allocate_typed(PackFile_FixupEntry *);
456 opcode_t cursor = 0;
457 int i, j;
458
459 /* Add a fixup table segment. */
460 fixup_seg = (PackFile_FixupTable*)PackFile_Segment_new_seg(
461 interp, &pf->directory, PF_FIXUP_SEG, FIXUP_TABLE_SEGMENT_NAME, 1);
462 if (fixup_seg == NULL) {
463 PIO_eprintf(interp,
464 "PBC Merge: Error creating fixup table segment.");
465 Parrot_exit(interp, 1);
466 }
467
468 /* Loop over input files. */
469 for (i = 0; i < num_inputs; i++) {
470 /* Get the fixup segment from the input file. */
471 PackFile_FixupTable * const in_seg = inputs[i]->pf->cur_cs->fixups;
472 if (in_seg == NULL) {
473 PIO_eprintf(interp,
474 "PBC Merge: Cannot locate fixup segment in %s",
475 inputs[i]->filename);
476 Parrot_exit(interp, 1);
477 }
478
479 /* Allocate space for these fixups, provided we have some. */
480 if (in_seg->fixup_count > 0) {
481 fixups = (PackFile_FixupEntry **)mem_sys_realloc(fixups,
482 (cursor + in_seg->fixup_count) * sizeof (Parrot_Pointer));
483 if (fixups == NULL) {
484 PIO_eprintf(interp, "PBC Merge: Out of memory");
485 Parrot_exit(interp, 1);
486 }
487 }
488
489 /* Loop over the fixups and copy them to the output PBC, correcting
490 the offsets into the bytecode. */
491 for (j = 0; j < in_seg->fixup_count; j++) {
492 /* Get the entry and allocate space for copies. */
493 PackFile_FixupEntry *cur_entry = in_seg->fixups[j];
494 PackFile_FixupEntry *copy = mem_allocate_typed(
495 PackFile_FixupEntry);
496 char *name_copy = (char *)mem_sys_allocate(
497 strlen(cur_entry->name) + 1);
498 if (copy == NULL || name_copy == NULL) {
499 PIO_eprintf(interp, "PBC Merge: Out of memory");
500 Parrot_exit(interp, 1);
501 }
502
503 /* Copy type and name. */
504 copy->type = cur_entry->type;
505 strcpy(name_copy, cur_entry->name);
506 copy->name = name_copy;
507
508 /* Set new offset and bytecode pointer. */
509 switch (copy->type) {
510 case enum_fixup_label:
511 copy->offset = cur_entry->offset + inputs[i]->code_start;
512 break;
513 case enum_fixup_sub:
514 copy->offset = cur_entry->offset + inputs[i]->const_start;
515 break;
516 default:
517 PIO_eprintf(interp, "PBC Merge: Unknown fixup type");
518 Parrot_exit(interp, 1);
519 }
520
521 copy->seg = bc;
522
523 /* Slot it into the list. */
524 fixups[cursor] = copy;
525 cursor++;
526 }
527 }
528
529 /* Stash merged fixup table and count. */
530 fixup_seg->fixups = fixups;
531 fixup_seg->fixup_count = cursor;
532 }
533
534
535 /*
536
537 =item C<static void pbc_merge_debugs>
538
539 This function merges the debug segments from the input PBC files.
540
541 =cut
542
543 */
544
545 static void
546 pbc_merge_debugs(PARROT_INTERP, ARGMOD(pbc_merge_input **inputs),
547 int num_inputs, ARGMOD(PackFile *pf), ARGMOD(PackFile_ByteCode *bc))
548 {
549 PackFile_Debug *debug_seg;
550 opcode_t *lines = mem_allocate_typed(opcode_t);
551 PackFile_DebugMapping **mappings =
552 mem_allocate_typed(PackFile_DebugMapping *);
553 opcode_t num_mappings = 0;
554 opcode_t num_lines = 0;
555 int i, j;
556
557 /* We need to merge both the mappings and the list of line numbers.
558 The line numbers can just be concatenated. The mappings must have
559 their offsets fixed up. */
560 for (i = 0; i < num_inputs; i++) {
561 PackFile_Debug *in_seg = inputs[i]->pf->cur_cs->debugs;
562
563 /* Concatenate line numbers. */
564 lines = (opcode_t *)mem_sys_realloc(lines,
565 (num_lines + in_seg->base.size) * sizeof (opcode_t));
566 if (lines == NULL) {
567 PIO_eprintf(interp, "PBC Merge: Cannot reallocate memory\n");
568 Parrot_exit(interp, 1);
569 }
570 memcpy(lines + num_lines, in_seg->base.data,
571 in_seg->base.size * sizeof (opcode_t));
572
573 /* Concatenate mappings. */
574 mappings = (PackFile_DebugMapping **)mem_sys_realloc(mappings,
575 (num_mappings + in_seg->num_mappings) *
576 sizeof (Parrot_Pointer));
577 for (j = 0; j < in_seg->num_mappings; j++) {
578 PackFile_DebugMapping *mapping = mem_allocate_typed(
579 PackFile_DebugMapping);
580 STRUCT_COPY(mapping, in_seg->mappings[j]);
581 mapping->offset += num_lines;
582 if (mapping->mapping_type == PF_DEBUGMAPPINGTYPE_FILENAME)
583 mapping->u.filename += inputs[i]->const_start;
584 mappings[num_mappings + j] = mapping;
585 }
586
587 /* Update counts. The "- 1" allows for the fact that the size value
588 itself is included in in_seg->base.size. See RT#58660. */
589 num_lines += in_seg->base.size - 1;
590 num_mappings += in_seg->num_mappings;
591 }
592
593 /* Create merged debug segment. Replace created data and mappings
594 with merged ones we have created. */
595 debug_seg = Parrot_new_debug_seg(interp, bc, num_lines);
596 PackFile_add_segment(interp, &pf->directory, (PackFile_Segment*)debug_seg);
597 mem_sys_free(debug_seg->base.data);
598 debug_seg->base.data = lines;
599 mem_sys_free(debug_seg->mappings);
600
601 debug_seg->mappings = mappings;
602 debug_seg->num_mappings = num_mappings;
603 }
604
605 /*
606
607 =item C<static void pbc_merge_pic_index>
608
609 This function merges the pic_index segments from the input PBC files.
610
611 =cut
612
613 */
614
615 static void
616 pbc_merge_pic_index(PARROT_INTERP, ARGMOD(pbc_merge_input **inputs),
617 int num_inputs, ARGMOD(PackFile *pf), ARGMOD(PackFile_ByteCode *bc))
618 {
619 int i;
620 PackFile_Segment *pic_index;
621 size_t size;
622 opcode_t cursor = 0;
623 opcode_t start = 0;
624 opcode_t last = 0;
625
626 /* calc needed size */
627 for (i = 0, size = 0; i < num_inputs; i++) {
628 PackFile_Segment * const in_seg = inputs[i]->pf->cur_cs->pic_index;
629 size += in_seg->size;
630 }
631 pic_index = PackFile_Segment_new_seg(interp,
632 &pf->directory, PF_UNKNOWN_SEG, "PIC_idx_MERGED", 1);
633 pic_index->data
634 = (opcode_t *)mem_sys_allocate_zeroed(size * sizeof (opcode_t));
635 pic_index->size = size;
636
637 for (i = 0, size = 0; i < num_inputs; i++) {
638 PackFile_Segment * const in_seg = inputs[i]->pf->cur_cs->pic_index;
639 size_t j;
640 /*
641 * pic_index is 0 or an ever increasing (by 1) number
642 */
643 for (j = 0; j < in_seg->size; j++) {
644 const opcode_t k = in_seg->data[j];
645 if (k) {
646 pic_index->data[cursor] = k + start;
647 last = k;
648 }
649 cursor++;
650 }
651 start = last;
652 }
653 bc->pic_index = pic_index;
654 }
655
656 /*
657
658 =item C<static void pbc_merge_ctpointers>
659
660 This function corrects the pointers into the constants table found in the
661 bytecode.
662
663 =cut
664
665 */
666
667 static void
668 pbc_merge_ctpointers(PARROT_INTERP, ARGMOD(pbc_merge_input **inputs),
669 int num_inputs, ARGMOD(PackFile_ByteCode *bc))
670 {
671 opcode_t *op_ptr;
672 opcode_t *ops = bc->base.data;
673 opcode_t cur_op = 0;
674 int cur_input = 0;
675 int cur_arg;
676
677 /* Loop over the ops in the merged bytecode. */
678 while (cur_op < (opcode_t)bc->base.size) {
679 op_info_t *op;
680 opcode_t op_num;
681
682 /* Keep track of the current input file. */
683 if (cur_input + 1 < num_inputs &&
684 cur_op >= inputs[cur_input + 1]->code_start)
685 cur_input++;
686
687 /* Get info about this op and jump over it. */
688 op_num = ops[cur_op];
689 op = &interp->op_info_table[op_num];
690 op_ptr = ops + cur_op;
691 cur_op++;
692
693 /* Loop over the arguments. */
694 for (cur_arg = 1; cur_arg < op->op_count; cur_arg++) {
695 /* Pick out any indexes into the constant table and correct them. */
696 switch (op->types[cur_arg - 1]) {
697 case PARROT_ARG_NC:
698 case PARROT_ARG_PC:
699 case PARROT_ARG_SC:
700 case PARROT_ARG_KC:
701 ops[cur_op] += inputs[cur_input]->const_start;
702 break;
703 default:
704 break;
705 }
706
707 /* Move along the bytecode array. */
708 cur_op++;
709 }
710
711 /* Handle special case variable argument opcodes. */
712 if (op_num == PARROT_OP_set_args_pc ||
713 op_num == PARROT_OP_get_results_pc ||
714 op_num == PARROT_OP_get_params_pc ||
715 op_num == PARROT_OP_set_returns_pc) {
716 /* Get the signature. */
717 const PMC * const sig = bc->const_table->constants[op_ptr[1]]->u.key;
718
719 /* Loop over the arguments to locate any that need a fixup. */
720 const int sig_items = SIG_ELEMS(sig);
721 for (cur_arg = 0; cur_arg < sig_items; cur_arg++) {
722 switch (SIG_ITEM(sig, cur_arg)) {
723 case PARROT_ARG_NC:
724 case PARROT_ARG_PC:
725 case PARROT_ARG_SC:
726 case PARROT_ARG_KC:
727 ops[cur_op] += inputs[cur_input]->const_start;
728 break;
729 default:
730 break;
731 }
732 cur_op++;
733 }
734 }
735 }
736 }
737
738
739 /*
740
741 =item C<static PackFile* pbc_merge_begin>
742
743 This is the function that drives PBC merging process.
744
745 =cut
746
747 */
748 PARROT_WARN_UNUSED_RESULT
749 PARROT_CANNOT_RETURN_NULL
750 static PackFile*
751 pbc_merge_begin(PARROT_INTERP, ARGMOD(pbc_merge_input **inputs), int num_inputs)
752 {
753 PackFile_ByteCode *bc;
754 PackFile_ConstTable *ct;
755
756 /* Create a new empty packfile. */
757 PackFile * const merged = PackFile_new(interp, 0);
758 if (merged == NULL) {
759 PIO_eprintf(interp, "PBC Merge: Error creating new packfile.\n");
760 Parrot_exit(interp, 1);
761 }
762
763 /* Merge the various stuff. */
764 bc = pbc_merge_bytecode(interp, inputs, num_inputs, merged);
765 ct = pbc_merge_constants(interp, inputs, num_inputs, merged, bc);
766 UNUSED(ct);
767
768 pbc_merge_fixups(interp, inputs, num_inputs, merged, bc);
769 pbc_merge_debugs(interp, inputs, num_inputs, merged, bc);
770 pbc_merge_pic_index(interp, inputs, num_inputs, merged, bc);
771
772 /* Walk bytecode and fix ops that reference the constants table. */
773 pbc_merge_ctpointers(interp, inputs, num_inputs, bc);
774
775 /* Return merged result. */
776 return merged;
777 }
778
779
780 /*
781
782 =item C<static void pbc_merge_write>
783
784 This functions writes out the merged packfile.
785
786 =cut
787
788 */
789
790 static void
791 pbc_merge_write(PARROT_INTERP, ARGMOD(PackFile *pf), ARGIN(const char *filename))
792 {
793 FILE *fp;
794
795 /* Get size of packfile we'll write. */
796 const size_t size = PackFile_pack_size(interp, pf) * sizeof (opcode_t);
797
798 /* Allocate memory. */
799 opcode_t * const pack = (opcode_t*) mem_sys_allocate(size);
800 if (pack == NULL) {
801 PIO_eprintf(interp, "PBC Merge: Out of memory");
802 Parrot_exit(interp, 1);
803 }
804
805 /* Write and clean up. */
806 PackFile_pack(interp, pf, pack);
807 if ((fp = fopen(filename, "wb")) == 0) {
808 PIO_eprintf(interp, "PBC Merge: Couldn't open %s\n", filename);
809 Parrot_exit(interp, 1);
810 }
811 if ((1 != fwrite(pack, size, 1, fp))) {
812 PIO_eprintf(interp, "PBC Merge: Couldn't write %s\n", filename);
813 Parrot_exit(interp, 1);
814 }
815 fclose(fp);
816 mem_sys_free(pack);
817 }
818
819
820 /*
821
822 =item C<int main>
823
824 The main function that grabs console input, reads in the packfiles
825 provided they exist, hands them to another function that runs the
826 merge process and finally writes out the produced packfile.
827
828 =cut
829
830 */
831
832 static struct longopt_opt_decl options[] = {
833 { 'o', 'o', OPTION_required_FLAG, { "--output" } }
834 };
835
836 int
837 main(int argc, const char **argv)
838 {
839 int status;
840 pbc_merge_input** input_files;
841 PackFile *merged;
842 int i;
843 const char *output_file = NULL;
844 struct longopt_opt_info opt = LONGOPT_OPT_INFO_INIT;
845 Interp * const interp = Parrot_new(NULL);
846
847 Parrot_block_GC_mark(interp);
848
849 /* Get options, ensuring we have at least one input
850 file and an output file. */
851 if (argc < 4) {
852 help(interp);
853 }
854 while ((status = longopt_get(interp, argc, argv, options, &opt)) > 0) {
855 switch (opt.opt_id) {
856 case 'o':
857 if (output_file == NULL)
858 output_file = opt.opt_arg;
859 else
860 help(interp);
861 break;
862 case '?':
863 help(interp);
864 break;
865 default:
866 break;
867 }
868 }
869 if (status == -1 || !output_file) {
870 help(interp);
871 }
872 argc -= opt.opt_index; /* Now the number of input files. */
873 argv += opt.opt_index; /* Now at first input filename. */
874
875 /* Load each packfile that we are to merge and set up an input
876 structure for each of them. */
877 input_files = (pbc_merge_input **)mem_sys_allocate(
878 argc * sizeof (Parrot_Pointer));
879
880 for (i = 0; i < argc; i++) {
881 /* Allocate a struct. */
882 input_files[i] = mem_allocate_typed(pbc_merge_input);
883
884 /* Set filename */
885 input_files[i]->filename = *argv;
886
887 /* Load the packfile and unpack it. */
888 input_files[i]->pf = pbc_merge_loadpbc(interp,
889 input_files[i]->filename);
890 if (input_files[i]->pf == NULL) {
891 PIO_eprintf(interp,
892 "PBC Merge: Unknown error while reading and unpacking %s\n",
893 *argv);
894 Parrot_exit(interp, 1);
895 }
896
897 /* Next file. */
898 argv++;
899 }
900
901 /* Merge. */
902 merged = pbc_merge_begin(interp, input_files, argc);
903
904 /* Write merged packfile. */
905 pbc_merge_write(interp, merged, output_file);
906
907 /* Finally, we're done. */
908 Parrot_exit(interp, 0);
909 }
910
911
912 /*
913 * Local variables:
914 * c-file-style: "parrot"
915 * End:
916 * vim: expandtab shiftwidth=4:
917 */
parrot vm git mirror