1 /* input_scrub.c - Break up input buffers into whole numbers of lines.
2 Copyright (C) 1987-2023 Free Software Foundation, Inc.
3
4 This file is part of GAS, the GNU Assembler.
5
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
9 any later version.
10
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
19 02110-1301, USA. */
20
21 #include "as.h"
22 #include "filenames.h"
23 #include "input-file.h"
24 #include "sb.h"
25 #include "listing.h"
26
27 /*
28 * O/S independent module to supply buffers of sanitised source code
29 * to rest of assembler. We get sanitised input data of arbitrary length.
30 * We break these buffers on line boundaries, recombine pieces that
31 * were broken across buffers, and return a buffer of full lines to
32 * the caller.
33 * The last partial line begins the next buffer we build and return to caller.
34 * The buffer returned to caller is preceded by BEFORE_STRING and followed
35 * by AFTER_STRING, as sentinels. The last character before AFTER_STRING
36 * is a newline.
37 * Also looks after line numbers, for e.g. error messages.
38 */
39
40 /*
41 * We don't care how filthy our buffers are, but our callers assume
42 * that the following sanitation has already been done.
43 *
44 * No comments, reduce a comment to a space.
45 * Reduce a tab to a space unless it is 1st char of line.
46 * All multiple tabs and spaces collapsed into 1 char. Tab only
47 * legal if 1st char of line.
48 * # line file statements converted to .line x;.file y; statements.
49 * Escaped newlines at end of line: remove them but add as many newlines
50 * to end of statement as you removed in the middle, to synch line numbers.
51 */
52
53 #define BEFORE_STRING ("\n")
54 #define AFTER_STRING ("\0") /* memcpy of 0 chars might choke. */
55 #define BEFORE_SIZE (1)
56 #define AFTER_SIZE (1)
57
58 #ifndef TC_EOL_IN_INSN
59 #define TC_EOL_IN_INSN(P) 0
60 #endif
61
62 static char *buffer_start; /*->1st char of full buffer area. */
63 static char *partial_where; /*->after last full line in buffer. */
64 static size_t partial_size; /* >=0. Number of chars in partial line in buffer. */
65
66 /* Because we need AFTER_STRING just after last full line, it clobbers
67 1st part of partial line. So we preserve 1st part of partial line
68 here. */
69 static char save_source[AFTER_SIZE];
70
71 /* The size of the input buffer we concatenate
72 input_file_give_next_buffer chunks into. Excludes the BEFORE and
73 AFTER counts. */
74 static size_t buffer_length;
75
76 /* The index into an sb structure we are reading from. -1 if none. */
77 static size_t sb_index = -1;
78
79 /* If we are reading from an sb structure, this is it. */
80 static sb from_sb;
81
82 /* Should we do a conditional check on from_sb? */
83 static enum expansion from_sb_expansion = expanding_none;
84
85 /* The number of nested sb structures we have included. */
86 int macro_nest;
87
88 /* We can have more than one source file open at once, though the info for all
89 but the latest one are saved off in a struct input_save. These files remain
90 open, so we are limited by the number of open files allowed by the
91 underlying OS. We may also sequentially read more than one source file in an
92 assembly. */
93
94 /* We must track the physical file and line number for error messages. We also
95 track a "logical" file and line number corresponding to (C?) compiler
96 source line numbers. Whenever we open a file we must fill in
97 physical_input_file. So if it is NULL we have not opened any files yet. */
98
99 static const char *physical_input_file;
100 static const char *logical_input_file;
101
102 /* 1-origin line number in a source file. */
103 /* A line ends in '\n' or eof. */
104 static unsigned int physical_input_line;
105 static unsigned int logical_input_line;
106
107 /* Indicator whether the origin of an update was a .linefile directive. */
108 static bool is_linefile;
109
110 /* Struct used to save the state of the input handler during include files */
111 struct input_save {
112 char * buffer_start;
113 char * partial_where;
114 size_t partial_size;
115 char save_source[AFTER_SIZE];
116 size_t buffer_length;
117 const char * physical_input_file;
118 const char * logical_input_file;
119 unsigned int physical_input_line;
120 unsigned int logical_input_line;
121 bool is_linefile;
122 size_t sb_index;
123 sb from_sb;
124 enum expansion from_sb_expansion; /* Should we do a conditional check? */
125 struct input_save * next_saved_file; /* Chain of input_saves. */
126 char * input_file_save; /* Saved state of input routines. */
127 char * saved_position; /* Caller's saved position in buf. */
128 };
129
130 static struct input_save *input_scrub_push (char *saved_position);
131 static char *input_scrub_pop (struct input_save *arg);
132
133 /* Saved information about the file that .include'd this one. When we hit EOF,
134 we automatically pop to that file. */
135
136 static struct input_save *next_saved_file;
137
138 /* Initialize input buffering. */
139
140 static void
141 input_scrub_reinit (void)
142 {
143 input_file_begin (); /* Reinitialize! */
144 logical_input_line = -1u;
145 logical_input_file = NULL;
146 sb_index = -1;
147
148 buffer_length = input_file_buffer_size () * 2;
149 buffer_start = XNEWVEC (char, BEFORE_SIZE + AFTER_SIZE + 1 + buffer_length);
150 memcpy (buffer_start, BEFORE_STRING, (int) BEFORE_SIZE);
151 }
152
153 /* Push the state of input reading and scrubbing so that we can #include.
154 The return value is a 'void *' (fudged for old compilers) to a save
155 area, which can be restored by passing it to input_scrub_pop(). */
156
157 static struct input_save *
158 input_scrub_push (char *saved_position)
159 {
160 struct input_save *saved;
161
162 saved = XNEW (struct input_save);
163
164 saved->saved_position = saved_position;
165 saved->buffer_start = buffer_start;
166 saved->partial_where = partial_where;
167 saved->partial_size = partial_size;
168 saved->buffer_length = buffer_length;
169 saved->physical_input_file = physical_input_file;
170 saved->logical_input_file = logical_input_file;
171 saved->physical_input_line = physical_input_line;
172 saved->logical_input_line = logical_input_line;
173 saved->is_linefile = is_linefile;
174 saved->sb_index = sb_index;
175 saved->from_sb = from_sb;
176 saved->from_sb_expansion = from_sb_expansion;
177 memcpy (saved->save_source, save_source, sizeof (save_source));
178 saved->next_saved_file = next_saved_file;
179 saved->input_file_save = input_file_push ();
180
181 input_scrub_reinit ();
182
183 return saved;
184 }
185
186 static char *
187 input_scrub_pop (struct input_save *saved)
188 {
189 char *saved_position;
190
191 input_scrub_end (); /* Finish off old buffer */
192
193 input_file_pop (saved->input_file_save);
194 saved_position = saved->saved_position;
195 buffer_start = saved->buffer_start;
196 buffer_length = saved->buffer_length;
197 physical_input_file = saved->physical_input_file;
198 logical_input_file = saved->logical_input_file;
199 physical_input_line = saved->physical_input_line;
200 logical_input_line = saved->logical_input_line;
201 is_linefile = saved->is_linefile;
202 sb_index = saved->sb_index;
203 from_sb = saved->from_sb;
204 from_sb_expansion = saved->from_sb_expansion;
205 partial_where = saved->partial_where;
206 partial_size = saved->partial_size;
207 next_saved_file = saved->next_saved_file;
208 memcpy (save_source, saved->save_source, sizeof (save_source));
209
210 free (saved);
211 return saved_position;
212 }
213
214 void
215 input_scrub_begin (void)
216 {
217 know (strlen (BEFORE_STRING) == BEFORE_SIZE);
218 know (strlen (AFTER_STRING) == AFTER_SIZE
219 || (AFTER_STRING[0] == '\0' && AFTER_SIZE == 1));
220
221 physical_input_file = NULL; /* No file read yet. */
222 next_saved_file = NULL; /* At EOF, don't pop to any other file */
223 macro_nest = 0;
224 input_scrub_reinit ();
225 do_scrub_begin (flag_m68k_mri);
226 }
227
228 void
229 input_scrub_end (void)
230 {
231 if (buffer_start)
232 {
233 free (buffer_start);
234 buffer_start = 0;
235 input_file_end ();
236 }
237 }
238
239 /* Start reading input from a new file.
240 Return start of caller's part of buffer. */
241
242 char *
243 input_scrub_new_file (const char *filename)
244 {
245 input_file_open (filename, !flag_no_comments);
246 physical_input_file = filename[0] ? filename : _("{standard input}");
247 physical_input_line = 0;
248
249 partial_size = 0;
250 return (buffer_start + BEFORE_SIZE);
251 }
252
253 /* Include a file from the current file. Save our state, cause it to
254 be restored on EOF, and begin handling a new file. Same result as
255 input_scrub_new_file. */
256
257 char *
258 input_scrub_include_file (const char *filename, char *position)
259 {
260 next_saved_file = input_scrub_push (position);
261 from_sb_expansion = expanding_none;
262 return input_scrub_new_file (filename);
263 }
264
265 /* Start getting input from an sb structure. This is used when
266 expanding a macro. */
267
268 void
269 input_scrub_include_sb (sb *from, char *position, enum expansion expansion)
270 {
271 int newline;
272
273 if (macro_nest > max_macro_nest)
274 as_fatal (_("macros nested too deeply"));
275 ++macro_nest;
276
277 #ifdef md_macro_start
278 if (expansion == expanding_macro)
279 {
280 md_macro_start ();
281 }
282 #endif
283
284 next_saved_file = input_scrub_push (position);
285
286 /* Allocate sufficient space: from->len plus optional newline
287 plus two ".linefile " directives, plus a little more for other
288 expansion. */
289 newline = from->len >= 1 && from->ptr[0] != '\n';
290 sb_build (&from_sb, from->len + newline + 2 * sizeof (".linefile") + 30);
291 from_sb_expansion = expansion;
292 if (newline)
293 {
294 /* Add the sentinel required by read.c. */
295 sb_add_char (&from_sb, '\n');
296 }
297 sb_scrub_and_add_sb (&from_sb, from);
298
299 /* Make sure the parser looks at defined contents when it scans for
300 e.g. end-of-line at the end of a macro. */
301 sb_terminate (&from_sb);
302
303 sb_index = 1;
304
305 /* These variables are reset by input_scrub_push. Restore them
306 since we are, after all, still at the same point in the file. */
307 logical_input_line = next_saved_file->logical_input_line;
308 logical_input_file = next_saved_file->logical_input_file;
309 }
310
311 void
312 input_scrub_close (void)
313 {
314 input_file_close ();
315 physical_input_line = 0;
316 logical_input_line = -1u;
317 }
318
319 char *
320 input_scrub_next_buffer (char **bufp)
321 {
322 char *limit; /*->just after last char of buffer. */
323
324 if (sb_index != (size_t) -1)
325 {
326 if (sb_index >= from_sb.len)
327 {
328 sb_kill (&from_sb);
329 if (from_sb_expansion == expanding_macro)
330 {
331 cond_finish_check (macro_nest);
332 #ifdef md_macro_end
333 /* Allow the target to clean up per-macro expansion
334 data. */
335 md_macro_end ();
336 #endif
337 }
338 --macro_nest;
339 partial_where = NULL;
340 partial_size = 0;
341 if (next_saved_file != NULL)
342 *bufp = input_scrub_pop (next_saved_file);
343 return partial_where;
344 }
345
346 partial_where = from_sb.ptr + from_sb.len;
347 partial_size = 0;
348 *bufp = from_sb.ptr + sb_index;
349 sb_index = from_sb.len;
350 return partial_where;
351 }
352
353 if (partial_size)
354 {
355 memmove (buffer_start + BEFORE_SIZE, partial_where, partial_size);
356 memcpy (buffer_start + BEFORE_SIZE, save_source, AFTER_SIZE);
357 }
358
359 while (1)
360 {
361 char *p;
362 char *start = buffer_start + BEFORE_SIZE + partial_size;
363
364 *bufp = buffer_start + BEFORE_SIZE;
365 limit = input_file_give_next_buffer (start);
366 if (!limit)
367 {
368 if (!partial_size)
369 /* End of this file. */
370 break;
371
372 as_warn (_("end of file not at end of a line; newline inserted"));
373 p = buffer_start + BEFORE_SIZE + partial_size;
374 *p++ = '\n';
375 limit = p;
376 }
377 else
378 {
379 /* Terminate the buffer to avoid confusing TC_EOL_IN_INSN. */
380 *limit = '\0';
381
382 /* Find last newline. */
383 for (p = limit - 1; *p != '\n' || TC_EOL_IN_INSN (p); --p)
384 if (p < start)
385 goto read_more;
386 ++p;
387 }
388
389 if (multibyte_handling == multibyte_warn)
390 (void) scan_for_multibyte_characters ((const unsigned char *) p,
391 (const unsigned char *) limit,
392 true /* Generate warnings */);
393
394 /* We found a newline in the newly read chars. */
395 partial_where = p;
396 partial_size = limit - p;
397
398 /* Save the fragment after that last newline. */
399 memcpy (save_source, partial_where, (int) AFTER_SIZE);
400 memcpy (partial_where, AFTER_STRING, (int) AFTER_SIZE);
401 return partial_where;
402
403 read_more:
404 /* Didn't find a newline. Read more text. */
405 partial_size = limit - (buffer_start + BEFORE_SIZE);
406 if (buffer_length - input_file_buffer_size () < partial_size)
407 {
408 /* Increase the buffer when it doesn't have room for the
409 next block of input. */
410 buffer_length *= 2;
411 buffer_start = XRESIZEVEC (char, buffer_start,
412 (buffer_length
413 + BEFORE_SIZE + AFTER_SIZE + 1));
414 }
415 }
416
417 /* Tell the listing we've finished the file. */
418 LISTING_EOF ();
419
420 /* If we should pop to another file at EOF, do it. */
421 partial_where = NULL;
422 if (next_saved_file)
423 *bufp = input_scrub_pop (next_saved_file);
424
425 return partial_where;
426 }
427
428 /* The remaining part of this file deals with line numbers, error
429 messages and so on. Return TRUE if we opened any file. */
430
431 int
432 seen_at_least_1_file (void)
433 {
434 return (physical_input_file != NULL);
435 }
436
437 void
438 bump_line_counters (void)
439 {
440 if (sb_index == (size_t) -1)
441 ++physical_input_line;
442
443 if (logical_input_line != -1u)
444 ++logical_input_line;
445 }
446
447 /* Tells us what the new logical line number and file are.
448 If the line_number is -1, we don't change the current logical line
449 number.
450 If fname is NULL, we don't change the current logical file name, unless
451 bit 3 of flags is set.
452 Returns nonzero if the filename actually changes. */
453
454 void
455 new_logical_line_flags (const char *fname, /* DON'T destroy it! We point to it! */
456 int line_number,
457 int flags)
458 {
459 switch (flags)
460 {
461 case 0:
462 break;
463 case 1:
464 if (line_number != -1)
465 abort ();
466 break;
467 case 1 << 1:
468 case 1 << 2:
469 /* FIXME: we could check that include nesting is correct. */
470 break;
471 case 1 << 3:
472 if (line_number < 0 || fname != NULL)
473 abort ();
474 if (next_saved_file == NULL)
475 fname = physical_input_file;
476 else if (next_saved_file->logical_input_file)
477 fname = next_saved_file->logical_input_file;
478 else
479 fname = next_saved_file->physical_input_file;
480 break;
481 default:
482 abort ();
483 }
484
485 is_linefile = flags != 1 && (flags != 0 || fname);
486
487 if (line_number >= 0)
488 logical_input_line = line_number;
489 else if (line_number == -1 && fname && !*fname && (flags & (1 << 2)))
490 {
491 logical_input_file = physical_input_file;
492 logical_input_line = physical_input_line;
493 fname = NULL;
494 }
495
496 if (fname
497 && (logical_input_file == NULL
498 || filename_cmp (logical_input_file, fname)))
499 logical_input_file = fname;
500 }
501
502 void
503 new_logical_line (const char *fname, int line_number)
504 {
505 new_logical_line_flags (fname, line_number, 0);
506 }
507
508 void
509 as_report_context (void)
510 {
511 const struct input_save *saved = next_saved_file;
512 enum expansion expansion = from_sb_expansion;
513 int indent = 1;
514
515 if (!macro_nest)
516 return;
517
518 do
519 {
520 if (expansion != expanding_macro)
521 /* Nothing. */;
522 else if (saved->logical_input_file != NULL
523 && saved->logical_input_line != -1u)
524 as_info_where (saved->logical_input_file, saved->logical_input_line,
525 indent, _("macro invoked from here"));
526 else
527 as_info_where (saved->physical_input_file, saved->physical_input_line,
528 indent, _("macro invoked from here"));
529
530 expansion = saved->from_sb_expansion;
531 ++indent;
532 }
533 while ((saved = saved->next_saved_file) != NULL);
534 }
535
536 /* Return the current physical input file name and line number, if known */
537
538 const char *
539 as_where_physical (unsigned int *linep)
540 {
541 if (physical_input_file != NULL)
542 {
543 if (linep != NULL)
544 *linep = physical_input_line;
545 return physical_input_file;
546 }
547
548 if (linep != NULL)
549 *linep = 0;
550 return NULL;
551 }
552
553 /* Return the file name and line number at the top most macro
554 invocation, unless .file / .line were used inside a macro. */
555
556 const char *
557 as_where (unsigned int *linep)
558 {
559 const char *file = as_where_top (linep);
560
561 if (macro_nest && is_linefile)
562 {
563 const struct input_save *saved = next_saved_file;
564 enum expansion expansion = from_sb_expansion;
565
566 do
567 {
568 if (expansion != expanding_macro)
569 /* Nothing. */;
570 else if (saved->logical_input_file != NULL
571 && (linep == NULL || saved->logical_input_line != -1u))
572 {
573 if (linep != NULL)
574 *linep = saved->logical_input_line;
575 file = saved->logical_input_file;
576 }
577 else if (saved->physical_input_file != NULL)
578 {
579 if (linep != NULL)
580 *linep = saved->physical_input_line;
581 file = saved->physical_input_file;
582 }
583
584 expansion = saved->from_sb_expansion;
585 }
586 while ((saved = saved->next_saved_file) != NULL);
587 }
588
589 return file;
590 }
591
592 /* Return the current file name and line number. */
593
594 const char *
595 as_where_top (unsigned int *linep)
596 {
597 if (logical_input_file != NULL
598 && (linep == NULL || logical_input_line != -1u))
599 {
600 if (linep != NULL)
601 *linep = logical_input_line;
602 return logical_input_file;
603 }
604
605 return as_where_physical (linep);
606 }