1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 1988 AT&T
24 * All Rights Reserved
25 *
26 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
27 *
28 * Copyright 2019 Joyent, Inc.
29 */
30
31 /*
32 * Map file parsing (Shared Core Code).
33 */
34 #include <fcntl.h>
35 #include <stdio.h>
36 #include <unistd.h>
37 #include <sys/stat.h>
38 #include <errno.h>
39 #include <limits.h>
40 #include <dirent.h>
41 #include <ctype.h>
42 #include <debug.h>
43 #include "msg.h"
44 #include "_libld.h"
45 #include "_map.h"
46
47 /*
48 * There are two styles of mapfile supported by the link-editor:
49 *
50 * 1) The original System V defined syntax, as augmented at Sun
51 * from Solaris 2.0 through Solaris 10. This style is also known
52 * as version 1.
53 *
54 * 2) A newer syntax, currently at version 2.
55 *
56 * The original syntax uses special characters (=, :, -, |, etc) as
57 * operators to indicate the operation being specified. Over the years,
58 * this syntax has been problematic:
59 *
60 * 1) Too cryptic: It's hard for people to remember which character
61 * means what.
62 *
63 * 2) Limited expansion potential: There only a few special characters
64 * available on the keyboard for new features, and it is difficult to
65 * add options to existing ones.
66 *
67 * Adding new features into this framework (2) have the effect of
68 * making the syntax even more cryptic (1). The newer syntax addresses
69 * these issues by moving to an extendible identifier based syntax that
70 * allows new features to be added without complicating old ones.
71 *
72 * The new syntax uses the following terminology:
73 *
74 * - Control directives are the directives that start with a '$'.
75 * They control how the mapfile is interpreted. We use the 'cdir_'
76 * prefix on functions and variables related to these directives.
77 *
78 * - Conditional Expressions are the expressions found in $if and $elif
79 * control directives. They evaluate to boolean true/false values.
80 * We use the 'cexp_' prefix for functions and variables related to
81 * these expressions.
82 *
83 * - Regular Directives are names (SYMBOL, VERSION, etc) that convey
84 * directions to the link-editor for building the output object.
85 *
86 * This file contains core code used by both mapfile styles: File management,
87 * lexical analysis, and other shared core functionality. It also contains
88 * the code for control directives, as they are intrinsically part of
89 * lexical analysis --- this is disabled when processing Sysv mapfiles.
90 */
91
92 /*
93 * We use a stack of cdir_level_t structs to manage $if/$elif/$else/$endif
94 * processing. At each level, we keep track of the information needed to
95 * determine whether or not to process nested input lines or skip them,
96 * along with information needed to report errors.
97 */
98 typedef struct {
99 Lineno cdl_if_lineno; /* Line number of opening $if */
100 Lineno cdl_else_lineno; /* 0, or line on which $else seen */
101 int cdl_done; /* True if no longer accepts input */
102 int cdl_pass; /* True if currently accepting input */
103 } cdir_level_t;
104
105 /* Operators in the expressions accepted by $if/$elif */
106 typedef enum {
107 CEXP_OP_NONE, /* Not an operator */
108 CEXP_OP_AND, /* && */
109 CEXP_OP_OR, /* || */
110 CEXP_OP_NEG, /* ! */
111 CEXP_OP_OPAR, /* ( */
112 CEXP_OP_CPAR /* ) */
113 } cexp_op_t;
114
115 /*
116 * Type of conditional expression identifier AVL tree nodes
117 */
118 typedef struct cexp_name_node {
119 avl_node_t ceid_avlnode; /* AVL book-keeping */
120 const char *ceid_name; /* boolean identifier name */
121 } cexp_id_node_t;
122
123
124 /*
125 * Declare a "stack" type, containing a pointer to data, a count of
126 * allocated, and currently used items in the stack. The data type
127 * is specified as the _type argument.
128 */
129 #define STACK(_type) \
130 struct { \
131 _type *stk_s; /* Stack array */ \
132 size_t stk_n; /* Current stack depth */ \
133 size_t stk_n_alloc; /* # of elements pointed at by s */ \
134 }
135
136 /*
137 * The following type represents a "generic" stack, where the data
138 * type is (void). This type is never instantiated. However, it has
139 * the same struct layout as any other STACK(), and is therefore a good
140 * generic type that can be used for stack_resize().
141 */
142 typedef STACK(void) generic_stack_t;
143
144 /*
145 * Ensure that the stack has enough room to push one more item
146 */
147 #define STACK_RESERVE(_stack, _n_default) \
148 (((_stack).stk_n < (_stack).stk_n_alloc) || \
149 stack_resize((generic_stack_t *)&(_stack).stk_s, _n_default, \
150 sizeof (*(_stack).stk_s)))
151
152 /*
153 * Reset a stack to empty.
154 */
155 #define STACK_RESET(_stack) (_stack).stk_n = 0;
156
157 /*
158 * True if stack is empty, False otherwise.
159 */
160 #define STACK_IS_EMPTY(_stack) ((_stack).stk_n == 0)
161
162 /*
163 * Push a value onto a stack. Caller must ensure that stack has room.
164 * This macro is intended to be used as the LHS of an assignment, the
165 * RHS of which is the value:
166 *
167 * STACK_PUSH(stack) = value;
168 */
169 #define STACK_PUSH(_stack) (_stack).stk_s[(_stack).stk_n++]
170
171 /*
172 * Pop a value off a stack. Caller must ensure
173 * that stack is not empty.
174 */
175 #define STACK_POP(_stack) ((_stack).stk_s[--(_stack).stk_n])
176
177 /*
178 * Access top element on stack without popping. Caller must ensure
179 * that stack is not empty.
180 */
181 #define STACK_TOP(_stack) (((_stack).stk_s)[(_stack).stk_n - 1])
182
183 /*
184 * Initial sizes used for the stacks: The stacks are allocated on demand
185 * to these sizes, and then doubled as necessary until they are large enough.
186 *
187 * The ideal size would be large enough that only a single allocation
188 * occurs, and our defaults should generally have that effect. However,
189 * in doing so, we run the risk of a latent error in the resize code going
190 * undetected until triggered by a large task in the field. For this reason,
191 * we set the sizes to the smallest size possible when compiled for debug.
192 */
193 #ifdef DEBUG
194 #define CDIR_STACK_INIT 1
195 #define CEXP_OP_STACK_INIT 1
196 #define CEXP_VAL_STACK_INIT 1
197 #else
198 #define CDIR_STACK_INIT 16
199 #define CEXP_OP_STACK_INIT 8
200 #define CEXP_VAL_STACK_INIT (CEXP_OP_STACK_INIT * 2) /* 2 vals per binop */
201 #endif
202
203
204 /*
205 * Persistent state maintained by map module in between calls.
206 *
207 * This is kept as static file scope data, because it is only used
208 * when libld is called by ld, and not by rtld. If that should change,
209 * the code is designed so that it can become reentrant easily:
210 *
211 * - Add a pointer to the output descriptor to a structure of this type,
212 * allocated dynamically on the first call to ld_map_parse().
213 * - Change all references to lms to instead reference the pointer in
214 * the output descriptor.
215 *
216 * Until then, it is simpler not to expose these details.
217 */
218 typedef struct {
219 int lms_cdir_valid; /* Allow control dir. on entry to gettoken() */
220 STACK(cdir_level_t) lms_cdir_stack; /* Conditional input level */
221 STACK(cexp_op_t) lms_cexp_op_stack; /* Cond. expr operators */
222 STACK(uchar_t) lms_cexp_val_stack; /* Cond. expr values */
223 avl_tree_t *lms_cexp_id;
224 } ld_map_state_t;
225 static ld_map_state_t lms;
226
227
228 /*
229 * Version 1 (SysV) syntax dispatch table for ld_map_gettoken(). For each
230 * of the 7-bit ASCII characters, determine how the lexical analyzer
231 * should behave.
232 *
233 * This table must be kept in sync with tkid_attr[] below.
234 *
235 * Identifier Note:
236 * The Linker and Libraries Guide states that the original syntax uses
237 * C identifier rules, allowing '.' to be treated as a letter. However,
238 * the implementation is considerably looser than that: Any character
239 * with an ASCII code (0-127) which is printable and not used to start
240 * another token is allowed to start an identifier, and they are terminated
241 * by any of: space, double quote, tab, newline, ':', ';', '=', or '#'.
242 * The original code has been replaced, but this table encodes the same
243 * rules, to ensure backward compatibility.
244 */
245 static const mf_tokdisp_t gettok_dispatch_v1 = {
246 TK_OP_EOF, /* 0 - NUL */
247 TK_OP_ILLCHR, /* 1 - SOH */
248 TK_OP_ILLCHR, /* 2 - STX */
249 TK_OP_ILLCHR, /* 3 - ETX */
250 TK_OP_ILLCHR, /* 4 - EOT */
251 TK_OP_ILLCHR, /* 5 - ENQ */
252 TK_OP_ILLCHR, /* 6 - ACK */
253 TK_OP_ILLCHR, /* 7 - BEL */
254 TK_OP_ILLCHR, /* 8 - BS */
255 TK_OP_WS, /* 9 - HT */
256 TK_OP_NL, /* 10 - NL */
257 TK_OP_WS, /* 11 - VT */
258 TK_OP_WS, /* 12 - FF */
259 TK_OP_WS, /* 13 - CR */
260 TK_OP_ILLCHR, /* 14 - SO */
261 TK_OP_ILLCHR, /* 15 - SI */
262 TK_OP_ILLCHR, /* 16 - DLE */
263 TK_OP_ILLCHR, /* 17 - DC1 */
264 TK_OP_ILLCHR, /* 18 - DC2 */
265 TK_OP_ILLCHR, /* 19 - DC3 */
266 TK_OP_ILLCHR, /* 20 - DC4 */
267 TK_OP_ILLCHR, /* 21 - NAK */
268 TK_OP_ILLCHR, /* 22 - SYN */
269 TK_OP_ILLCHR, /* 23 - ETB */
270 TK_OP_ILLCHR, /* 24 - CAN */
271 TK_OP_ILLCHR, /* 25 - EM */
272 TK_OP_ILLCHR, /* 26 - SUB */
273 TK_OP_ILLCHR, /* 27 - ESC */
274 TK_OP_ILLCHR, /* 28 - FS */
275 TK_OP_ILLCHR, /* 29 - GS */
276 TK_OP_ILLCHR, /* 30 - RS */
277 TK_OP_ILLCHR, /* 31 - US */
278 TK_OP_WS, /* 32 - SP */
279 TK_OP_ID, /* 33 - ! */
280 TK_OP_SIMQUOTE, /* 34 - " */
281 TK_OP_CMT, /* 35 - # */
282 TK_OP_ID, /* 36 - $ */
283 TK_OP_ID, /* 37 - % */
284 TK_OP_ID, /* 38 - & */
285 TK_OP_ID, /* 39 - ' */
286 TK_OP_ID, /* 40 - ( */
287 TK_OP_ID, /* 41 - ) */
288 TK_OP_ID, /* 42 - * */
289 TK_OP_ID, /* 43 - + */
290 TK_OP_ID, /* 44 - , */
291 TK_DASH, /* 45 - - */
292 TK_OP_ID, /* 46 - . */
293 TK_OP_ID, /* 47 - / */
294 TK_OP_ID, /* 48 - 0 */
295 TK_OP_ID, /* 49 - 1 */
296 TK_OP_ID, /* 50 - 2 */
297 TK_OP_ID, /* 51 - 3 */
298 TK_OP_ID, /* 52 - 4 */
299 TK_OP_ID, /* 53 - 5 */
300 TK_OP_ID, /* 54 - 6 */
301 TK_OP_ID, /* 55 - 7 */
302 TK_OP_ID, /* 56 - 8 */
303 TK_OP_ID, /* 57 - 9 */
304 TK_COLON, /* 58 - : */
305 TK_SEMICOLON, /* 59 - ; */
306 TK_OP_ID, /* 60 - < */
307 TK_EQUAL, /* 61 - = */
308 TK_OP_ID, /* 62 - > */
309 TK_OP_ID, /* 63 - ? */
310 TK_ATSIGN, /* 64 - @ */
311 TK_OP_ID, /* 65 - A */
312 TK_OP_ID, /* 66 - B */
313 TK_OP_ID, /* 67 - C */
314 TK_OP_ID, /* 68 - D */
315 TK_OP_ID, /* 69 - E */
316 TK_OP_ID, /* 70 - F */
317 TK_OP_ID, /* 71 - G */
318 TK_OP_ID, /* 72 - H */
319 TK_OP_ID, /* 73 - I */
320 TK_OP_ID, /* 74 - J */
321 TK_OP_ID, /* 75 - K */
322 TK_OP_ID, /* 76 - L */
323 TK_OP_ID, /* 77 - M */
324 TK_OP_ID, /* 78 - N */
325 TK_OP_ID, /* 79 - O */
326 TK_OP_ID, /* 80 - P */
327 TK_OP_ID, /* 81 - Q */
328 TK_OP_ID, /* 82 - R */
329 TK_OP_ID, /* 83 - S */
330 TK_OP_ID, /* 84 - T */
331 TK_OP_ID, /* 85 - U */
332 TK_OP_ID, /* 86 - V */
333 TK_OP_ID, /* 87 - W */
334 TK_OP_ID, /* 88 - X */
335 TK_OP_ID, /* 89 - Y */
336 TK_OP_ID, /* 90 - Z */
337 TK_OP_ID, /* 91 - [ */
338 TK_OP_ID, /* 92 - \ */
339 TK_OP_ID, /* 93 - ] */
340 TK_OP_ID, /* 94 - ^ */
341 TK_OP_ID, /* 95 - _ */
342 TK_OP_ID, /* 96 - ` */
343 TK_OP_ID, /* 97 - a */
344 TK_OP_ID, /* 98 - b */
345 TK_OP_ID, /* 99 - c */
346 TK_OP_ID, /* 100 - d */
347 TK_OP_ID, /* 101 - e */
348 TK_OP_ID, /* 102 - f */
349 TK_OP_ID, /* 103 - g */
350 TK_OP_ID, /* 104 - h */
351 TK_OP_ID, /* 105 - i */
352 TK_OP_ID, /* 106 - j */
353 TK_OP_ID, /* 107 - k */
354 TK_OP_ID, /* 108 - l */
355 TK_OP_ID, /* 109 - m */
356 TK_OP_ID, /* 110 - n */
357 TK_OP_ID, /* 111 - o */
358 TK_OP_ID, /* 112 - p */
359 TK_OP_ID, /* 113 - q */
360 TK_OP_ID, /* 114 - r */
361 TK_OP_ID, /* 115 - s */
362 TK_OP_ID, /* 116 - t */
363 TK_OP_ID, /* 117 - u */
364 TK_OP_ID, /* 118 - v */
365 TK_OP_ID, /* 119 - w */
366 TK_OP_ID, /* 120 - x */
367 TK_OP_ID, /* 121 - y */
368 TK_OP_ID, /* 122 - z */
369 TK_LEFTBKT, /* 123 - { */
370 TK_PIPE, /* 124 - | */
371 TK_RIGHTBKT, /* 125 - } */
372 TK_OP_ID, /* 126 - ~ */
373 TK_OP_ILLCHR, /* 127 - DEL */
374 };
375
376 /*
377 * Version 2 syntax dispatch table for ld_map_gettoken(). For each of the
378 * 7-bit ASCII characters, determine how the lexical analyzer should behave.
379 *
380 * This table must be kept in sync with tkid_attr[] below.
381 *
382 * Identifier Note:
383 * We define a letter as being one of the character [A-Z], [a-z], or [_%/.]
384 * A digit is the numbers [0-9], or [$-]. An unquoted identifier is defined
385 * as a letter, followed by any number of letters or digits. This is a loosened
386 * version of the C definition of an identifier. The extra characters not
387 * allowed by C are common in section names and/or file paths.
388 */
389 static const mf_tokdisp_t gettok_dispatch_v2 = {
390 TK_OP_EOF, /* 0 - NUL */
391 TK_OP_ILLCHR, /* 1 - SOH */
392 TK_OP_ILLCHR, /* 2 - STX */
393 TK_OP_ILLCHR, /* 3 - ETX */
394 TK_OP_ILLCHR, /* 4 - EOT */
395 TK_OP_ILLCHR, /* 5 - ENQ */
396 TK_OP_ILLCHR, /* 6 - ACK */
397 TK_OP_ILLCHR, /* 7 - BEL */
398 TK_OP_ILLCHR, /* 8 - BS */
399 TK_OP_WS, /* 9 - HT */
400 TK_OP_NL, /* 10 - NL */
401 TK_OP_WS, /* 11 - VT */
402 TK_OP_WS, /* 12 - FF */
403 TK_OP_WS, /* 13 - CR */
404 TK_OP_ILLCHR, /* 14 - SO */
405 TK_OP_ILLCHR, /* 15 - SI */
406 TK_OP_ILLCHR, /* 16 - DLE */
407 TK_OP_ILLCHR, /* 17 - DC1 */
408 TK_OP_ILLCHR, /* 18 - DC2 */
409 TK_OP_ILLCHR, /* 19 - DC3 */
410 TK_OP_ILLCHR, /* 20 - DC4 */
411 TK_OP_ILLCHR, /* 21 - NAK */
412 TK_OP_ILLCHR, /* 22 - SYN */
413 TK_OP_ILLCHR, /* 23 - ETB */
414 TK_OP_ILLCHR, /* 24 - CAN */
415 TK_OP_ILLCHR, /* 25 - EM */
416 TK_OP_ILLCHR, /* 26 - SUB */
417 TK_OP_ILLCHR, /* 27 - ESC */
418 TK_OP_ILLCHR, /* 28 - FS */
419 TK_OP_ILLCHR, /* 29 - GS */
420 TK_OP_ILLCHR, /* 30 - RS */
421 TK_OP_ILLCHR, /* 31 - US */
422 TK_OP_WS, /* 32 - SP */
423 TK_BANG, /* 33 - ! */
424 TK_OP_CQUOTE, /* 34 - " */
425 TK_OP_CMT, /* 35 - # */
426 TK_OP_CDIR, /* 36 - $ */
427 TK_OP_ID, /* 37 - % */
428 TK_OP_BADCHR, /* 38 - & */
429 TK_OP_SIMQUOTE, /* 39 - ' */
430 TK_OP_BADCHR, /* 40 - ( */
431 TK_OP_BADCHR, /* 41 - ) */
432 TK_STAR, /* 42 - * */
433 TK_OP_CEQUAL, /* 43 - + */
434 TK_OP_BADCHR, /* 44 - , */
435 TK_OP_CEQUAL, /* 45 - - */
436 TK_OP_ID, /* 46 - . */
437 TK_OP_ID, /* 47 - / */
438 TK_OP_NUM, /* 48 - 0 */
439 TK_OP_NUM, /* 49 - 1 */
440 TK_OP_NUM, /* 50 - 2 */
441 TK_OP_NUM, /* 51 - 3 */
442 TK_OP_NUM, /* 52 - 4 */
443 TK_OP_NUM, /* 53 - 5 */
444 TK_OP_NUM, /* 54 - 6 */
445 TK_OP_NUM, /* 55 - 7 */
446 TK_OP_NUM, /* 56 - 8 */
447 TK_OP_NUM, /* 57 - 9 */
448 TK_COLON, /* 58 - : */
449 TK_SEMICOLON, /* 59 - ; */
450 TK_OP_BADCHR, /* 60 - < */
451 TK_EQUAL, /* 61 - = */
452 TK_OP_BADCHR, /* 62 - > */
453 TK_OP_BADCHR, /* 63 - ? */
454 TK_OP_BADCHR, /* 64 - @ */
455 TK_OP_ID, /* 65 - A */
456 TK_OP_ID, /* 66 - B */
457 TK_OP_ID, /* 67 - C */
458 TK_OP_ID, /* 68 - D */
459 TK_OP_ID, /* 69 - E */
460 TK_OP_ID, /* 70 - F */
461 TK_OP_ID, /* 71 - G */
462 TK_OP_ID, /* 72 - H */
463 TK_OP_ID, /* 73 - I */
464 TK_OP_ID, /* 74 - J */
465 TK_OP_ID, /* 75 - K */
466 TK_OP_ID, /* 76 - L */
467 TK_OP_ID, /* 77 - M */
468 TK_OP_ID, /* 78 - N */
469 TK_OP_ID, /* 79 - O */
470 TK_OP_ID, /* 80 - P */
471 TK_OP_ID, /* 81 - Q */
472 TK_OP_ID, /* 82 - R */
473 TK_OP_ID, /* 83 - S */
474 TK_OP_ID, /* 84 - T */
475 TK_OP_ID, /* 85 - U */
476 TK_OP_ID, /* 86 - V */
477 TK_OP_ID, /* 87 - W */
478 TK_OP_ID, /* 88 - X */
479 TK_OP_ID, /* 89 - Y */
480 TK_OP_ID, /* 90 - Z */
481 TK_OP_BADCHR, /* 91 - [ */
482 TK_OP_BADCHR, /* 92 - \ */
483 TK_OP_BADCHR, /* 93 - ] */
484 TK_OP_BADCHR, /* 94 - ^ */
485 TK_OP_ID, /* 95 - _ */
486 TK_OP_BADCHR, /* 96 - ` */
487 TK_OP_ID, /* 97 - a */
488 TK_OP_ID, /* 98 - b */
489 TK_OP_ID, /* 99 - c */
490 TK_OP_ID, /* 100 - d */
491 TK_OP_ID, /* 101 - e */
492 TK_OP_ID, /* 102 - f */
493 TK_OP_ID, /* 103 - g */
494 TK_OP_ID, /* 104 - h */
495 TK_OP_ID, /* 105 - i */
496 TK_OP_ID, /* 106 - j */
497 TK_OP_ID, /* 107 - k */
498 TK_OP_ID, /* 108 - l */
499 TK_OP_ID, /* 109 - m */
500 TK_OP_ID, /* 110 - n */
501 TK_OP_ID, /* 111 - o */
502 TK_OP_ID, /* 112 - p */
503 TK_OP_ID, /* 113 - q */
504 TK_OP_ID, /* 114 - r */
505 TK_OP_ID, /* 115 - s */
506 TK_OP_ID, /* 116 - t */
507 TK_OP_ID, /* 117 - u */
508 TK_OP_ID, /* 118 - v */
509 TK_OP_ID, /* 119 - w */
510 TK_OP_ID, /* 120 - x */
511 TK_OP_ID, /* 121 - y */
512 TK_OP_ID, /* 122 - z */
513 TK_LEFTBKT, /* 123 - { */
514 TK_OP_BADCHR, /* 124 - | */
515 TK_RIGHTBKT, /* 125 - } */
516 TK_OP_BADCHR, /* 126 - ~ */
517 TK_OP_ILLCHR, /* 127 - DEL */
518 };
519
520
521 /*
522 * Table used to identify unquoted identifiers. Each element of this array
523 * contains a bitmask indicating whether the character it represents starts,
524 * or continues an identifier, for each supported mapfile syntax version.
525 */
526 static const char tkid_attr[128] = {
527 0, /* 0 - NUL */
528 TKID_ATTR_CONT(1), /* 1 - SOH */
529 TKID_ATTR_CONT(1), /* 2 - STX */
530 TKID_ATTR_CONT(1), /* 3 - ETX */
531 TKID_ATTR_CONT(1), /* 4 - EOT */
532 TKID_ATTR_CONT(1), /* 5 - ENQ */
533 TKID_ATTR_CONT(1), /* 6 - ACK */
534 TKID_ATTR_CONT(1), /* 7 - BEL */
535 TKID_ATTR_CONT(1), /* 8 - BS */
536 0, /* 9 - HT */
537 0, /* 10 - NL */
538 TKID_ATTR_CONT(1), /* 11 - VT */
539 TKID_ATTR_CONT(1), /* 12 - FF */
540 TKID_ATTR_CONT(1), /* 13 - CR */
541 TKID_ATTR_CONT(1), /* 14 - SO */
542 TKID_ATTR_CONT(1), /* 15 - SI */
543 TKID_ATTR_CONT(1), /* 16 - DLE */
544 TKID_ATTR_CONT(1), /* 17 - DC1 */
545 TKID_ATTR_CONT(1), /* 18 - DC2 */
546 TKID_ATTR_CONT(1), /* 19 - DC3 */
547 TKID_ATTR_CONT(1), /* 20 - DC4 */
548 TKID_ATTR_CONT(1), /* 21 - NAK */
549 TKID_ATTR_CONT(1), /* 22 - SYN */
550 TKID_ATTR_CONT(1), /* 23 - ETB */
551 TKID_ATTR_CONT(1), /* 24 - CAN */
552 TKID_ATTR_CONT(1), /* 25 - EM */
553 TKID_ATTR_CONT(1), /* 26 - SUB */
554 TKID_ATTR_CONT(1), /* 27 - ESC */
555 TKID_ATTR_CONT(1), /* 28 - FS */
556 TKID_ATTR_CONT(1), /* 29 - GS */
557 TKID_ATTR_CONT(1), /* 30 - RS */
558 TKID_ATTR_CONT(1), /* 31 - US */
559 0, /* 32 - SP */
560 TKID_ATTR(1), /* 33 - ! */
561 0, /* 34 - " */
562 0, /* 35 - # */
563 TKID_ATTR(1) | TKID_ATTR_CONT(2), /* 36 - $ */
564 TKID_ATTR(1) | TKID_ATTR_CONT(2), /* 37 - % */
565 TKID_ATTR(1), /* 38 - & */
566 TKID_ATTR(1), /* 39 - ' */
567 TKID_ATTR(1), /* 40 - ( */
568 TKID_ATTR(1), /* 41 - ) */
569 TKID_ATTR(1), /* 42 - * */
570 TKID_ATTR(1), /* 43 - + */
571 TKID_ATTR(1), /* 44 - , */
572 TKID_ATTR_CONT(1) | TKID_ATTR_CONT(2), /* 45 - - */
573 TKID_ATTR(1) | TKID_ATTR(2), /* 46 - . */
574 TKID_ATTR(1) | TKID_ATTR(2), /* 47 - / */
575 TKID_ATTR(1) | TKID_ATTR_CONT(2), /* 48 - 0 */
576 TKID_ATTR(1) | TKID_ATTR_CONT(2), /* 49 - 1 */
577 TKID_ATTR(1) | TKID_ATTR_CONT(2), /* 50 - 2 */
578 TKID_ATTR(1) | TKID_ATTR_CONT(2), /* 51 - 3 */
579 TKID_ATTR(1) | TKID_ATTR_CONT(2), /* 52 - 4 */
580 TKID_ATTR(1) | TKID_ATTR_CONT(2), /* 53 - 5 */
581 TKID_ATTR(1) | TKID_ATTR_CONT(2), /* 54 - 6 */
582 TKID_ATTR(1) | TKID_ATTR_CONT(2), /* 55 - 7 */
583 TKID_ATTR(1) | TKID_ATTR_CONT(2), /* 56 - 8 */
584 TKID_ATTR(1) | TKID_ATTR_CONT(2), /* 57 - 9 */
585 0, /* 58 - : */
586 0, /* 59 - ; */
587 TKID_ATTR(1), /* 60 - < */
588 0, /* 61 - = */
589 TKID_ATTR(1), /* 62 - > */
590 TKID_ATTR(1), /* 63 - ? */
591 TKID_ATTR_CONT(1), /* 64 - @ */
592 TKID_ATTR(1) | TKID_ATTR(2), /* 65 - A */
593 TKID_ATTR(1) | TKID_ATTR(2), /* 66 - B */
594 TKID_ATTR(1) | TKID_ATTR(2), /* 67 - C */
595 TKID_ATTR(1) | TKID_ATTR(2), /* 68 - D */
596 TKID_ATTR(1) | TKID_ATTR(2), /* 69 - E */
597 TKID_ATTR(1) | TKID_ATTR(2), /* 70 - F */
598 TKID_ATTR(1) | TKID_ATTR(2), /* 71 - G */
599 TKID_ATTR(1) | TKID_ATTR(2), /* 72 - H */
600 TKID_ATTR(1) | TKID_ATTR(2), /* 73 - I */
601 TKID_ATTR(1) | TKID_ATTR(2), /* 74 - J */
602 TKID_ATTR(1) | TKID_ATTR(2), /* 75 - K */
603 TKID_ATTR(1) | TKID_ATTR(2), /* 76 - L */
604 TKID_ATTR(1) | TKID_ATTR(2), /* 77 - M */
605 TKID_ATTR(1) | TKID_ATTR(2), /* 78 - N */
606 TKID_ATTR(1) | TKID_ATTR(2), /* 79 - O */
607 TKID_ATTR(1) | TKID_ATTR(2), /* 80 - P */
608 TKID_ATTR(1) | TKID_ATTR(2), /* 81 - Q */
609 TKID_ATTR(1) | TKID_ATTR(2), /* 82 - R */
610 TKID_ATTR(1) | TKID_ATTR(2), /* 83 - S */
611 TKID_ATTR(1) | TKID_ATTR(2), /* 84 - T */
612 TKID_ATTR(1) | TKID_ATTR(2), /* 85 - U */
613 TKID_ATTR(1) | TKID_ATTR(2), /* 86 - V */
614 TKID_ATTR(1) | TKID_ATTR(2), /* 87 - W */
615 TKID_ATTR(1) | TKID_ATTR(2), /* 88 - X */
616 TKID_ATTR(1) | TKID_ATTR(2), /* 89 - Y */
617 TKID_ATTR(1) | TKID_ATTR(2), /* 90 - Z */
618 TKID_ATTR(1), /* 91 - [ */
619 TKID_ATTR(1), /* 92 - \ */
620 TKID_ATTR(1), /* 93 - ] */
621 TKID_ATTR(1), /* 94 - ^ */
622 TKID_ATTR(1) | TKID_ATTR(2), /* 95 - _ */
623 TKID_ATTR(1), /* 96 - ` */
624 TKID_ATTR(1) | TKID_ATTR(2), /* 97 - a */
625 TKID_ATTR(1) | TKID_ATTR(2), /* 98 - b */
626 TKID_ATTR(1) | TKID_ATTR(2), /* 99 - c */
627 TKID_ATTR(1) | TKID_ATTR(2), /* 100 - d */
628 TKID_ATTR(1) | TKID_ATTR(2), /* 101 - e */
629 TKID_ATTR(1) | TKID_ATTR(2), /* 102 - f */
630 TKID_ATTR(1) | TKID_ATTR(2), /* 103 - g */
631 TKID_ATTR(1) | TKID_ATTR(2), /* 104 - h */
632 TKID_ATTR(1) | TKID_ATTR(2), /* 105 - i */
633 TKID_ATTR(1) | TKID_ATTR(2), /* 106 - j */
634 TKID_ATTR(1) | TKID_ATTR(2), /* 107 - k */
635 TKID_ATTR(1) | TKID_ATTR(2), /* 108 - l */
636 TKID_ATTR(1) | TKID_ATTR(2), /* 109 - m */
637 TKID_ATTR(1) | TKID_ATTR(2), /* 110 - n */
638 TKID_ATTR(1) | TKID_ATTR(2), /* 111 - o */
639 TKID_ATTR(1) | TKID_ATTR(2), /* 112 - p */
640 TKID_ATTR(1) | TKID_ATTR(2), /* 113 - q */
641 TKID_ATTR(1) | TKID_ATTR(2), /* 114 - r */
642 TKID_ATTR(1) | TKID_ATTR(2), /* 115 - s */
643 TKID_ATTR(1) | TKID_ATTR(2), /* 116 - t */
644 TKID_ATTR(1) | TKID_ATTR(2), /* 117 - u */
645 TKID_ATTR(1) | TKID_ATTR(2), /* 118 - v */
646 TKID_ATTR(1) | TKID_ATTR(2), /* 119 - w */
647 TKID_ATTR(1) | TKID_ATTR(2), /* 120 - x */
648 TKID_ATTR(1) | TKID_ATTR(2), /* 121 - y */
649 TKID_ATTR(1) | TKID_ATTR(2), /* 122 - z */
650 TKID_ATTR_CONT(1), /* 123 - { */
651 TKID_ATTR_CONT(1), /* 124 - | */
652 TKID_ATTR_CONT(1), /* 125 - } */
653 TKID_ATTR(1), /* 126 - ~ */
654 TKID_ATTR_CONT(1), /* 127 - DEL */
655 };
656
657
658 /*
659 * Advance the given string pointer to the next newline character,
660 * or the terminating NULL if there is none.
661 */
662 inline static void
663 advance_to_eol(char **str)
664 {
665 char *s = *str;
666
667 while ((*s != '\n') && (*s != '\0'))
668 s++;
669 *str = s;
670 }
671
672 /*
673 * Insert a NULL patch at the given address
674 */
675 inline static void
676 null_patch_set(char *str, ld_map_npatch_t *np)
677 {
678 np->np_ptr = str;
679 np->np_ch = *str;
680 *str = '\0';
681 }
682
683 /*
684 * Undo a NULL patch
685 */
686 inline static void
687 null_patch_undo(ld_map_npatch_t *np)
688 {
689 *np->np_ptr = np->np_ch;
690 }
691
692 /*
693 * Insert a NULL patch at the end of the line containing str.
694 */
695 static void
696 null_patch_eol(char *str, ld_map_npatch_t *np)
697 {
698 advance_to_eol(&str);
699 null_patch_set(str, np);
700 }
701
702 /*
703 * Locate the end of an unquoted identifier.
704 *
705 * entry:
706 * mf - Mapfile descriptor, positioned to first character
707 * of identifier.
708 *
709 * exit:
710 * If the item pointed at by mf is not an identifier, returns NULL.
711 * Otherwise, returns pointer to character after the last character
712 * of the identifier.
713 */
714 inline static char *
715 ident_delimit(Mapfile *mf)
716 {
717 char *str = mf->mf_next;
718 ld_map_npatch_t np;
719 int c = *str++;
720
721 /* If not a valid start character, report the error */
722 if ((c & 0x80) || !(tkid_attr[c] & mf->mf_tkid_start)) {
723 null_patch_set(str, &np);
724 mf_fatal(mf, MSG_INTL(MSG_MAP_BADCHAR), str);
725 null_patch_undo(&np);
726 return (NULL);
727 }
728
729 /* Keep going until we hit a non-continuing character */
730 for (c = *str; !(c & 0x80) && (tkid_attr[c] & mf->mf_tkid_cont);
731 c = *++str)
732 ;
733
734 return (str);
735 }
736
737 /*
738 * Allocate memory for a stack.
739 *
740 * entry:
741 * stack - Pointer to stack for which memory is required, cast
742 * to the generic stack type.
743 * n_default - Size to use for initial allocation.
744 * elt_size - sizeof(elt), where elt is the actual stack data type.
745 *
746 * exit:
747 * Returns (1) on success. On error (memory allocation), a message
748 * is printed and False (0) is returned.
749 *
750 * note:
751 * The caller casts the pointer to their actual datatype-specific stack
752 * to be a (generic_stack_t *). The C language will give all stack
753 * structs the same size and layout as long as the underlying platform
754 * uses a single integral type for pointers. Hence, this cast is safe,
755 * and lets a generic routine modify data-specific types without being
756 * aware of those types.
757 */
758 static Boolean
759 stack_resize(generic_stack_t *stack, size_t n_default, size_t elt_size)
760 {
761 size_t new_n_alloc;
762 void *newaddr;
763
764 /* Use initial size first, and double the allocation on each call */
765 new_n_alloc = (stack->stk_n_alloc == 0) ?
766 n_default : (stack->stk_n_alloc * 2);
767
768 newaddr = libld_realloc(stack->stk_s, new_n_alloc * elt_size);
769 if (newaddr == NULL)
770 return (FALSE);
771
772 stack->stk_s = newaddr;
773 stack->stk_n_alloc = new_n_alloc;
774 return (TRUE);
775 }
776
777 /*
778 * AVL comparison function for cexp_id_node_t items.
779 *
780 * entry:
781 * n1, n2 - pointers to nodes to be compared
782 *
783 * exit:
784 * Returns -1 if (n1 < n2), 0 if they are equal, and 1 if (n1 > n2)
785 */
786 static int
787 cexp_ident_cmp(const void *n1, const void *n2)
788 {
789 int rc;
790
791 rc = strcmp(((cexp_id_node_t *)n1)->ceid_name,
792 ((cexp_id_node_t *)n2)->ceid_name);
793
794 if (rc > 0)
795 return (1);
796 if (rc < 0)
797 return (-1);
798 return (0);
799 }
800
801
802 /*
803 * Returns True (1) if name is in the conditional expression identifier
804 * AVL tree, and False (0) otherwise.
805 */
806 static int
807 cexp_ident_test(const char *name)
808 {
809 cexp_id_node_t node;
810
811 node.ceid_name = name;
812 return (avl_find(lms.lms_cexp_id, &node, 0) != NULL);
813 }
814
815 /*
816 * Add a new boolean identifier to the conditional expression identifier
817 * AVL tree.
818 *
819 * entry:
820 * mf - If non-NULL, the mapfile descriptor for the mapfile
821 * containing the $add directive. NULL if this is an
822 * initialization call.
823 * name - Name of identifier. Must point at stable storage that will
824 * not be moved or modified by the caller following this call.
825 *
826 * exit:
827 * On success, True (1) is returned and name has been entered.
828 * On failure, False (0) is returned and an error has been printed.
829 */
830 static int
831 cexp_ident_add(Mapfile *mf, const char *name)
832 {
833 cexp_id_node_t *node;
834
835 if (mf != NULL) {
836 DBG_CALL(Dbg_map_cexp_id(mf->mf_ofl->ofl_lml, 1,
837 mf->mf_name, mf->mf_lineno, name));
838
839 /* If is already known, don't do it again */
840 if (cexp_ident_test(name))
841 return (1);
842 }
843
844 if ((node = libld_calloc(sizeof (*node), 1)) == NULL)
845 return (0);
846 node->ceid_name = name;
847 avl_add(lms.lms_cexp_id, node);
848 return (1);
849 }
850
851 /*
852 * Remove a boolean identifier from the conditional expression identifier
853 * AVL tree.
854 *
855 * entry:
856 * mf - Mapfile descriptor
857 * name - Name of identifier.
858 *
859 * exit:
860 * If the name was in the tree, it has been removed. If not,
861 * then this routine quietly returns.
862 */
863 static void
864 cexp_ident_clear(Mapfile *mf, const char *name)
865 {
866 cexp_id_node_t node;
867 cexp_id_node_t *real_node;
868
869 DBG_CALL(Dbg_map_cexp_id(mf->mf_ofl->ofl_lml, 0,
870 mf->mf_name, mf->mf_lineno, name));
871
872 node.ceid_name = name;
873 real_node = avl_find(lms.lms_cexp_id, &node, 0);
874 if (real_node != NULL)
875 avl_remove(lms.lms_cexp_id, real_node);
876 }
877
878 /*
879 * Initialize the AVL tree that holds the names of the currently defined
880 * boolean identifiers for conditional expressions ($if/$elif).
881 *
882 * entry:
883 * ofl - Output file descriptor
884 *
885 * exit:
886 * On success, TRUE (1) is returned and lms.lms_cexp_id is ready for use.
887 * On failure, FALSE (0) is returned.
888 */
889 static Boolean
890 cexp_ident_init(void)
891 {
892 /* If already done, use it */
893 if (lms.lms_cexp_id != NULL)
894 return (TRUE);
895
896 lms.lms_cexp_id = libld_calloc(sizeof (*lms.lms_cexp_id), 1);
897 if (lms.lms_cexp_id == NULL)
898 return (FALSE);
899 avl_create(lms.lms_cexp_id, cexp_ident_cmp, sizeof (cexp_id_node_t),
900 SGSOFFSETOF(cexp_id_node_t, ceid_avlnode));
901
902
903 /* ELFCLASS */
904 if (cexp_ident_add(NULL, (ld_targ.t_m.m_class == ELFCLASS32) ?
905 MSG_ORIG(MSG_STR_UELF32) : MSG_ORIG(MSG_STR_UELF64)) == 0)
906 return (FALSE);
907
908 /* Machine */
909 switch (ld_targ.t_m.m_mach) {
910 case EM_386:
911 case EM_AMD64:
912 if (cexp_ident_add(NULL, MSG_ORIG(MSG_STR_UX86)) == 0)
913 return (FALSE);
914 break;
915
916 case EM_SPARC:
917 case EM_SPARCV9:
918 if (cexp_ident_add(NULL, MSG_ORIG(MSG_STR_USPARC)) == 0)
919 return (FALSE);
920 break;
921 }
922
923 /* true is always defined */
924 if (cexp_ident_add(NULL, MSG_ORIG(MSG_STR_TRUE)) == 0)
925 return (FALSE);
926
927 return (TRUE);
928 }
929
930 /*
931 * Validate the string starting at mf->mf_next as being a
932 * boolean conditional expression identifier.
933 *
934 * entry:
935 * mf - Mapfile descriptor
936 * len - NULL, or address of variable to receive strlen() of identifier
937 * directive - If (len == NULL), string giving name of directive being
938 * processed. Ignored if (len != NULL).
939 *
940 * exit:
941 * On success:
942 * - If len is NULL, a NULL is inserted following the final
943 * character of the identifier, and the remainder of the string
944 * is tested to ensure it is empty, or only contains whitespace.
945 * - If len is non-NULL, *len is set to the number of characters
946 * in the identifier, and the rest of the string is not modified.
947 * - TRUE (1) is returned
948 *
949 * On failure, returns FALSE (0).
950 */
951 static Boolean
952 cexp_ident_validate(Mapfile *mf, size_t *len, const char *directive)
953 {
954 char *tail;
955
956 if ((tail = ident_delimit(mf)) == NULL)
957 return (FALSE);
958
959 /*
960 * If len is non-NULL, we simple count the number of characters
961 * consumed by the identifier and are done. If len is NULL, then
962 * ensure there's nothing left but whitespace, and NULL terminate
963 * the identifier to remove it.
964 */
965 if (len != NULL) {
966 *len = tail - mf->mf_next;
967 } else if (*tail != '\0') {
968 *tail++ = '\0';
969 while (isspace(*tail))
970 tail++;
971 if (*tail != '\0') {
972 mf_fatal(mf, MSG_INTL(MSG_MAP_BADEXTRA), directive);
973 return (FALSE);
974 }
975 }
976
977 return (TRUE);
978 }
979
980 /*
981 * Push a new operator onto the conditional expression operator stack.
982 *
983 * entry:
984 * mf - Mapfile descriptor
985 * op - Operator to push
986 *
987 * exit:
988 * On success, TRUE (1) is returned, otherwise FALSE (0).
989 */
990 static Boolean
991 cexp_push_op(cexp_op_t op)
992 {
993 if (STACK_RESERVE(lms.lms_cexp_op_stack, CEXP_OP_STACK_INIT) == 0)
994 return (FALSE);
995
996 STACK_PUSH(lms.lms_cexp_op_stack) = op;
997 return (TRUE);
998 }
999
1000 /*
1001 * Evaluate the basic operator (non-paren) at the top of lms.lms_cexp_op_stack,
1002 * and push the results on lms.lms_cexp_val_stack.
1003 *
1004 * exit:
1005 * On success, returns TRUE (1). On error, FALSE (0) is returned,
1006 * and the caller is responsible for issuing the error.
1007 */
1008 static Boolean
1009 cexp_eval_op(void)
1010 {
1011 cexp_op_t op;
1012 uchar_t val;
1013
1014 op = STACK_POP(lms.lms_cexp_op_stack);
1015 switch (op) {
1016 case CEXP_OP_AND:
1017 if (lms.lms_cexp_val_stack.stk_n < 2)
1018 return (FALSE);
1019 val = STACK_POP(lms.lms_cexp_val_stack);
1020 STACK_TOP(lms.lms_cexp_val_stack) = val &&
1021 STACK_TOP(lms.lms_cexp_val_stack);
1022 break;
1023
1024 case CEXP_OP_OR:
1025 if (lms.lms_cexp_val_stack.stk_n < 2)
1026 return (FALSE);
1027 val = STACK_POP(lms.lms_cexp_val_stack);
1028 STACK_TOP(lms.lms_cexp_val_stack) = val ||
1029 STACK_TOP(lms.lms_cexp_val_stack);
1030 break;
1031
1032 case CEXP_OP_NEG:
1033 if (lms.lms_cexp_val_stack.stk_n < 1)
1034 return (FALSE);
1035 STACK_TOP(lms.lms_cexp_val_stack) =
1036 !STACK_TOP(lms.lms_cexp_val_stack);
1037 break;
1038 default:
1039 return (FALSE);
1040 }
1041
1042 return (TRUE);
1043 }
1044
1045 /*
1046 * Evaluate an expression for a $if/$elif control directive.
1047 *
1048 * entry:
1049 * mf - Mapfile descriptor for NULL terminated string
1050 * containing the expression.
1051 *
1052 * exit:
1053 * The contents of str are modified by this routine.
1054 * One of the following values are returned:
1055 * -1 Syntax error encountered (an error is printed)
1056 * 0 The expression evaluates to False
1057 * 1 The expression evaluates to True.
1058 *
1059 * note:
1060 * A simplified version of Dijkstra's Shunting Yard algorithm is used
1061 * to convert this syntax into postfix form and then evaluate it.
1062 * Our version has no functions and a tiny set of operators.
1063 *
1064 * The expressions consist of boolean identifiers, which can be
1065 * combined using the following operators, listed from highest
1066 * precedence to least:
1067 *
1068 * Operator Meaning
1069 * -------------------------------------------------
1070 * (expr) sub-expression, non-associative
1071 * ! logical negation, prefix, left associative
1072 * && || logical and/or, binary, left associative
1073 *
1074 * The operands manipulated by these operators are names, consisting of
1075 * a sequence of letters and digits. The first character must be a letter.
1076 * Underscore (_) and period (.) are also considered to be characters.
1077 * An operand is considered True if it is found in our set of known
1078 * names (lms.lms_cexp_id), and False otherwise.
1079 *
1080 * The Shunting Yard algorithm works using two stacks, one for operators,
1081 * and a second for operands. The infix input expression is tokenized from
1082 * left to right and processed in order. Issues of associativity and
1083 * precedence are managed by reducing (poping and evaluating) items with
1084 * higer precedence before pushing additional tokens with lower precedence.
1085 */
1086 static int
1087 cexp_eval_expr(Mapfile *mf)
1088 {
1089 char *ident;
1090 size_t len;
1091 cexp_op_t new_op = CEXP_OP_AND; /* to catch binop at start */
1092 ld_map_npatch_t np;
1093 char *str = mf->mf_next;
1094
1095 STACK_RESET(lms.lms_cexp_op_stack);
1096 STACK_RESET(lms.lms_cexp_val_stack);
1097
1098 for (; *str; str++) {
1099
1100 /* Skip whitespace */
1101 while (isspace(*str))
1102 str++;
1103 if (!*str)
1104 break;
1105
1106 switch (*str) {
1107 case '&':
1108 case '|':
1109 if (*(str + 1) != *str)
1110 goto token_error;
1111 if ((new_op != CEXP_OP_NONE) &&
1112 (new_op != CEXP_OP_CPAR)) {
1113 mf_fatal0(mf, MSG_INTL(MSG_MAP_CEXP_BADOPUSE));
1114 return (-1);
1115 }
1116 str++;
1117
1118 /*
1119 * As this is a left associative binary operator, we
1120 * need to process all operators of equal or higher
1121 * precedence before pushing the new operator.
1122 */
1123 while (!STACK_IS_EMPTY(lms.lms_cexp_op_stack)) {
1124 cexp_op_t op = STACK_TOP(lms.lms_cexp_op_stack);
1125
1126
1127 if ((op != CEXP_OP_AND) && (op != CEXP_OP_OR) &&
1128 (op != CEXP_OP_NEG))
1129 break;
1130
1131 if (!cexp_eval_op())
1132 goto semantic_error;
1133 }
1134
1135 new_op = (*str == '&') ? CEXP_OP_AND : CEXP_OP_OR;
1136 if (!cexp_push_op(new_op))
1137 return (-1);
1138 break;
1139
1140 case '!':
1141 new_op = CEXP_OP_NEG;
1142 if (!cexp_push_op(new_op))
1143 return (-1);
1144 break;
1145
1146 case '(':
1147 new_op = CEXP_OP_OPAR;
1148 if (!cexp_push_op(new_op))
1149 return (-1);
1150 break;
1151
1152 case ')':
1153 new_op = CEXP_OP_CPAR;
1154
1155 /* Evaluate the operator stack until reach '(' */
1156 while (!STACK_IS_EMPTY(lms.lms_cexp_op_stack) &&
1157 (STACK_TOP(lms.lms_cexp_op_stack) != CEXP_OP_OPAR))
1158 if (!cexp_eval_op())
1159 goto semantic_error;
1160
1161 /*
1162 * If the top of operator stack is not an open paren,
1163 * when we have an error. In this case, the operator
1164 * stack will be empty due to the loop above.
1165 */
1166 if (STACK_IS_EMPTY(lms.lms_cexp_op_stack))
1167 goto unbalpar_error;
1168 lms.lms_cexp_op_stack.stk_n--; /* Pop OPAR */
1169 break;
1170
1171 default:
1172 /* Ensure there's room to push another operand */
1173 if (STACK_RESERVE(lms.lms_cexp_val_stack,
1174 CEXP_VAL_STACK_INIT) == 0)
1175 return (0);
1176 new_op = CEXP_OP_NONE;
1177
1178 /*
1179 * Operands cannot be numbers. However, we accept two
1180 * special cases: '0' means false, and '1' is true.
1181 * This is done to support the common C idiom of
1182 * '#if 1' and '#if 0' to conditionalize code under
1183 * development.
1184 */
1185 if ((*str == '0') || (*str == '1')) {
1186 STACK_PUSH(lms.lms_cexp_val_stack) =
1187 (*str == '1');
1188 break;
1189 }
1190
1191 /* Look up the identifier */
1192 ident = mf->mf_next = str;
1193 if (!cexp_ident_validate(mf, &len, NULL))
1194 return (-1);
1195 str += len - 1; /* loop will advance past final ch */
1196 null_patch_set(&ident[len], &np);
1197 STACK_PUSH(lms.lms_cexp_val_stack) =
1198 cexp_ident_test(ident);
1199 null_patch_undo(&np);
1200
1201 break;
1202 }
1203 }
1204
1205 /* Evaluate the operator stack until empty */
1206 while (!STACK_IS_EMPTY(lms.lms_cexp_op_stack)) {
1207 if (STACK_TOP(lms.lms_cexp_op_stack) == CEXP_OP_OPAR)
1208 goto unbalpar_error;
1209
1210 if (!cexp_eval_op())
1211 goto semantic_error;
1212 }
1213
1214 /* There should be exactly one value left */
1215 if (lms.lms_cexp_val_stack.stk_n != 1)
1216 goto semantic_error;
1217
1218 /* Final value is the result */
1219 return (lms.lms_cexp_val_stack.stk_s[0]);
1220
1221 /* Errors issued more than once are handled below, accessed via goto */
1222
1223 token_error: /* unexpected characters in input stream */
1224 mf_fatal(mf, MSG_INTL(MSG_MAP_CEXP_TOKERR), str);
1225 return (-1);
1226
1227 semantic_error: /* valid tokens, but in invalid arrangement */
1228 mf_fatal0(mf, MSG_INTL(MSG_MAP_CEXP_SEMERR));
1229 return (-1);
1230
1231 unbalpar_error: /* Extra or missing parenthesis */
1232 mf_fatal0(mf, MSG_INTL(MSG_MAP_CEXP_UNBALPAR));
1233 return (-1);
1234 }
1235
1236 /*
1237 * Process a mapfile control directive. These directives start with
1238 * the dollar character, and are used to manage details of the mapfile
1239 * itself, such as version and conditional input.
1240 *
1241 * entry:
1242 * mf - Mapfile descriptor
1243 *
1244 * exit:
1245 * Returns TRUE (1) for success, and FALSE (0) on error. In the
1246 * error case, a descriptive error is issued.
1247 */
1248 static Boolean
1249 cdir_process(Mapfile *mf)
1250 {
1251 typedef enum { /* Directive types */
1252 CDIR_T_UNKNOWN = 0, /* Unrecognized control directive */
1253 CDIR_T_ADD, /* $add */
1254 CDIR_T_CLEAR, /* $clear */
1255 CDIR_T_ERROR, /* $error */
1256 CDIR_T_VERSION, /* $mapfile_version */
1257 CDIR_T_IF, /* $if */
1258 CDIR_T_ELIF, /* $elif */
1259 CDIR_T_ELSE, /* $else */
1260 CDIR_T_ENDIF, /* $endif */
1261 } cdir_t;
1262
1263 typedef enum { /* Types of arguments accepted by directives */
1264 ARG_T_NONE, /* Directive takes no arguments */
1265 ARG_T_EXPR, /* Directive takes a conditional expression */
1266 ARG_T_ID, /* Conditional expression identifier */
1267 ARG_T_STR, /* Non-empty string */
1268 ARG_T_IGN /* Ignore the argument */
1269 } cdir_arg_t;
1270
1271 typedef struct {
1272 const char *md_name; /* Directive name */
1273 size_t md_size; /* strlen(md_name) */
1274 cdir_arg_t md_arg; /* Type of arguments */
1275 cdir_t md_op; /* CDIR_T_ code */
1276 } cdir_match_t;
1277
1278 /* Control Directives: The most likely items are listed first */
1279 static cdir_match_t match_data[] = {
1280 { MSG_ORIG(MSG_STR_CDIR_IF), MSG_STR_CDIR_IF_SIZE,
1281 ARG_T_EXPR, CDIR_T_IF },
1282 { MSG_ORIG(MSG_STR_CDIR_ENDIF), MSG_STR_CDIR_ENDIF_SIZE,
1283 ARG_T_NONE, CDIR_T_ENDIF },
1284 { MSG_ORIG(MSG_STR_CDIR_ELSE), MSG_STR_CDIR_ELSE_SIZE,
1285 ARG_T_NONE, CDIR_T_ELSE },
1286 { MSG_ORIG(MSG_STR_CDIR_ELIF), MSG_STR_CDIR_ELIF_SIZE,
1287 ARG_T_EXPR, CDIR_T_ELIF },
1288 { MSG_ORIG(MSG_STR_CDIR_ERROR), MSG_STR_CDIR_ERROR_SIZE,
1289 ARG_T_STR, CDIR_T_ERROR },
1290 { MSG_ORIG(MSG_STR_CDIR_ADD), MSG_STR_CDIR_ADD_SIZE,
1291 ARG_T_ID, CDIR_T_ADD },
1292 { MSG_ORIG(MSG_STR_CDIR_CLEAR), MSG_STR_CDIR_CLEAR_SIZE,
1293 ARG_T_ID, CDIR_T_CLEAR },
1294 { MSG_ORIG(MSG_STR_CDIR_MFVER), MSG_STR_CDIR_MFVER_SIZE,
1295 ARG_T_IGN, CDIR_T_VERSION },
1296
1297 { NULL, 0,
1298 ARG_T_IGN, CDIR_T_UNKNOWN }
1299 };
1300
1301 cdir_match_t *mdptr;
1302 char *tail;
1303 int expr_eval; /* Result of evaluating ARG_T_EXPR */
1304 Mapfile arg_mf;
1305 cdir_level_t *level;
1306 int pass, parent_pass; /* Currently accepting input */
1307
1308 restart:
1309 /* Is the immediate context passing input? */
1310 pass = STACK_IS_EMPTY(lms.lms_cdir_stack) ||
1311 STACK_TOP(lms.lms_cdir_stack).cdl_pass;
1312
1313 /* Is the surrounding (parent) context passing input? */
1314 parent_pass = (lms.lms_cdir_stack.stk_n <= 1) ||
1315 lms.lms_cdir_stack.stk_s[lms.lms_cdir_stack.stk_n - 2].cdl_pass;
1316
1317
1318 for (mdptr = match_data; mdptr->md_name; mdptr++) {
1319 /* Prefix must match, or we move on */
1320 if (strncmp(mf->mf_next, mdptr->md_name,
1321 mdptr->md_size) != 0)
1322 continue;
1323 tail = mf->mf_next + mdptr->md_size;
1324
1325 /*
1326 * If there isn't whitespace, or a NULL terminator following
1327 * the prefix, then even though our prefix matched, the actual
1328 * token is longer, and we don't have a match.
1329 */
1330 if (!isspace(*tail) && (*tail != '\0'))
1331 continue;
1332
1333 /* We have matched a valid control directive */
1334 break;
1335 }
1336
1337 /* Advance input to end of the current line */
1338 advance_to_eol(&mf->mf_next);
1339
1340 /*
1341 * Set up a temporary mapfile descriptor to reference the
1342 * argument string. The benefit of this second block, is that
1343 * we can advance the real one to the next line now, which allows
1344 * us to return at any time knowing that the input has been moved
1345 * to the proper spot. This simplifies the error cases.
1346 *
1347 * If we had a match, tail points at the start of the string.
1348 * Otherwise, we want to point at the end of the line.
1349 */
1350 arg_mf = *mf;
1351 if (mdptr->md_name == NULL)
1352 arg_mf.mf_text = arg_mf.mf_next;
1353 else
1354 arg_mf.mf_text = arg_mf.mf_next = tail;
1355
1356 /*
1357 * Null terminate the arguments, and advance the main mapfile
1358 * state block to the next line.
1359 */
1360 if (*mf->mf_next == '\n') {
1361 *mf->mf_next++ = '\0';
1362 mf->mf_lineno++;
1363 }
1364
1365 /* Skip leading whitespace to arguments */
1366 while (isspace(*arg_mf.mf_next))
1367 arg_mf.mf_next++;
1368
1369 /* Strip off any comment present on the line */
1370 for (tail = arg_mf.mf_next; *tail; tail++)
1371 if (*tail == '#') {
1372 *tail = '\0';
1373 break;
1374 }
1375
1376 /*
1377 * Process the arguments as necessary depending on their type.
1378 * If this control directive is nested inside a surrounding context
1379 * that is not currently passing text, then we skip the argument
1380 * evaluation. This follows the behavior of the C preprocessor,
1381 * which only examines enough to detect the operation within
1382 * a disabled section, without issuing errors about the arguments.
1383 */
1384 if (pass || (parent_pass && (mdptr->md_op == CDIR_T_ELIF))) {
1385 switch (mdptr->md_arg) {
1386 case ARG_T_NONE:
1387 if (*arg_mf.mf_next == '\0')
1388 break;
1389 /* Args are present, but not wanted */
1390 mf_fatal(&arg_mf, MSG_INTL(MSG_MAP_CDIR_REQNOARG),
1391 mdptr->md_name);
1392 return (FALSE);
1393
1394 case ARG_T_EXPR:
1395 /* Ensure that arguments are present */
1396 if (*arg_mf.mf_next == '\0')
1397 goto error_reqarg;
1398 expr_eval = cexp_eval_expr(&arg_mf);
1399 if (expr_eval == -1)
1400 return (FALSE);
1401 break;
1402
1403 case ARG_T_ID:
1404 /* Ensure that arguments are present */
1405 if (*arg_mf.mf_next == '\0')
1406 goto error_reqarg;
1407 if (!cexp_ident_validate(&arg_mf, NULL,
1408 mdptr->md_name))
1409 return (FALSE);
1410 break;
1411
1412 case ARG_T_STR:
1413 /* Ensure that arguments are present */
1414 if (*arg_mf.mf_next == '\0')
1415 goto error_reqarg;
1416 /* Remove trailing whitespace */
1417 tail = arg_mf.mf_next + strlen(arg_mf.mf_next);
1418 while ((tail > arg_mf.mf_next) &&
1419 isspace(*(tail -1)))
1420 tail--;
1421 *tail = '\0';
1422 break;
1423 }
1424 }
1425
1426 /*
1427 * Carry out the specified control directive:
1428 */
1429 if (!STACK_IS_EMPTY(lms.lms_cdir_stack))
1430 level = &STACK_TOP(lms.lms_cdir_stack);
1431
1432 switch (mdptr->md_op) {
1433 case CDIR_T_UNKNOWN: /* Unrecognized control directive */
1434 if (!pass)
1435 break;
1436 mf_fatal0(&arg_mf, MSG_INTL(MSG_MAP_CDIR_BAD));
1437 return (FALSE);
1438
1439 case CDIR_T_ADD:
1440 if (pass && !cexp_ident_add(&arg_mf, arg_mf.mf_next))
1441 return (FALSE);
1442 break;
1443
1444 case CDIR_T_CLEAR:
1445 if (pass)
1446 cexp_ident_clear(&arg_mf, arg_mf.mf_next);
1447 break;
1448
1449 case CDIR_T_ERROR:
1450 if (!pass)
1451 break;
1452 mf_fatal(&arg_mf, MSG_INTL(MSG_MAP_CDIR_ERROR),
1453 arg_mf.mf_next);
1454 return (FALSE);
1455
1456 case CDIR_T_VERSION:
1457 /*
1458 * A $mapfile_version control directive can only appear
1459 * as the first directive in a mapfile, and is used to
1460 * determine the syntax for the rest of the file. It's
1461 * too late to be using it here.
1462 */
1463 if (!pass)
1464 break;
1465 mf_fatal0(&arg_mf, MSG_INTL(MSG_MAP_CDIR_REPVER));
1466 return (FALSE);
1467
1468 case CDIR_T_IF:
1469 /* Push a new level on the conditional input stack */
1470 if (STACK_RESERVE(lms.lms_cdir_stack, CDIR_STACK_INIT) == 0)
1471 return (FALSE);
1472 level = &lms.lms_cdir_stack.stk_s[lms.lms_cdir_stack.stk_n++];
1473 level->cdl_if_lineno = arg_mf.mf_lineno;
1474 level->cdl_else_lineno = 0;
1475
1476 /*
1477 * If previous level is not passing, this level is disabled.
1478 * Otherwise, the expression value determines what happens.
1479 */
1480 if (pass) {
1481 level->cdl_done = level->cdl_pass = expr_eval;
1482 } else {
1483 level->cdl_done = 1;
1484 level->cdl_pass = 0;
1485 }
1486 break;
1487
1488 case CDIR_T_ELIF:
1489 /* $elif requires an open $if construct */
1490 if (STACK_IS_EMPTY(lms.lms_cdir_stack)) {
1491 mf_fatal(&arg_mf, MSG_INTL(MSG_MAP_CDIR_NOIF),
1492 MSG_ORIG(MSG_STR_CDIR_ELIF));
1493 return (FALSE);
1494 }
1495
1496 /* $elif cannot follow $else */
1497 if (level->cdl_else_lineno > 0) {
1498 mf_fatal(&arg_mf, MSG_INTL(MSG_MAP_CDIR_ELSE),
1499 MSG_ORIG(MSG_STR_CDIR_ELIF),
1500 EC_LINENO(level->cdl_else_lineno));
1501 return (FALSE);
1502 }
1503
1504 /*
1505 * Accept text from $elif if the level isn't already
1506 * done and the expression evaluates to true.
1507 */
1508 level->cdl_pass = !level->cdl_done && expr_eval;
1509 if (level->cdl_pass)
1510 level->cdl_done = 1;
1511 break;
1512
1513 case CDIR_T_ELSE:
1514 /* $else requires an open $if construct */
1515 if (STACK_IS_EMPTY(lms.lms_cdir_stack)) {
1516 mf_fatal(&arg_mf, MSG_INTL(MSG_MAP_CDIR_NOIF),
1517 MSG_ORIG(MSG_STR_CDIR_ELSE));
1518 return (FALSE);
1519 }
1520
1521 /* There can only be one $else in the chain */
1522 if (level->cdl_else_lineno > 0) {
1523 mf_fatal(&arg_mf, MSG_INTL(MSG_MAP_CDIR_ELSE),
1524 MSG_ORIG(MSG_STR_CDIR_ELSE),
1525 EC_LINENO(level->cdl_else_lineno));
1526 return (FALSE);
1527 }
1528 level->cdl_else_lineno = arg_mf.mf_lineno;
1529
1530 /* Accept text from $else if the level isn't already done */
1531 level->cdl_pass = !level->cdl_done;
1532 level->cdl_done = 1;
1533 break;
1534
1535 case CDIR_T_ENDIF:
1536 /* $endif requires an open $if construct */
1537 if (STACK_IS_EMPTY(lms.lms_cdir_stack)) {
1538 mf_fatal(&arg_mf, MSG_INTL(MSG_MAP_CDIR_NOIF),
1539 MSG_ORIG(MSG_STR_CDIR_ENDIF));
1540 return (FALSE);
1541 }
1542 if (--lms.lms_cdir_stack.stk_n > 0)
1543 level = &STACK_TOP(lms.lms_cdir_stack);
1544 break;
1545
1546 default:
1547 return (FALSE);
1548 }
1549
1550 /* Evaluating the control directive above can change pass status */
1551 expr_eval = STACK_IS_EMPTY(lms.lms_cdir_stack) ||
1552 STACK_TOP(lms.lms_cdir_stack).cdl_pass;
1553 if (expr_eval != pass) {
1554 pass = expr_eval;
1555 DBG_CALL(Dbg_map_pass(arg_mf.mf_ofl->ofl_lml, pass,
1556 arg_mf.mf_name, arg_mf.mf_lineno, mdptr->md_name));
1557 }
1558
1559 /*
1560 * At this point, we have processed a control directive,
1561 * updated our conditional state stack, and the input is
1562 * positioned at the start of the line following the directive.
1563 * If the current level is accepting input, then give control
1564 * back to ld_map_gettoken() to resume its normal operation.
1565 */
1566 if (pass)
1567 return (TRUE);
1568
1569 /*
1570 * The current level is not accepting input. Only another
1571 * control directive can change this, so read and discard input
1572 * until we encounter one of the following:
1573 *
1574 * EOF: Return and let ld_map_gettoken() report it
1575 * Control Directive: Restart this function / evaluate new directive
1576 */
1577 while (*mf->mf_next != '\0') {
1578 /* Skip leading whitespace */
1579 while (isspace_nonl(*mf->mf_next))
1580 mf->mf_next++;
1581
1582 /*
1583 * Control directives start with a '$'. If we hit
1584 * one, restart the function at this point
1585 */
1586 if (*mf->mf_next == '$')
1587 goto restart;
1588
1589 /* Not a control directive, so advance input to next line */
1590 advance_to_eol(&mf->mf_next);
1591 if (*mf->mf_next == '\n') {
1592 mf->mf_lineno++;
1593 mf->mf_next++;
1594 }
1595 }
1596
1597 assert(*mf->mf_next == '\0');
1598 return (TRUE);
1599
1600 /*
1601 * Control directives that require an argument that is not present
1602 * jump here to report the error and exit.
1603 */
1604 error_reqarg:
1605 mf_fatal(&arg_mf, MSG_INTL(MSG_MAP_CDIR_REQARG), mdptr->md_name);
1606 return (FALSE);
1607
1608 }
1609
1610 #ifndef _ELF64
1611 /*
1612 * Convert a string to lowercase.
1613 */
1614 void
1615 ld_map_lowercase(char *str)
1616 {
1617 while (*str = tolower(*str))
1618 str++;
1619 }
1620 #endif
1621
1622 /*
1623 * Wrappper on strtoul()/strtoull(), adapted to return an Xword.
1624 *
1625 * entry:
1626 * str - Pointer to string to be converted.
1627 * endptr - As documented for strtoul(3C). Either NULL, or
1628 * address of pointer to receive the address of the first
1629 * unused character in str (called "final" in strtoul(3C)).
1630 * ret_value - Address of Xword variable to receive result.
1631 *
1632 * exit:
1633 * On success, *ret_value receives the result, *endptr is updated if
1634 * endptr is non-NULL, and STRTOXWORD_OK is returned.
1635 * On failure, STRTOXWORD_TOBIG is returned if an otherwise valid
1636 * value was too large, and STRTOXWORD_BAD is returned if the string
1637 * is malformed.
1638 */
1639 ld_map_strtoxword_t
1640 ld_map_strtoxword(const char *restrict str, char **restrict endptr,
1641 Xword *ret_value)
1642 {
1643 #if defined(_ELF64) /* _ELF64 */
1644 #define FUNC strtoull /* Function to use */
1645 #define FUNC_MAX ULLONG_MAX /* Largest value returned by FUNC */
1646 #define XWORD_MAX ULLONG_MAX /* Largest Xword value */
1647 uint64_t value; /* Variable of FUNC return type */
1648 #else /* _ELF32 */
1649 #define FUNC strtoul
1650 #define FUNC_MAX ULONG_MAX
1651 #define XWORD_MAX UINT_MAX
1652 ulong_t value;
1653 #endif
1654
1655 char *endptr_local; /* Used if endptr is NULL */
1656
1657 if (endptr == NULL)
1658 endptr = &endptr_local;
1659
1660 errno = 0;
1661 value = FUNC(str, endptr, 0);
1662 if ((errno != 0) || (str == *endptr)) {
1663 if (value == FUNC_MAX)
1664 return (STRTOXWORD_TOOBIG);
1665 else
1666 return (STRTOXWORD_BAD);
1667 }
1668
1669 /*
1670 * If this is a 64-bit linker building an ELFCLASS32 object,
1671 * the FUNC return type is a 64-bit value, while an Xword is
1672 * 32-bit. It is possible for FUNC to be able to convert a value
1673 * too large for our return type.
1674 */
1675 #if FUNC_MAX != XWORD_MAX
1676 if (value > XWORD_MAX)
1677 return (STRTOXWORD_TOOBIG);
1678 #endif
1679
1680 *ret_value = value;
1681 return (STRTOXWORD_OK);
1682
1683 #undef FUNC
1684 #undef FUNC_MAX
1685 #undef XWORD_MAC
1686 }
1687
1688 /*
1689 * Convert the unsigned integer value at the current mapfile input
1690 * into binary form. All numeric values in mapfiles are treated as
1691 * unsigned integers of the appropriate width for an address on the
1692 * given target. Values can be decimal, hex, or octal.
1693 *
1694 * entry:
1695 * str - String to process.
1696 * value - Address of variable to receive resulting value.
1697 * notail - If TRUE, an error is issued if non-whitespace
1698 * characters other than '#' (comment) are found following
1699 * the numeric value before the end of line.
1700 *
1701 * exit:
1702 * On success:
1703 * - *str is advanced to the next character following the value
1704 * - *value receives the value
1705 * - Returns TRUE (1).
1706 * On failure, returns FALSE (0).
1707 */
1708 static Boolean
1709 ld_map_getint(Mapfile *mf, ld_map_tkval_t *value, Boolean notail)
1710 {
1711 ld_map_strtoxword_t s2xw_ret;
1712 ld_map_npatch_t np;
1713 char *endptr;
1714 char *errstr = mf->mf_next;
1715
1716 value->tkv_int.tkvi_str = mf->mf_next;
1717 s2xw_ret = ld_map_strtoxword(mf->mf_next, &endptr,
1718 &value->tkv_int.tkvi_value);
1719 if (s2xw_ret != STRTOXWORD_OK) {
1720 null_patch_eol(mf->mf_next, &np);
1721 if (s2xw_ret == STRTOXWORD_TOOBIG)
1722 mf_fatal(mf, MSG_INTL(MSG_MAP_VALUELIMIT), errstr);
1723 else
1724 mf_fatal(mf, MSG_INTL(MSG_MAP_MALVALUE), errstr);
1725 null_patch_undo(&np);
1726 return (FALSE);
1727 }
1728
1729 /* Advance position to item following value, skipping whitespace */
1730 value->tkv_int.tkvi_cnt = endptr - mf->mf_next;
1731 mf->mf_next = endptr;
1732 while (isspace_nonl(*mf->mf_next))
1733 mf->mf_next++;
1734
1735 /* If requested, ensure there's nothing left */
1736 if (notail && (*mf->mf_next != '\n') && (*mf->mf_next != '#') &&
1737 (*mf->mf_next != '\0')) {
1738 null_patch_eol(mf->mf_next, &np);
1739 mf_fatal(mf, MSG_INTL(MSG_MAP_BADVALUETAIL), errstr);
1740 null_patch_undo(&np);
1741 return (FALSE);
1742 }
1743
1744 return (TRUE);
1745 }
1746
1747 /*
1748 * Convert a an unquoted identifier into a TK_STRING token, using the
1749 * rules for syntax version in use. Used exclusively by ld_map_gettoken().
1750 *
1751 * entry:
1752 * mf - Mapfile descriptor, positioned to the first character of
1753 * the string.
1754 * flags - Bitmask of options to control ld_map_gettoken()s behavior
1755 * tkv- Address of pointer to variable to receive token value.
1756 *
1757 * exit:
1758 * On success, mf is advanced past the token, tkv is updated with
1759 * the string, and TK_STRING is returned. On error, TK_ERROR is returned.
1760 */
1761 inline static Token
1762 gettoken_ident(Mapfile *mf, int flags, ld_map_tkval_t *tkv)
1763 {
1764 char *end;
1765 Token tok;
1766 ld_map_npatch_t np;
1767
1768 tkv->tkv_str = mf->mf_next;
1769 if ((end = ident_delimit(mf)) == NULL)
1770 return (TK_ERROR);
1771 mf->mf_next = end;
1772
1773 /*
1774 * One advantage of reading the entire mapfile into memory is that
1775 * we can access the strings within it without having to allocate
1776 * more memory or make copies. In order to do that, we need to NULL
1777 * terminate this identifier. That is going to overwrite the
1778 * following character. The problem this presents is that the next
1779 * character may well be the first character of a subsequent token.
1780 * The solution to this is:
1781 *
1782 * 1) Disallow the case where the next character is able to
1783 * start a string. This is not legal mapfile syntax anyway,
1784 * so catching it here simplifies matters.
1785 * 2) Copy the character into the special mf->mf_next_ch
1786 * 3) The next call to ld_map_gettoken() checks mf->mf_next_ch,
1787 * and if it is non-0, uses it instead of dereferencing the
1788 * mf_next pointer.
1789 */
1790 tok = (*mf->mf_next & 0x80) ?
1791 TK_OP_ILLCHR : mf->mf_tokdisp[*mf->mf_next];
1792 switch (tok) {
1793 case TK_OP_BADCHR:
1794 null_patch_eol(mf->mf_next, &np);
1795 mf_fatal(mf, MSG_INTL(MSG_MAP_BADCHAR), mf->mf_next);
1796 null_patch_undo(&np);
1797 return (TK_ERROR);
1798
1799 case TK_OP_SIMQUOTE:
1800 case TK_OP_CQUOTE:
1801 case TK_OP_CDIR:
1802 case TK_OP_NUM:
1803 case TK_OP_ID:
1804 null_patch_eol(mf->mf_next, &np);
1805 mf_fatal(mf, MSG_INTL(MSG_MAP_WSNEEDED), mf->mf_next);
1806 null_patch_undo(&np);
1807 return (TK_ERROR);
1808 }
1809
1810 /* Null terminate, saving the replaced character */
1811 mf->mf_next_ch = *mf->mf_next;
1812 *mf->mf_next = '\0';
1813
1814 if (flags & TK_F_STRLC)
1815 ld_map_lowercase(tkv->tkv_str);
1816 return (TK_STRING);
1817 }
1818
1819 /*
1820 * Convert a quoted string into a TK_STRING token, using simple
1821 * quoting rules:
1822 * - Start and end quotes must be present and match
1823 * - There are no special characters or escape sequences.
1824 * This function is used exclusively by ld_map_gettoken().
1825 *
1826 * entry:
1827 * mf - Mapfile descriptor, positioned to the opening quote character.
1828 * flags - Bitmask of options to control ld_map_gettoken()s behavior
1829 * tkv- Address of pointer to variable to receive token value.
1830 *
1831 * exit:
1832 * On success, mf is advanced past the token, tkv is updated with
1833 * the string, and TK_STRING is returned. On error, TK_ERROR is returned.
1834 */
1835 inline static Token
1836 gettoken_simquote_str(Mapfile *mf, int flags, ld_map_tkval_t *tkv)
1837 {
1838 char *str, *end;
1839 char quote;
1840
1841 str = mf->mf_next++;
1842 quote = *str;
1843 end = mf->mf_next;
1844 while ((*end != '\0') && (*end != '\n') && (*end != quote))
1845 end++;
1846 if (*end != quote) {
1847 ld_map_npatch_t np;
1848
1849 null_patch_eol(end, &np);
1850 mf_fatal(mf, MSG_INTL(MSG_MAP_NOTERM), str);
1851 null_patch_undo(&np);
1852 return (TK_ERROR);
1853 }
1854
1855 /*
1856 * end is pointing at the closing quote. We can turn that into NULL
1857 * termination for the string without needing to restore it later.
1858 */
1859 *end = '\0';
1860 mf->mf_next = end + 1;
1861 tkv->tkv_str = str + 1; /* Skip opening quote */
1862 if (flags & TK_F_STRLC)
1863 ld_map_lowercase(tkv->tkv_str);
1864 return (TK_STRING);
1865 }
1866
1867 /*
1868 * Convert a quoted string into a TK_STRING token, using C string literal
1869 * quoting rules:
1870 * - Start and end quotes must be present and match
1871 * - Backslash is an escape, used to introduce special characters
1872 * This function is used exclusively by ld_map_gettoken().
1873 *
1874 * entry:
1875 * mf - Mapfile descriptor, positioned to the opening quote character.
1876 * flags - Bitmask of options to control ld_map_gettoken()s behavior
1877 * tkv- Address of pointer to variable to receive token value.
1878 *
1879 * exit:
1880 * On success, mf is advanced past the token, tkv is updated with
1881 * the string, and TK_STRING is returned. On error, TK_ERROR is returned.
1882 */
1883 inline static Token
1884 gettoken_cquote_str(Mapfile *mf, int flags, ld_map_tkval_t *tkv)
1885 {
1886 char *str, *cur, *end;
1887 char quote;
1888 int c;
1889
1890 /*
1891 * This function goes through the quoted string and copies
1892 * it on top of itself, replacing escape sequences with the
1893 * characters they denote. There is always enough room for this,
1894 * because escapes are multi-character sequences that are converted
1895 * to single character results.
1896 */
1897 str = mf->mf_next++;
1898 quote = *str;
1899 cur = end = mf->mf_next;
1900 for (c = *end++; (c != '\0') && (c != '\n') && (c != quote);
1901 c = *end++) {
1902 if (c == '\\') {
1903 c = conv_translate_c_esc(&end);
1904 if (c == -1) {
1905 mf_fatal(mf, MSG_INTL(MSG_MAP_BADCESC), *end);
1906 return (TK_ERROR);
1907 }
1908 }
1909 *cur++ = c;
1910 }
1911 *cur = '\0'; /* terminate the result */
1912 if (c != quote) {
1913 ld_map_npatch_t np;
1914
1915 null_patch_eol(end, &np);
1916 mf_fatal(mf, MSG_INTL(MSG_MAP_NOTERM), str);
1917 null_patch_undo(&np);
1918 return (TK_ERROR);
1919 }
1920
1921 /* end is pointing one character past the closing quote */
1922 mf->mf_next = end;
1923 tkv->tkv_str = str + 1; /* Skip opening quote */
1924 if (flags & TK_F_STRLC)
1925 ld_map_lowercase(tkv->tkv_str);
1926 return (TK_STRING);
1927 }
1928
1929 /*
1930 * Get a token from the mapfile.
1931 *
1932 * entry:
1933 * mf - Mapfile descriptor
1934 * flags - Bitmask of options to control ld_map_gettoken()s behavior
1935 * tkv- Address of pointer to variable to receive token value.
1936 *
1937 * exit:
1938 * Returns one of the TK_* values, to report the result. If the resulting
1939 * token has a value (TK_STRING / TK_INT), and tkv is non-NULL, tkv
1940 * is filled in with the resulting value.
1941 */
1942 Token
1943 ld_map_gettoken(Mapfile *mf, int flags, ld_map_tkval_t *tkv)
1944 {
1945 int cdir_allow, ch;
1946 Token tok;
1947 ld_map_npatch_t np;
1948
1949 /*
1950 * Mapfile control directives all start with a '$' character. However,
1951 * they are only valid when they are the first thing on a line. That
1952 * happens on the first call to ld_map_gettoken() for a new a new
1953 * mapfile, as tracked with lms.lms_cdir_valid, and immediately
1954 * following each newline seen in the file.
1955 */
1956 cdir_allow = lms.lms_cdir_valid;
1957 lms.lms_cdir_valid = 0;
1958
1959 /* Cycle through the characters looking for tokens. */
1960 for (;;) {
1961 /*
1962 * Process the next character. This is normally *mf->mf_next,
1963 * but if mf->mf_next_ch is non-0, then it contains the
1964 * character, and *mf->mf_next contains a NULL termination
1965 * from the TK_STRING token returned on the previous call.
1966 *
1967 * gettoken_ident() ensures that this is never done to
1968 * a character that starts a string.
1969 */
1970 if (mf->mf_next_ch == 0) {
1971 ch = *mf->mf_next;
1972 } else {
1973 ch = mf->mf_next_ch;
1974 mf->mf_next_ch = 0; /* Reset */
1975 }
1976
1977 /* Map the character to a dispatch action */
1978 tok = (ch & 0x80) ? TK_OP_ILLCHR : mf->mf_tokdisp[ch];
1979
1980 /*
1981 * Items that require processing are identified as OP tokens.
1982 * We process them, and return a result non-OP token.
1983 *
1984 * Non-OP tokens are single character tokens, and we return
1985 * them immediately.
1986 */
1987 switch (tok) {
1988 case TK_OP_EOF:
1989 /* If EOFOK is set, quietly report it as TK_EOF */
1990 if ((flags & TK_F_EOFOK) != 0)
1991 return (TK_EOF);
1992
1993 /* Treat it as a standard error */
1994 mf_fatal0(mf, MSG_INTL(MSG_MAP_PREMEOF));
1995 return (TK_ERROR);
1996
1997 case TK_OP_ILLCHR:
1998 mf_fatal(mf, MSG_INTL(MSG_MAP_ILLCHAR), ch);
1999 mf->mf_next++;
2000 return (TK_ERROR);
2001
2002 case TK_OP_BADCHR:
2003 tk_op_badchr:
2004 null_patch_eol(mf->mf_next, &np);
2005 mf_fatal(mf, MSG_INTL(MSG_MAP_BADCHAR), mf->mf_next);
2006 null_patch_undo(&np);
2007 mf->mf_next++;
2008 return (TK_ERROR);
2009
2010 case TK_OP_WS: /* White space */
2011 mf->mf_next++;
2012 break;
2013
2014 case TK_OP_NL: /* White space too, but bump line number. */
2015 mf->mf_next++;
2016 mf->mf_lineno++;
2017 cdir_allow = 1;
2018 break;
2019
2020 case TK_OP_SIMQUOTE:
2021 if (flags & TK_F_KEYWORD)
2022 goto tk_op_badkwquote;
2023 return (gettoken_simquote_str(mf, flags, tkv));
2024
2025 case TK_OP_CQUOTE:
2026 if (flags & TK_F_KEYWORD) {
2027 tk_op_badkwquote:
2028 null_patch_eol(mf->mf_next, &np);
2029 mf_fatal(mf, MSG_INTL(MSG_MAP_BADKWQUOTE),
2030 mf->mf_next);
2031 null_patch_undo(&np);
2032 mf->mf_next++;
2033 return (TK_ERROR);
2034 }
2035 return (gettoken_cquote_str(mf, flags, tkv));
2036
2037 case TK_OP_CMT:
2038 advance_to_eol(&mf->mf_next);
2039 break;
2040
2041 case TK_OP_CDIR:
2042 /*
2043 * Control directives are only valid at the start
2044 * of a line.
2045 */
2046 if (!cdir_allow) {
2047 null_patch_eol(mf->mf_next, &np);
2048 mf_fatal(mf, MSG_INTL(MSG_MAP_CDIR_NOTBOL),
2049 mf->mf_next);
2050 null_patch_undo(&np);
2051 mf->mf_next++;
2052 return (TK_ERROR);
2053 }
2054 if (!cdir_process(mf))
2055 return (TK_ERROR);
2056 break;
2057
2058 case TK_OP_NUM: /* Decimal, hex(0x...), or octal (0...) value */
2059 if (!ld_map_getint(mf, tkv, FALSE))
2060 return (TK_ERROR);
2061 return (TK_INT);
2062
2063 case TK_OP_ID: /* Unquoted identifier */
2064 return (gettoken_ident(mf, flags, tkv));
2065
2066 case TK_OP_CEQUAL: /* += or -= */
2067 if (*(mf->mf_next + 1) != '=')
2068 goto tk_op_badchr;
2069 tok = (ch == '+') ? TK_PLUSEQ : TK_MINUSEQ;
2070 mf->mf_next += 2;
2071 return (tok);
2072
2073 default: /* Non-OP token */
2074 mf->mf_next++;
2075 return (tok);
2076 }
2077 }
2078 }
2079
2080 /*
2081 * Given a token and value returned by ld_map_gettoken(), return a string
2082 * representation of it suitable for use in an error message.
2083 *
2084 * entry:
2085 * tok - Token code. Must not be an OP-token
2086 * tkv - Token value
2087 */
2088 const char *
2089 ld_map_tokenstr(Token tok, ld_map_tkval_t *tkv, Conv_inv_buf_t *inv_buf)
2090 {
2091 size_t cnt;
2092
2093 switch (tok) {
2094 case TK_ERROR:
2095 return (MSG_ORIG(MSG_STR_ERROR));
2096 case TK_EOF:
2097 return (MSG_ORIG(MSG_STR_EOF));
2098 case TK_STRING:
2099 return (tkv->tkv_str);
2100 case TK_COLON:
2101 return (MSG_ORIG(MSG_QSTR_COLON));
2102 case TK_SEMICOLON:
2103 return (MSG_ORIG(MSG_QSTR_SEMICOLON));
2104 case TK_EQUAL:
2105 return (MSG_ORIG(MSG_QSTR_EQUAL));
2106 case TK_PLUSEQ:
2107 return (MSG_ORIG(MSG_QSTR_PLUSEQ));
2108 case TK_MINUSEQ:
2109 return (MSG_ORIG(MSG_QSTR_MINUSEQ));
2110 case TK_ATSIGN:
2111 return (MSG_ORIG(MSG_QSTR_ATSIGN));
2112 case TK_DASH:
2113 return (MSG_ORIG(MSG_QSTR_DASH));
2114 case TK_LEFTBKT:
2115 return (MSG_ORIG(MSG_QSTR_LEFTBKT));
2116 case TK_RIGHTBKT:
2117 return (MSG_ORIG(MSG_QSTR_RIGHTBKT));
2118 case TK_PIPE:
2119 return (MSG_ORIG(MSG_QSTR_PIPE));
2120 case TK_INT:
2121 cnt = tkv->tkv_int.tkvi_cnt;
2122 if (cnt >= sizeof (inv_buf->buf))
2123 cnt = sizeof (inv_buf->buf) - 1;
2124 (void) memcpy(inv_buf->buf, tkv->tkv_int.tkvi_str, cnt);
2125 inv_buf->buf[cnt] = '\0';
2126 return (inv_buf->buf);
2127 case TK_STAR:
2128 return (MSG_ORIG(MSG_QSTR_STAR));
2129 case TK_BANG:
2130 return (MSG_ORIG(MSG_QSTR_BANG));
2131 default:
2132 assert(0);
2133 break;
2134 }
2135
2136 /*NOTREACHED*/
2137 return (MSG_INTL(MSG_MAP_INTERR));
2138 }
2139
2140 /*
2141 * Advance the input to the first non-empty line, and determine
2142 * the mapfile version. The version is specified by the mapfile
2143 * using a $mapfile_version directive. The original System V
2144 * syntax lacks this directive, and we use that fact to identify
2145 * such files. SysV mapfile are implicitly defined to have version 1.
2146 *
2147 * entry:
2148 * ofl - Output file descriptor
2149 * mf - Mapfile block
2150 *
2151 * exit:
2152 * On success, updates mf->mf_version, and returns TRUE (1).
2153 * On failure, returns FALSE (0).
2154 */
2155 static Boolean
2156 mapfile_version(Mapfile *mf)
2157 {
2158 char *line_start = mf->mf_next;
2159 Boolean cont = TRUE;
2160 Boolean status = TRUE; /* Assume success */
2161 Token tok;
2162
2163 mf->mf_version = MFV_SYSV;
2164
2165 /*
2166 * Cycle through the characters looking for tokens. Although the
2167 * true version is not known yet, we use the v2 dispatch table.
2168 * It contains control directives, which we need for this search,
2169 * and the other TK_OP_ tokens we will recognize and act on are the
2170 * same for both tables.
2171 *
2172 * It is important not to process any tokens that would lead to
2173 * a non-OP token:
2174 *
2175 * - The version is required to interpret them
2176 * - Our mapfile descriptor is not fully initialized,
2177 * attempts to run that code will crash the program.
2178 */
2179 while (cont) {
2180 /* Map the character to a dispatch action */
2181 tok = (*mf->mf_next & 0x80) ?
2182 TK_OP_ILLCHR : gettok_dispatch_v2[*mf->mf_next];
2183
2184 switch (tok) {
2185 case TK_OP_WS: /* White space */
2186 mf->mf_next++;
2187 break;
2188
2189 case TK_OP_NL: /* White space too, but bump line number. */
2190 mf->mf_next++;
2191 mf->mf_lineno++;
2192 break;
2193
2194 case TK_OP_CMT:
2195 advance_to_eol(&mf->mf_next);
2196 break;
2197
2198 case TK_OP_CDIR:
2199 /*
2200 * Control directives are only valid at the start
2201 * of a line. However, as we have not yet seen
2202 * a token, we do not need to test for this, and
2203 * can safely assume that we are at the start.
2204 */
2205 if (!strncasecmp(mf->mf_next,
2206 MSG_ORIG(MSG_STR_CDIR_MFVER),
2207 MSG_STR_CDIR_MFVER_SIZE) &&
2208 isspace_nonl(*(mf->mf_next +
2209 MSG_STR_CDIR_MFVER_SIZE))) {
2210 ld_map_tkval_t ver;
2211
2212 mf->mf_next += MSG_STR_CDIR_MFVER_SIZE + 1;
2213 if (!ld_map_getint(mf, &ver, TRUE)) {
2214 status = cont = FALSE;
2215 break;
2216 }
2217 /*
2218 * Is it a valid version? Note that we
2219 * intentionally do not allow you to
2220 * specify version 1 using the $mapfile_version
2221 * syntax, because that's reserved to version
2222 * 2 and up.
2223 */
2224 if ((ver.tkv_int.tkvi_value < 2) ||
2225 (ver.tkv_int.tkvi_value >= MFV_NUM)) {
2226 const char *fmt;
2227
2228 fmt = (ver.tkv_int.tkvi_value < 2) ?
2229 MSG_INTL(MSG_MAP_CDIR_BADVDIR) :
2230 MSG_INTL(MSG_MAP_CDIR_BADVER);
2231 mf_fatal(mf, fmt,
2232 EC_WORD(ver.tkv_int.tkvi_value));
2233 status = cont = FALSE;
2234 break;
2235 }
2236 mf->mf_version = ver.tkv_int.tkvi_value;
2237 cont = FALSE; /* Version recovered. All done */
2238 break;
2239 }
2240 /*
2241 * Not a version directive. Reset the current position
2242 * to the start of the current line and stop here.
2243 * SysV syntax applies.
2244 */
2245 mf->mf_next = line_start;
2246 cont = FALSE;
2247 break;
2248
2249 default:
2250 /*
2251 * If we see anything else, then stop at this point.
2252 * The file has System V syntax (version 1), and the
2253 * next token should be interpreted as such.
2254 */
2255 cont = FALSE;
2256 break;
2257 }
2258 }
2259
2260 return (status);
2261 }
2262
2263 /*
2264 * Parse the mapfile.
2265 */
2266 Boolean
2267 ld_map_parse(const char *mapfile, Ofl_desc *ofl)
2268 {
2269 struct stat stat_buf; /* stat of mapfile */
2270 int mapfile_fd; /* descriptor for mapfile */
2271 int err;
2272 Mapfile *mf; /* Mapfile descriptor */
2273 size_t name_len; /* strlen(mapfile) */
2274
2275 /*
2276 * Determine if we're dealing with a file or a directory.
2277 */
2278 if (stat(mapfile, &stat_buf) == -1) {
2279 err = errno;
2280 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SYS_STAT), mapfile,
2281 strerror(err));
2282 return (FALSE);
2283 }
2284 if (S_ISDIR(stat_buf.st_mode)) {
2285 DIR *dirp;
2286 struct dirent *denp;
2287
2288 /*
2289 * Open the directory and interpret each visible file as a
2290 * mapfile.
2291 */
2292 if ((dirp = opendir(mapfile)) == NULL)
2293 return (TRUE);
2294
2295 while ((denp = readdir(dirp)) != NULL) {
2296 char path[PATH_MAX];
2297
2298 /*
2299 * Ignore any hidden filenames. Construct the full
2300 * pathname to the new mapfile.
2301 */
2302 if (*denp->d_name == '.')
2303 continue;
2304 (void) snprintf(path, PATH_MAX, MSG_ORIG(MSG_STR_PATH),
2305 mapfile, denp->d_name);
2306 if (!ld_map_parse(path, ofl))
2307 return (FALSE);
2308 }
2309 (void) closedir(dirp);
2310 return (TRUE);
2311 } else if (!S_ISREG(stat_buf.st_mode)) {
2312 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SYS_NOTREG), mapfile);
2313 return (FALSE);
2314 }
2315
2316 /* Open file */
2317 if ((mapfile_fd = open(mapfile, O_RDONLY)) == -1) {
2318 err = errno;
2319 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SYS_OPEN), mapfile,
2320 strerror(err));
2321 return (FALSE);
2322 }
2323
2324 /*
2325 * Allocate enough memory to hold the state block, mapfile name,
2326 * and mapfile text. Text has alignment 1, so it can follow the
2327 * state block without padding.
2328 */
2329 name_len = strlen(mapfile) + 1;
2330 mf = libld_malloc(sizeof (*mf) + name_len + stat_buf.st_size + 1);
2331 if (mf == NULL)
2332 return (FALSE);
2333 mf->mf_ofl = ofl;
2334 mf->mf_name = (char *)(mf + 1);
2335 (void) strcpy(mf->mf_name, mapfile);
2336 mf->mf_text = mf->mf_name + name_len;
2337 if (read(mapfile_fd, mf->mf_text, stat_buf.st_size) !=
2338 stat_buf.st_size) {
2339 err = errno;
2340 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SYS_READ), mapfile,
2341 strerror(err));
2342 (void) close(mapfile_fd);
2343 return (FALSE);
2344 }
2345 (void) close(mapfile_fd);
2346 mf->mf_text[stat_buf.st_size] = '\0';
2347 mf->mf_next = mf->mf_text;
2348 mf->mf_lineno = 1;
2349 mf->mf_next_ch = 0; /* No "lookahead" character yet */
2350 mf->mf_ec_insndx = 0; /* Insert entrace criteria at top */
2351
2352 /*
2353 * Read just enough from the mapfile to determine the version,
2354 * and then dispatch to the appropriate code for further processing
2355 */
2356 if (!mapfile_version(mf))
2357 return (FALSE);
2358
2359 /*
2360 * Start and continuation masks for unquoted identifier at this
2361 * mapfile version level.
2362 */
2363 mf->mf_tkid_start = TKID_ATTR_START(mf->mf_version);
2364 mf->mf_tkid_cont = TKID_ATTR_CONT(mf->mf_version);
2365
2366 DBG_CALL(Dbg_map_parse(ofl->ofl_lml, mapfile, mf->mf_version));
2367
2368 switch (mf->mf_version) {
2369 case MFV_SYSV:
2370 /* Guidance: Use newer mapfile syntax */
2371 if (OFL_GUIDANCE(ofl, FLG_OFG_NO_MF))
2372 ld_eprintf(ofl, ERR_GUIDANCE,
2373 MSG_INTL(MSG_GUIDE_MAPFILE), mapfile);
2374
2375 mf->mf_tokdisp = gettok_dispatch_v1;
2376 if (!ld_map_parse_v1(mf))
2377 return (FALSE);
2378 break;
2379
2380 case MFV_SOLARIS:
2381 mf->mf_tokdisp = gettok_dispatch_v2;
2382 STACK_RESET(lms.lms_cdir_stack);
2383
2384 /*
2385 * If the conditional expression identifier tree has not been
2386 * initialized, set it up. This is only done on the first
2387 * mapfile, because the identifier control directives accumulate
2388 * across all the mapfiles.
2389 */
2390 if ((lms.lms_cexp_id == NULL) && !cexp_ident_init())
2391 return (FALSE);
2392
2393 /*
2394 * Tell ld_map_gettoken() we will accept a '$' as starting a
2395 * control directive on the first call. Normally, they are
2396 * only allowed after a newline.
2397 */
2398 lms.lms_cdir_valid = 1;
2399
2400 if (!ld_map_parse_v2(mf))
2401 return (FALSE);
2402
2403 /* Did we leave any open $if control directives? */
2404 if (!STACK_IS_EMPTY(lms.lms_cdir_stack)) {
2405 while (!STACK_IS_EMPTY(lms.lms_cdir_stack)) {
2406 cdir_level_t *level =
2407 &STACK_POP(lms.lms_cdir_stack);
2408
2409 mf_fatal(mf, MSG_INTL(MSG_MAP_CDIR_NOEND),
2410 EC_LINENO(level->cdl_if_lineno));
2411 }
2412 return (FALSE);
2413 }
2414 break;
2415 }
2416
2417 return (TRUE);
2418 }
2419
2420 /*
2421 * Sort the segment list. This is necessary if a mapfile has set explicit
2422 * virtual addresses for segments, or defined a SEGMENT_ORDER directive.
2423 *
2424 * Only PT_LOAD segments can be assigned a virtual address. These segments can
2425 * be one of two types:
2426 *
2427 * - Standard segments for text, data or bss. These segments will have been
2428 * inserted before the default text (first PT_LOAD) segment.
2429 *
2430 * - Empty (reservation) segments. These segment will have been inserted at
2431 * the end of any default PT_LOAD segments.
2432 *
2433 * Any standard segments that are assigned a virtual address will be sorted,
2434 * and as their definitions precede any default PT_LOAD segments, these segments
2435 * will be assigned sections before any defaults.
2436 *
2437 * Any reservation segments are also sorted amoung themselves, as these segments
2438 * must still follow the standard default segments.
2439 */
2440 static Boolean
2441 sort_seg_list(Ofl_desc *ofl)
2442 {
2443 APlist *sort_segs = NULL, *load_segs = NULL;
2444 Sg_desc *sgp1;
2445 Aliste idx1;
2446 Aliste nsegs;
2447
2448
2449 /*
2450 * We know the number of elements in the sorted list will be
2451 * the same as the original, so use this as the initial allocation
2452 * size for the replacement aplist.
2453 */
2454 nsegs = aplist_nitems(ofl->ofl_segs);
2455
2456
2457 /* Add the items below SGID_TEXT to the list */
2458 for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp1)) {
2459 if (sgp1->sg_id >= SGID_TEXT)
2460 break;
2461
2462 if (aplist_append(&sort_segs, sgp1, nsegs) == NULL)
2463 return (FALSE);
2464 }
2465
2466 /*
2467 * If there are any SEGMENT_ORDER items, add them, and set their
2468 * FLG_SG_ORDERED flag to identify them in debug output, and to
2469 * prevent them from being added again below.
2470 */
2471 for (APLIST_TRAVERSE(ofl->ofl_segs_order, idx1, sgp1)) {
2472 if (aplist_append(&sort_segs, sgp1, nsegs) == NULL)
2473 return (FALSE);
2474 sgp1->sg_flags |= FLG_SG_ORDERED;
2475 }
2476
2477 /*
2478 * Add the loadable segments to another list in sorted order.
2479 */
2480 DBG_CALL(Dbg_map_sort_title(ofl->ofl_lml, TRUE));
2481 for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp1)) {
2482 DBG_CALL(Dbg_map_sort_seg(ofl->ofl_lml, ELFOSABI_SOLARIS,
2483 ld_targ.t_m.m_mach, sgp1));
2484
2485 /* Only interested in PT_LOAD items not in SEGMENT_ORDER list */
2486 if ((sgp1->sg_phdr.p_type != PT_LOAD) ||
2487 (sgp1->sg_flags & FLG_SG_ORDERED))
2488 continue;
2489
2490 /*
2491 * If the loadable segment does not contain a vaddr, simply
2492 * append it to the new list.
2493 */
2494 if ((sgp1->sg_flags & FLG_SG_P_VADDR) == 0) {
2495 if (aplist_append(&load_segs, sgp1, AL_CNT_SEGMENTS) ==
2496 NULL)
2497 return (FALSE);
2498
2499 } else {
2500 Aliste idx2;
2501 Sg_desc *sgp2;
2502 int inserted = 0;
2503
2504 /*
2505 * Traverse the segment list we are creating, looking
2506 * for a segment that defines a vaddr.
2507 */
2508 for (APLIST_TRAVERSE(load_segs, idx2, sgp2)) {
2509 /*
2510 * Any real segments that contain vaddr's need
2511 * to be sorted. Any reservation segments also
2512 * need to be sorted. However, any reservation
2513 * segments should be placed after any real
2514 * segments.
2515 */
2516 if (((sgp2->sg_flags &
2517 (FLG_SG_P_VADDR | FLG_SG_EMPTY)) == 0) &&
2518 (sgp1->sg_flags & FLG_SG_EMPTY))
2519 continue;
2520
2521 if ((sgp2->sg_flags & FLG_SG_P_VADDR) &&
2522 ((sgp2->sg_flags & FLG_SG_EMPTY) ==
2523 (sgp1->sg_flags & FLG_SG_EMPTY))) {
2524 if (sgp1->sg_phdr.p_vaddr ==
2525 sgp2->sg_phdr.p_vaddr) {
2526 ld_eprintf(ofl, ERR_FATAL,
2527 MSG_INTL(MSG_MAP_SEGSAME),
2528 sgp1->sg_name,
2529 sgp2->sg_name);
2530 return (FALSE);
2531 }
2532
2533 if (sgp1->sg_phdr.p_vaddr >
2534 sgp2->sg_phdr.p_vaddr)
2535 continue;
2536 }
2537
2538 /*
2539 * Insert this segment before the segment on
2540 * the load_segs list.
2541 */
2542 if (aplist_insert(&load_segs, sgp1,
2543 AL_CNT_SEGMENTS, idx2) == NULL)
2544 return (FALSE);
2545 inserted = 1;
2546 break;
2547 }
2548
2549 /*
2550 * If the segment being inspected has not been inserted
2551 * in the segment list, simply append it to the list.
2552 */
2553 if ((inserted == 0) && (aplist_append(&load_segs,
2554 sgp1, AL_CNT_SEGMENTS) == NULL))
2555 return (FALSE);
2556 }
2557 }
2558
2559 /*
2560 * Add the sorted loadable segments to our initial segment list.
2561 */
2562 for (APLIST_TRAVERSE(load_segs, idx1, sgp1)) {
2563 if (aplist_append(&sort_segs, sgp1, AL_CNT_SEGMENTS) == NULL)
2564 return (FALSE);
2565 }
2566
2567 /*
2568 * Add all other segments to our list.
2569 */
2570 for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp1)) {
2571 if ((sgp1->sg_id < SGID_TEXT) ||
2572 (sgp1->sg_phdr.p_type == PT_LOAD) ||
2573 (sgp1->sg_flags & FLG_SG_ORDERED))
2574 continue;
2575
2576 if (aplist_append(&sort_segs, sgp1, AL_CNT_SEGMENTS) == NULL)
2577 return (FALSE);
2578 }
2579
2580 /*
2581 * Free the original list, and the pt_load list, and use
2582 * the new list as the segment list.
2583 */
2584 free(ofl->ofl_segs);
2585 if (load_segs) free(load_segs);
2586 ofl->ofl_segs = sort_segs;
2587
2588 if (DBG_ENABLED) {
2589 Dbg_map_sort_title(ofl->ofl_lml, FALSE);
2590 for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp1)) {
2591 Dbg_map_sort_seg(ofl->ofl_lml, ELFOSABI_SOLARIS,
2592 ld_targ.t_m.m_mach, sgp1);
2593 }
2594 }
2595
2596 return (TRUE);
2597 }
2598
2599 /*
2600 * After all mapfiles have been processed, this routine is used to
2601 * finish any remaining mapfile related work.
2602 *
2603 * exit:
2604 * Returns TRUE on success, and FALSE on failure.
2605 */
2606 Boolean
2607 ld_map_post_process(Ofl_desc *ofl)
2608 {
2609 Aliste idx, idx2;
2610 Is_desc *isp;
2611 Sg_desc *sgp;
2612 Ent_desc *enp;
2613 Sg_desc *first_seg = NULL;
2614
2615
2616 DBG_CALL(Dbg_map_post_title(ofl->ofl_lml));
2617
2618 /*
2619 * Per-segment processing:
2620 * - Identify segments with explicit virtual address
2621 * - Details of input and output section order
2622 */
2623 for (APLIST_TRAVERSE(ofl->ofl_segs, idx, sgp)) {
2624 /*
2625 * We are looking for segments. Program headers that represent
2626 * segments are required to have a non-NULL name pointer,
2627 * while that those that do not are required to have a
2628 * NULL name pointer.
2629 */
2630 if (sgp->sg_name == NULL)
2631 continue;
2632
2633 /* Remember the first non-disabled segment */
2634 if ((first_seg == NULL) && !(sgp->sg_flags & FLG_SG_DISABLED))
2635 first_seg = sgp;
2636
2637 /*
2638 * If a segment has an explicit virtual address, we will
2639 * need to sort the segments.
2640 */
2641 if (sgp->sg_flags & FLG_SG_P_VADDR)
2642 ofl->ofl_flags1 |= FLG_OF1_VADDR;
2643
2644 /*
2645 * The FLG_OF_OS_ORDER flag enables the code that does
2646 * output section ordering. Set if the segment has
2647 * a non-empty output section order list.
2648 */
2649 if (alist_nitems(sgp->sg_os_order) > 0)
2650 ofl->ofl_flags |= FLG_OF_OS_ORDER;
2651
2652 /*
2653 * The version 1 and version 2 syntaxes for input section
2654 * ordering are different and incompatible enough that we
2655 * only allow the use of one or the other for a given segment:
2656 *
2657 * v1) The version 1 syntax has the user set the ?O flag on
2658 * the segment. If this is done, all input sections placed
2659 * via an entrance criteria that has a section name are to
2660 * be sorted, using the order of the entrance criteria
2661 * as the sort key.
2662 *
2663 * v2) The version 2 syntax has the user specify a name for
2664 * the entry criteria, and then provide a list of entry
2665 * criteria names via the IS_ORDER segment attribute.
2666 * Sections placed via the criteria listed in IS_ORDER
2667 * are sorted, and the others are not.
2668 *
2669 * Regardless of the syntax version used, the section sorting
2670 * code expects the following:
2671 *
2672 * - Segments requiring input section sorting have the
2673 * FLG_SG_IS_ORDER flag set
2674 *
2675 * - Entrance criteria referencing the segment that
2676 * participate in input section sorting have a non-zero
2677 * sort key in their ec_ordndx field.
2678 *
2679 * At this point, the following are true:
2680 *
2681 * - All entrance criteria have ec_ordndx set to 0.
2682 * - Segments that require the version 1 behavior have
2683 * the FLG_SG_IS_ORDER flag set, and the segments
2684 * sg_is_order list is empty.
2685 * - Segments that require the version 2 behavior do not
2686 * have FLG_SG_IS_ORDER set, and the sg_is_order list is
2687 * non-empty. This list contains the names of the entrance
2688 * criteria that will participate in input section sorting,
2689 * and their relative order in the list provides the
2690 * sort key to use.
2691 *
2692 * We must detect these two cases, set the FLG_SG_IS_ORDER
2693 * flag as necessary, and fill in all entrance criteria
2694 * sort keys. If any input section sorting is to be done,
2695 * we also set the FLG_OF_IS_ORDER flag on the output descriptor
2696 * to enable the code that does that work.
2697 */
2698
2699 /* Version 1: ?O flag? */
2700 if (sgp->sg_flags & FLG_SG_IS_ORDER) {
2701 Word index = 0;
2702
2703 ofl->ofl_flags |= FLG_OF_IS_ORDER;
2704 DBG_CALL(Dbg_map_ent_ord_title(ofl->ofl_lml,
2705 sgp->sg_name));
2706
2707 /*
2708 * Give each user defined entrance criteria for this
2709 * segment that specifies a section name a
2710 * monotonically increasing sort key.
2711 */
2712 for (APLIST_TRAVERSE(ofl->ofl_ents, idx2, enp))
2713 if ((enp->ec_segment == sgp) &&
2714 (enp->ec_is_name != NULL) &&
2715 ((enp->ec_flags & FLG_EC_BUILTIN) == 0))
2716 enp->ec_ordndx = ++index;
2717 continue;
2718 }
2719
2720 /* Version 2: SEGMENT IS_ORDER list? */
2721 if (aplist_nitems(sgp->sg_is_order) > 0) {
2722 Word index = 0;
2723
2724 ofl->ofl_flags |= FLG_OF_IS_ORDER;
2725 DBG_CALL(Dbg_map_ent_ord_title(ofl->ofl_lml,
2726 sgp->sg_name));
2727
2728 /*
2729 * Give each entrance criteria in the sg_is_order
2730 * list a monotonically increasing sort key.
2731 */
2732 for (APLIST_TRAVERSE(sgp->sg_is_order, idx2, enp)) {
2733 enp->ec_ordndx = ++index;
2734 enp->ec_segment->sg_flags |= FLG_SG_IS_ORDER;
2735 }
2736 }
2737 }
2738
2739 /* Sort the segment descriptors if necessary */
2740 if (((ofl->ofl_flags1 & FLG_OF1_VADDR) ||
2741 (aplist_nitems(ofl->ofl_segs_order) > 0)) &&
2742 !sort_seg_list(ofl))
2743 return (FALSE);
2744
2745 /*
2746 * If the output file is a static file without an interpreter, and
2747 * if any virtual address is specified, then set the NOHDR flag for
2748 * backward compatibility.
2749 */
2750 if (!(ofl->ofl_flags & (FLG_OF_DYNAMIC | FLG_OF_RELOBJ)) &&
2751 !(ofl->ofl_osinterp) && (ofl->ofl_flags1 & FLG_OF1_VADDR))
2752 ofl->ofl_dtflags_1 |= DF_1_NOHDR;
2753
2754 if (ofl->ofl_flags & FLG_OF_RELOBJ) {
2755 /*
2756 * NOHDR has no effect on a relocatable file.
2757 * Make sure this flag isn't set.
2758 */
2759 ofl->ofl_dtflags_1 &= ~DF_1_NOHDR;
2760 } else if (first_seg != NULL) {
2761 /*
2762 * DF_1_NOHDR might have been set globally by the HDR_NOALLOC
2763 * directive. If not, then we want to check the per-segment
2764 * flag for the first loadable segment and propagate it
2765 * if set.
2766 */
2767 if ((ofl->ofl_dtflags_1 & DF_1_NOHDR) == 0) {
2768 /*
2769 * If we sorted the segments, the first segment
2770 * may have changed.
2771 */
2772 if ((ofl->ofl_flags1 & FLG_OF1_VADDR) ||
2773 (aplist_nitems(ofl->ofl_segs_order) > 0)) {
2774 for (APLIST_TRAVERSE(ofl->ofl_segs, idx, sgp)) {
2775 if (sgp->sg_name == NULL)
2776 continue;
2777 if ((sgp->sg_flags & FLG_SG_DISABLED) ==
2778 0) {
2779 first_seg = sgp;
2780 break;
2781 }
2782 }
2783 }
2784
2785 /*
2786 * If the per-segment NOHDR flag is set on our first
2787 * segment, then make it take effect.
2788 */
2789 if (first_seg->sg_flags & FLG_SG_NOHDR)
2790 ofl->ofl_dtflags_1 |= DF_1_NOHDR;
2791 }
2792
2793 /*
2794 * For executable and shared objects, the first segment must
2795 * be loadable unless NOHDR was specified, because the ELF
2796 * header must simultaneously lie at offset 0 of the file and
2797 * be included in the first loadable segment. This isn't
2798 * possible if some other segment type starts the file
2799 */
2800 if (!(ofl->ofl_dtflags_1 & DF_1_NOHDR) &&
2801 (first_seg->sg_phdr.p_type != PT_LOAD)) {
2802 Conv_inv_buf_t inv_buf;
2803
2804 ld_eprintf(ofl, ERR_FATAL,
2805 MSG_INTL(MSG_SEG_FIRNOTLOAD),
2806 conv_phdr_type(ELFOSABI_SOLARIS, ld_targ.t_m.m_mach,
2807 first_seg->sg_phdr.p_type, 0, &inv_buf),
2808 first_seg->sg_name);
2809 return (FALSE);
2810 }
2811 }
2812
2813 /*
2814 * Mapfiles may have been used to create symbol definitions
2815 * with backing storage. Although the backing storage is
2816 * associated with an input section, the association of the
2817 * section to an output section (and segment) is initially
2818 * deferred. Now that all mapfile processing is complete, any
2819 * entrance criteria requirements have been processed, and
2820 * these backing storage sections can be associated with the
2821 * appropriate output section (and segment).
2822 */
2823 if (ofl->ofl_maptext || ofl->ofl_mapdata)
2824 DBG_CALL(Dbg_sec_backing(ofl->ofl_lml));
2825
2826 for (APLIST_TRAVERSE(ofl->ofl_maptext, idx, isp)) {
2827 if (ld_place_section(ofl, isp, NULL,
2828 ld_targ.t_id.id_text, NULL) == (Os_desc *)S_ERROR)
2829 return (FALSE);
2830 }
2831
2832 for (APLIST_TRAVERSE(ofl->ofl_mapdata, idx, isp)) {
2833 if (ld_place_section(ofl, isp, NULL,
2834 ld_targ.t_id.id_data, NULL) == (Os_desc *)S_ERROR)
2835 return (FALSE);
2836 }
2837
2838 return (TRUE);
2839 }