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