xref: /illumos-gate/usr/src/cmd/sgs/libld/common/map.c (revision aedf2b3bb56b025fcaf87b49ec6c8aeea07f16d7)
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 2009 Sun Microsystems, Inc.  All rights reserved.
27  * Use is subject to license terms.
28  */
29 
30 /*
31  * Map file parsing.
32  */
33 #include	<fcntl.h>
34 #include	<string.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	<elfcap.h>
43 #include	<debug.h>
44 #include	"msg.h"
45 #include	"_libld.h"
46 
47 #if	defined(_ELF64)
48 #define	STRTOADDR	strtoull
49 #define	XWORD_MAX	ULLONG_MAX
50 #else	/* Elf32 */
51 #define	STRTOADDR	strtoul
52 #define	XWORD_MAX	UINT_MAX
53 #endif	/* _ELF64 */
54 
55 /* Possible return values from gettoken */
56 typedef enum {
57 	TK_ERROR =	-1,	/* Error in lexical analysis */
58 	TK_STRING =	0,
59 	TK_COLON =	1,
60 	TK_SEMICOLON =	2,
61 	TK_EQUAL =	3,
62 	TK_ATSIGN =	4,
63 	TK_DASH =	5,
64 	TK_LEFTBKT =	6,
65 	TK_RIGHTBKT =	7,
66 	TK_PIPE =	8,
67 	TK_EOF =	9
68 } Token;
69 
70 
71 static char	*Mapspace;	/* Malloc space holding mapfile. */
72 static ulong_t	Line_num;	/* Current mapfile line number. */
73 static char	*Start_tok;	/* First character of current token. */
74 static char	*nextchr;	/* Next char in mapfile to examine. */
75 
76 /*
77  * Convert a string to lowercase.
78  */
79 static void
80 lowercase(char *str)
81 {
82 	while (*str = tolower(*str))
83 		str++;
84 }
85 
86 /*
87  * Get a token from the mapfile.
88  *
89  * entry:
90  *	ofl - Output file descriptor
91  *	mapfile - Name of mapfile
92  *	eof_ok - If False, end of file causes a premature EOF error to be
93  *		issued. If True, TK_EOF is returned quietly.
94  */
95 static Token
96 gettoken(Ofl_desc *ofl, const char *mapfile, int eof_ok)
97 {
98 	static char	oldchr = '\0';	/* Char at end of current token. */
99 	char		*end;		/* End of the current token. */
100 
101 	/* Cycle through the characters looking for tokens. */
102 	for (;;) {
103 		if (oldchr != '\0') {
104 			*nextchr = oldchr;
105 			oldchr = '\0';
106 		}
107 		if (!isascii(*nextchr) ||
108 		    (!isprint(*nextchr) && !isspace(*nextchr) &&
109 		    (*nextchr != '\0'))) {
110 			eprintf(ofl->ofl_lml, ERR_FATAL,
111 			    MSG_INTL(MSG_MAP_ILLCHAR), mapfile,
112 			    EC_XWORD(Line_num), *((uchar_t *)nextchr));
113 			return (TK_ERROR);
114 		}
115 		switch (*nextchr) {
116 		case '\0':	/* End of file. */
117 			if (!eof_ok)
118 				eprintf(ofl->ofl_lml, ERR_FATAL,
119 				    MSG_INTL(MSG_MAP_PREMEOF), mapfile,
120 				    EC_XWORD(Line_num));
121 			return (TK_EOF);
122 
123 		case ' ':	/* White space. */
124 		case '\t':
125 			nextchr++;
126 			break;
127 		case '\n':	/* White space too, but bump line number. */
128 			nextchr++;
129 			Line_num++;
130 			break;
131 		case '#':	/* Comment. */
132 			while (*nextchr != '\n' && *nextchr != '\0')
133 				nextchr++;
134 			break;
135 		case ':':
136 			nextchr++;
137 			return (TK_COLON);
138 		case ';':
139 			nextchr++;
140 			return (TK_SEMICOLON);
141 		case '=':
142 			nextchr++;
143 			return (TK_EQUAL);
144 		case '@':
145 			nextchr++;
146 			return (TK_ATSIGN);
147 		case '-':
148 			nextchr++;
149 			return (TK_DASH);
150 		case '|':
151 			nextchr++;
152 			return (TK_PIPE);
153 		case '{':
154 			nextchr++;
155 			return (TK_LEFTBKT);
156 		case '}':
157 			nextchr++;
158 			return (TK_RIGHTBKT);
159 		case '"':
160 			Start_tok = ++nextchr;
161 			if (((end = strpbrk(nextchr,
162 			    MSG_ORIG(MSG_MAP_TOK_1))) == NULL) ||
163 			    (*end != '"')) {
164 				eprintf(ofl->ofl_lml, ERR_FATAL,
165 				    MSG_INTL(MSG_MAP_NOTERM), mapfile,
166 				    EC_XWORD(Line_num));
167 				return (TK_ERROR);
168 			}
169 			*end = '\0';
170 			nextchr = end + 1;
171 			return (TK_STRING);
172 		default:	/* string. */
173 			Start_tok = nextchr;		/* CSTYLED */
174 			end = strpbrk(nextchr, MSG_ORIG(MSG_MAP_TOK_2));
175 			if (end == NULL)
176 				nextchr = Start_tok + strlen(Start_tok);
177 			else {
178 				nextchr = end;
179 				oldchr = *nextchr;
180 				*nextchr = '\0';
181 			}
182 			return (TK_STRING);
183 		}
184 	}
185 }
186 
187 /*
188  * Process a hardware/software capabilities segment declaration definition.
189  *	hwcap_1	= val,... [ OVERRIDE ]
190  *	sfcap_1	= val,... [ OVERRIDE ]
191  *
192  * The values can be defined as a list of machine specify tokens, or numerics.
193  * Tokens are representations of the sys/auxv_$MACH.h capabilities, for example:
194  *
195  *	#define AV_386_FPU 0x0001	is represented as	FPU
196  *	#define AV_386_TSC 0x0002	 "    "    "   " 	TSC
197  *
198  * Or, the above two capabilities could be represented as V0x3.  Note, the
199  * OVERRIDE flag is used to ensure that only those values provided via this
200  * mapfile entry are recorded in the final image, ie. this overrides any
201  * hardware capabilities that may be defined in the objects read as part of this
202  * link-edit.  Specifying:
203  *
204  *	V0x0 OVERRIDE
205  *
206  * effectively removes any capabilities information from the final image.
207  */
208 static uintptr_t
209 map_cap(const char *mapfile, Word type, Ofl_desc *ofl)
210 {
211 	Token	tok;			/* Current token. */
212 	Xword	number;
213 	int	used = 0;
214 
215 	while ((tok = gettoken(ofl, mapfile, 0)) != TK_SEMICOLON) {
216 		if (tok != TK_STRING) {
217 			if (tok != TK_ERROR)
218 				eprintf(ofl->ofl_lml, ERR_FATAL,
219 				    MSG_INTL(MSG_MAP_EXPSEGATT), mapfile,
220 				    EC_XWORD(Line_num));
221 			return (S_ERROR);
222 		}
223 
224 		lowercase(Start_tok);
225 
226 		/*
227 		 * First, determine if the token represents the reserved
228 		 * OVERRIDE keyword.
229 		 */
230 		if (strncmp(Start_tok, MSG_ORIG(MSG_MAP_OVERRIDE),
231 		    MSG_MAP_OVERRIDE_SIZE) == 0) {
232 			if (type == CA_SUNW_HW_1)
233 				ofl->ofl_flags1 |= FLG_OF1_OVHWCAP;
234 			else
235 				ofl->ofl_flags1 |= FLG_OF1_OVSFCAP;
236 			used++;
237 			continue;
238 		}
239 
240 		/*
241 		 * Next, determine if the token represents a machine specific
242 		 * hardware capability, or a generic software capability.
243 		 */
244 		if (type == CA_SUNW_HW_1) {
245 			if ((number = (Xword)elfcap_hw1_from_str(
246 			    ELFCAP_STYLE_LC, Start_tok,
247 			    ld_targ.t_m.m_mach)) != 0) {
248 				ofl->ofl_hwcap_1 |= number;
249 				used++;
250 				continue;
251 			}
252 		} else {
253 			if ((number = (Xword)elfcap_sf1_from_str(
254 			    ELFCAP_STYLE_LC, Start_tok,
255 			    ld_targ.t_m.m_mach)) != 0) {
256 				ofl->ofl_sfcap_1 |= number;
257 				used++;
258 				continue;
259 			}
260 		}
261 
262 		/*
263 		 * Next, determine if the token represents a numeric value.
264 		 */
265 		if (Start_tok[0] == 'v') {
266 			char		*end_tok;
267 
268 			errno = 0;
269 			number = (Xword)strtoul(&Start_tok[1], &end_tok, 0);
270 			if (errno) {
271 				int	err = errno;
272 				eprintf(ofl->ofl_lml, ERR_FATAL,
273 				    MSG_INTL(MSG_MAP_BADCAPVAL),
274 				    mapfile, EC_XWORD(Line_num), Start_tok,
275 				    strerror(err));
276 				return (S_ERROR);
277 			}
278 			if (end_tok != strchr(Start_tok, '\0')) {
279 				eprintf(ofl->ofl_lml, ERR_FATAL,
280 				    MSG_INTL(MSG_MAP_BADCAPVAL), mapfile,
281 				    EC_XWORD(Line_num), Start_tok,
282 				    MSG_INTL(MSG_MAP_NOBADFRM));
283 				return (S_ERROR);
284 			}
285 
286 			if (type == CA_SUNW_HW_1)
287 				ofl->ofl_hwcap_1 |= number;
288 			else
289 				ofl->ofl_sfcap_1 |= number;
290 			used++;
291 			continue;
292 		}
293 
294 		/*
295 		 * We have an unknown token.
296 		 */
297 		used++;
298 		eprintf(ofl->ofl_lml, ERR_FATAL, MSG_INTL(MSG_MAP_UNKCAPATTR),
299 		    mapfile, EC_XWORD(Line_num), Start_tok);
300 		return (S_ERROR);
301 	}
302 
303 	/*
304 	 * Catch any empty declarations, and indicate any software capabilities
305 	 * have been initialized if necessary.
306 	 */
307 	if (used == 0) {
308 		eprintf(ofl->ofl_lml, ERR_WARNING, MSG_INTL(MSG_MAP_EMPTYCAP),
309 		    mapfile, EC_XWORD(Line_num));
310 	} else if (type == CA_SUNW_SF_1) {
311 		Lword	badsf1;
312 
313 		/*
314 		 * Note, hardware capabilities, beyond the tokens that are
315 		 * presently known, can be accepted using the V0xXXX notation,
316 		 * and as these simply get or'd into the output image, we allow
317 		 * any values to be supplied.  Software capability tokens
318 		 * however, have an algorithm of acceptance and update (see
319 		 * sf1_cap() in files.c).  Therefore only allow software
320 		 * capabilities that are known.
321 		 */
322 		if ((badsf1 = (ofl->ofl_sfcap_1 & ~SF1_SUNW_MASK)) != 0) {
323 			eprintf(ofl->ofl_lml, ERR_WARNING,
324 			    MSG_INTL(MSG_MAP_BADSF1), mapfile,
325 			    EC_XWORD(Line_num), EC_LWORD(badsf1));
326 			ofl->ofl_sfcap_1 &= SF1_SUNW_MASK;
327 		}
328 		if ((ofl->ofl_sfcap_1 &
329 		    (SF1_SUNW_FPKNWN | SF1_SUNW_FPUSED)) == SF1_SUNW_FPUSED) {
330 			eprintf(ofl->ofl_lml, ERR_WARNING,
331 			    MSG_INTL(MSG_MAPFIL_BADSF1), mapfile,
332 			    EC_XWORD(Line_num), EC_LWORD(SF1_SUNW_FPUSED));
333 			ofl->ofl_sfcap_1 &= ~SF1_SUNW_FPUSED;
334 		}
335 #if	!defined(_ELF64)
336 		/*
337 		 * The SF1_SUNW_ADDR32 software capability is only meaningful
338 		 * when building a 64-bit object.  Warn the user, and remove the
339 		 * setting, if we're building a 32-bit object.
340 		 */
341 		if (ofl->ofl_sfcap_1 & SF1_SUNW_ADDR32) {
342 			eprintf(ofl->ofl_lml, ERR_WARNING,
343 			    MSG_INTL(MSG_MAP_INADDR32SF1), mapfile,
344 			    EC_XWORD(Line_num));
345 			ofl->ofl_sfcap_1 &= ~SF1_SUNW_ADDR32;
346 		}
347 #endif
348 	}
349 	return (1);
350 }
351 
352 /*
353  * Common segment error checking.
354  */
355 static Boolean
356 seg_check(const char *mapfile, Sg_desc *sgp, Ofl_desc *ofl, Boolean b_type,
357     Word p_type)
358 {
359 	if (b_type) {
360 		eprintf(ofl->ofl_lml, ERR_FATAL, MSG_INTL(MSG_MAP_MOREONCE),
361 		    mapfile, EC_XWORD(Line_num), MSG_INTL(MSG_MAP_SEGTYP));
362 		return (FALSE);
363 	}
364 	if ((sgp->sg_flags & FLG_SG_TYPE) && (sgp->sg_phdr.p_type != p_type)) {
365 		eprintf(ofl->ofl_lml, ERR_WARNING, MSG_INTL(MSG_MAP_REDEFATT),
366 		    mapfile, EC_XWORD(Line_num), MSG_INTL(MSG_MAP_SEGTYP),
367 		    sgp->sg_name);
368 	}
369 	return (TRUE);
370 }
371 
372 /*
373  * Process a mapfile segment declaration definition.
374  *	segment_name	= segment_attribute;
375  * 	segment_attribute : segment_type  segment_flags  virtual_addr
376  *			    physical_addr  length alignment
377  */
378 static uintptr_t
379 map_equal(const char *mapfile, Sg_desc *sgp, Ofl_desc *ofl)
380 {
381 	Token	tok;			/* Current token. */
382 	Boolean	b_type  = FALSE;	/* True if seg types found. */
383 	Boolean	b_flags = FALSE;	/* True if seg flags found. */
384 	Boolean	b_len   = FALSE;	/* True if seg length found. */
385 	Boolean	b_round = FALSE;	/* True if seg rounding found. */
386 	Boolean	b_vaddr = FALSE;	/* True if seg virtual addr found. */
387 	Boolean	b_paddr = FALSE;	/* True if seg physical addr found. */
388 	Boolean	b_align = FALSE;	/* True if seg alignment found. */
389 
390 	while ((tok = gettoken(ofl, mapfile, 0)) != TK_SEMICOLON) {
391 		if (tok != TK_STRING) {
392 			if (tok != TK_ERROR)
393 				eprintf(ofl->ofl_lml, ERR_FATAL,
394 				    MSG_INTL(MSG_MAP_EXPSEGATT), mapfile,
395 				    EC_XWORD(Line_num));
396 			return (S_ERROR);
397 		}
398 
399 		lowercase(Start_tok);
400 
401 		/*
402 		 * Segment type.  Users are permitted to define PT_LOAD,
403 		 * PT_NOTE, PT_STACK and PT_NULL segments.  Other segment types
404 		 * are only defined in seg_desc[].
405 		 */
406 		if (strcmp(Start_tok, MSG_ORIG(MSG_MAP_LOAD)) == 0) {
407 			if ((b_type = seg_check(mapfile, sgp, ofl, b_type,
408 			    PT_LOAD)) == FALSE)
409 				return (S_ERROR);
410 
411 			sgp->sg_phdr.p_type = PT_LOAD;
412 			sgp->sg_flags |= FLG_SG_TYPE;
413 
414 		} else if (strcmp(Start_tok, MSG_ORIG(MSG_MAP_STACK)) == 0) {
415 			if ((b_type = seg_check(mapfile, sgp, ofl, b_type,
416 			    PT_SUNWSTACK)) == FALSE)
417 				return (S_ERROR);
418 
419 			sgp->sg_phdr.p_type = PT_SUNWSTACK;
420 			sgp->sg_flags |= (FLG_SG_TYPE | FLG_SG_EMPTY);
421 
422 		} else if (strcmp(Start_tok, MSG_ORIG(MSG_MAP_NULL)) == 0) {
423 			if ((b_type = seg_check(mapfile, sgp, ofl, b_type,
424 			    PT_NULL)) == FALSE)
425 				return (S_ERROR);
426 
427 			sgp->sg_phdr.p_type = PT_NULL;
428 			sgp->sg_flags |= FLG_SG_TYPE;
429 
430 		} else if (strcmp(Start_tok, MSG_ORIG(MSG_MAP_NOTE)) == 0) {
431 			if ((b_type = seg_check(mapfile, sgp, ofl, b_type,
432 			    PT_NOTE)) == FALSE)
433 				return (S_ERROR);
434 
435 			sgp->sg_phdr.p_type = PT_NOTE;
436 			sgp->sg_flags |= FLG_SG_TYPE;
437 		}
438 
439 		/* Segment Flags. */
440 
441 		else if (*Start_tok == '?') {
442 			Word	tmp_flags = 0;
443 			char	*flag_tok = Start_tok + 1;
444 
445 			if (b_flags) {
446 				eprintf(ofl->ofl_lml, ERR_FATAL,
447 				    MSG_INTL(MSG_MAP_MOREONCE), mapfile,
448 				    EC_XWORD(Line_num),
449 				    MSG_INTL(MSG_MAP_SEGFLAG));
450 				return (S_ERROR);
451 			}
452 
453 			/*
454 			 * If ? has nothing following leave the flags cleared,
455 			 * otherwise or in any flags specified.
456 			 */
457 			if (*flag_tok) {
458 				while (*flag_tok) {
459 					switch (*flag_tok) {
460 					case 'r':
461 						tmp_flags |= PF_R;
462 						break;
463 					case 'w':
464 						tmp_flags |= PF_W;
465 						break;
466 					case 'x':
467 						tmp_flags |= PF_X;
468 						break;
469 					case 'e':
470 						sgp->sg_flags |= FLG_SG_EMPTY;
471 						break;
472 					case 'o':
473 						sgp->sg_flags |= FLG_SG_ORDER;
474 						ofl->ofl_flags |=
475 						    FLG_OF_SEGORDER;
476 						break;
477 					case 'n':
478 						sgp->sg_flags |= FLG_SG_NOHDR;
479 						break;
480 					default:
481 						eprintf(ofl->ofl_lml, ERR_FATAL,
482 						    MSG_INTL(MSG_MAP_UNKSEGFLG),
483 						    mapfile, EC_XWORD(Line_num),
484 						    *flag_tok);
485 						return (S_ERROR);
486 					}
487 					flag_tok++;
488 				}
489 			}
490 			/*
491 			 * Warn when changing flags except when we're
492 			 * adding or removing "X" from a RW PT_LOAD
493 			 * segment.
494 			 */
495 			if ((sgp->sg_flags & FLG_SG_FLAGS) &&
496 			    (sgp->sg_phdr.p_flags != tmp_flags) &&
497 			    !(sgp->sg_phdr.p_type == PT_LOAD &&
498 			    (tmp_flags & (PF_R|PF_W)) == (PF_R|PF_W) &&
499 			    (tmp_flags ^ sgp->sg_phdr.p_flags) == PF_X)) {
500 				eprintf(ofl->ofl_lml, ERR_WARNING,
501 				    MSG_INTL(MSG_MAP_REDEFATT), mapfile,
502 				    EC_XWORD(Line_num),
503 				    MSG_INTL(MSG_MAP_SEGFLAG), sgp->sg_name);
504 			}
505 			sgp->sg_flags |= FLG_SG_FLAGS;
506 			sgp->sg_phdr.p_flags = tmp_flags;
507 			b_flags = TRUE;
508 		}
509 
510 
511 		/* Segment address, length, alignment or rounding number. */
512 
513 		else if ((Start_tok[0] == 'l') || (Start_tok[0] == 'v') ||
514 		    (Start_tok[0] == 'a') || (Start_tok[0] == 'p') ||
515 		    (Start_tok[0] == 'r')) {
516 			char		*end_tok;
517 			Xword		number;
518 
519 			if ((number = (Xword)STRTOADDR(&Start_tok[1], &end_tok,
520 			    0))	>= XWORD_MAX) {
521 				eprintf(ofl->ofl_lml, ERR_FATAL,
522 				    MSG_INTL(MSG_MAP_SEGADDR), mapfile,
523 				    EC_XWORD(Line_num), Start_tok,
524 				    MSG_INTL(MSG_MAP_EXCLIMIT));
525 				return (S_ERROR);
526 			}
527 
528 			if (end_tok != strchr(Start_tok, '\0')) {
529 				eprintf(ofl->ofl_lml, ERR_FATAL,
530 				    MSG_INTL(MSG_MAP_SEGADDR), mapfile,
531 				    EC_XWORD(Line_num), Start_tok,
532 				    MSG_INTL(MSG_MAP_NOBADFRM));
533 				return (S_ERROR);
534 			}
535 
536 			switch (*Start_tok) {
537 			case 'l':
538 				if (b_len) {
539 					eprintf(ofl->ofl_lml, ERR_FATAL,
540 					    MSG_INTL(MSG_MAP_MOREONCE),
541 					    mapfile, EC_XWORD(Line_num),
542 					    MSG_INTL(MSG_MAP_SEGLEN));
543 					return (S_ERROR);
544 				}
545 				if ((sgp->sg_flags & FLG_SG_LENGTH) &&
546 				    (sgp->sg_length != number))
547 					eprintf(ofl->ofl_lml, ERR_WARNING,
548 					    MSG_INTL(MSG_MAP_REDEFATT),
549 					    mapfile, EC_XWORD(Line_num),
550 					    MSG_INTL(MSG_MAP_SEGLEN),
551 					    sgp->sg_name);
552 				sgp->sg_length = number;
553 				sgp->sg_flags |= FLG_SG_LENGTH;
554 				b_len = TRUE;
555 				break;
556 			case 'r':
557 				if (b_round) {
558 					eprintf(ofl->ofl_lml, ERR_FATAL,
559 					    MSG_INTL(MSG_MAP_MOREONCE),
560 					    mapfile, EC_XWORD(Line_num),
561 					    MSG_INTL(MSG_MAP_SEGROUND));
562 					return (S_ERROR);
563 				}
564 				if ((sgp->sg_flags & FLG_SG_ROUND) &&
565 				    (sgp->sg_round != number))
566 					eprintf(ofl->ofl_lml, ERR_WARNING,
567 					    MSG_INTL(MSG_MAP_REDEFATT),
568 					    mapfile, EC_XWORD(Line_num),
569 					    MSG_INTL(MSG_MAP_SEGROUND),
570 					    sgp->sg_name);
571 				sgp->sg_round = number;
572 				sgp->sg_flags |= FLG_SG_ROUND;
573 				b_round = TRUE;
574 				break;
575 			case 'v':
576 				if (b_vaddr) {
577 					eprintf(ofl->ofl_lml, ERR_FATAL,
578 					    MSG_INTL(MSG_MAP_MOREONCE),
579 					    mapfile, EC_XWORD(Line_num),
580 					    MSG_INTL(MSG_MAP_SEGVADDR));
581 					return (S_ERROR);
582 				}
583 				if ((sgp->sg_flags & FLG_SG_VADDR) &&
584 				    (sgp->sg_phdr.p_vaddr != number))
585 					eprintf(ofl->ofl_lml, ERR_WARNING,
586 					    MSG_INTL(MSG_MAP_REDEFATT),
587 					    mapfile, EC_XWORD(Line_num),
588 					    MSG_INTL(MSG_MAP_SEGVADDR),
589 					    sgp->sg_name);
590 				/* LINTED */
591 				sgp->sg_phdr.p_vaddr = (Addr)number;
592 				sgp->sg_flags |= FLG_SG_VADDR;
593 				ofl->ofl_flags1 |= FLG_OF1_VADDR;
594 				ofl->ofl_flags |= FLG_OF_SEGSORT;
595 				b_vaddr = TRUE;
596 				break;
597 			case 'p':
598 				if (b_paddr) {
599 					eprintf(ofl->ofl_lml, ERR_FATAL,
600 					    MSG_INTL(MSG_MAP_MOREONCE),
601 					    mapfile, EC_XWORD(Line_num),
602 					    MSG_INTL(MSG_MAP_SEGPHYS));
603 					return (S_ERROR);
604 				}
605 				if ((sgp->sg_flags & FLG_SG_PADDR) &&
606 				    (sgp->sg_phdr.p_paddr != number))
607 					eprintf(ofl->ofl_lml, ERR_WARNING,
608 					    MSG_INTL(MSG_MAP_REDEFATT),
609 					    mapfile, EC_XWORD(Line_num),
610 					    MSG_INTL(MSG_MAP_SEGPHYS),
611 					    sgp->sg_name);
612 				/* LINTED */
613 				sgp->sg_phdr.p_paddr = (Addr)number;
614 				sgp->sg_flags |= FLG_SG_PADDR;
615 				b_paddr = TRUE;
616 				break;
617 			case 'a':
618 				if (b_align) {
619 					eprintf(ofl->ofl_lml, ERR_FATAL,
620 					    MSG_INTL(MSG_MAP_MOREONCE),
621 					    mapfile, EC_XWORD(Line_num),
622 					    MSG_INTL(MSG_MAP_SEGALIGN));
623 					return (S_ERROR);
624 				}
625 				if ((sgp->sg_flags & FLG_SG_ALIGN) &&
626 				    (sgp->sg_phdr.p_align != number))
627 					eprintf(ofl->ofl_lml, ERR_WARNING,
628 					    MSG_INTL(MSG_MAP_REDEFATT),
629 					    mapfile, EC_XWORD(Line_num),
630 					    MSG_INTL(MSG_MAP_SEGALIGN),
631 					    sgp->sg_name);
632 				/* LINTED */
633 				sgp->sg_phdr.p_align = (Xword)number;
634 				sgp->sg_flags |= FLG_SG_ALIGN;
635 				b_align = TRUE;
636 				break;
637 			}
638 		} else {
639 			eprintf(ofl->ofl_lml, ERR_FATAL,
640 			    MSG_INTL(MSG_MAP_UNKSEGATT), mapfile,
641 			    EC_XWORD(Line_num), Start_tok);
642 			return (S_ERROR);
643 		}
644 	}
645 
646 	/*
647 	 * Empty segments can be used to define PT_LOAD segment reservations, or
648 	 * to reserve PT_NULL program headers.
649 	 *
650 	 * PT_LOAD reservations are only allowed within executables, as the
651 	 * reservation must be established through exec() as part of initial
652 	 * process loading.  In addition, PT_LOAD reservations must have an
653 	 * associated address and size.
654 	 *
655 	 * PT_NULL program headers are established for later use by applications
656 	 * such as the post-optimizer.  PT_NULL headers should have no other
657 	 * attributes assigned.
658 	 */
659 	if ((sgp->sg_flags & FLG_SG_EMPTY) &&
660 	    (sgp->sg_phdr.p_type != PT_SUNWSTACK)) {
661 
662 		/*
663 		 * Any style of empty segment should have no permissions.
664 		 */
665 		if (sgp->sg_phdr.p_flags != 0) {
666 			eprintf(ofl->ofl_lml, ERR_FATAL,
667 			    MSG_INTL(MSG_MAP_SEGEMNOPERM), mapfile,
668 			    EC_XWORD(Line_num),
669 			    EC_WORD(sgp->sg_phdr.p_flags));
670 			return (S_ERROR);
671 		}
672 
673 		if (sgp->sg_phdr.p_type == PT_LOAD) {
674 			if ((ofl->ofl_flags & FLG_OF_EXEC) == 0) {
675 				eprintf(ofl->ofl_lml, ERR_FATAL,
676 				    MSG_INTL(MSG_MAP_SEGEMPEXE), mapfile,
677 				    EC_XWORD(Line_num));
678 				return (S_ERROR);
679 			}
680 			if ((sgp->sg_flags & (FLG_SG_LENGTH | FLG_SG_VADDR)) !=
681 			    (FLG_SG_LENGTH | FLG_SG_VADDR)) {
682 				eprintf(ofl->ofl_lml, ERR_FATAL,
683 				    MSG_INTL(MSG_MAP_SEGEMPATT), mapfile,
684 				    EC_XWORD(Line_num));
685 				return (S_ERROR);
686 			}
687 		} else if (sgp->sg_phdr.p_type == PT_NULL) {
688 			if ((sgp->sg_flags & (FLG_SG_LENGTH | FLG_SG_VADDR)) &&
689 			    ((sgp->sg_length != 0) ||
690 			    (sgp->sg_phdr.p_vaddr != 0))) {
691 				eprintf(ofl->ofl_lml, ERR_FATAL,
692 				    MSG_INTL(MSG_MAP_SEGEMPNOATT), mapfile,
693 				    EC_XWORD(Line_num));
694 				return (S_ERROR);
695 			}
696 		} else {
697 			eprintf(ofl->ofl_lml, ERR_WARNING,
698 			    MSG_INTL(MSG_MAP_SEGEMPLOAD), mapfile,
699 			    EC_XWORD(Line_num));
700 			sgp->sg_phdr.p_type = PT_LOAD;
701 		}
702 	}
703 
704 	/*
705 	 * All segment attributes have now been scanned.  Certain flags do not
706 	 * make sense if this is not a loadable segment, fix if necessary.
707 	 * Note, if the segment is of type PT_NULL it must be new, and any
708 	 * defaults will be applied back in ld_map_parse().
709 	 * When clearing an attribute leave the flag set as an indicator for
710 	 * later entries re-specifying the same segment.
711 	 */
712 	if ((sgp->sg_phdr.p_type != PT_NULL) &&
713 	    (sgp->sg_phdr.p_type != PT_LOAD)) {
714 		const char	*fmt;
715 
716 		if (sgp->sg_phdr.p_type == PT_SUNWSTACK)
717 			fmt = MSG_INTL(MSG_MAP_NOSTACK1);
718 		else
719 			fmt = MSG_INTL(MSG_MAP_NONLOAD);
720 
721 		if ((sgp->sg_flags & FLG_SG_FLAGS) &&
722 		    (sgp->sg_phdr.p_type != PT_SUNWSTACK)) {
723 			if (sgp->sg_phdr.p_flags != 0) {
724 				eprintf(ofl->ofl_lml, ERR_WARNING,
725 				    MSG_INTL(MSG_MAP_NONLOAD), mapfile,
726 				    EC_XWORD(Line_num),
727 				    MSG_INTL(MSG_MAP_SEGFLAG));
728 				sgp->sg_phdr.p_flags = 0;
729 			}
730 		}
731 		if (sgp->sg_flags & FLG_SG_LENGTH)
732 			if (sgp->sg_length != 0) {
733 				eprintf(ofl->ofl_lml, ERR_WARNING,
734 				    fmt, mapfile, EC_XWORD(Line_num),
735 				    MSG_INTL(MSG_MAP_SEGLEN));
736 				sgp->sg_length = 0;
737 			}
738 		if (sgp->sg_flags & FLG_SG_ROUND)
739 			if (sgp->sg_round != 0) {
740 				eprintf(ofl->ofl_lml, ERR_WARNING,
741 				    fmt, mapfile, EC_XWORD(Line_num),
742 				    MSG_INTL(MSG_MAP_SEGROUND));
743 				sgp->sg_round = 0;
744 			}
745 		if (sgp->sg_flags & FLG_SG_VADDR) {
746 			if (sgp->sg_phdr.p_vaddr != 0) {
747 				eprintf(ofl->ofl_lml, ERR_WARNING,
748 				    fmt, mapfile, EC_XWORD(Line_num),
749 				    MSG_INTL(MSG_MAP_SEGVADDR));
750 				sgp->sg_phdr.p_vaddr = 0;
751 			}
752 		}
753 		if (sgp->sg_flags & FLG_SG_PADDR)
754 			if (sgp->sg_phdr.p_paddr != 0) {
755 				eprintf(ofl->ofl_lml, ERR_WARNING,
756 				    fmt, mapfile, EC_XWORD(Line_num),
757 				    MSG_INTL(MSG_MAP_SEGPHYS));
758 				sgp->sg_phdr.p_paddr = 0;
759 			}
760 		if (sgp->sg_flags & FLG_SG_ALIGN)
761 			if (sgp->sg_phdr.p_align != 0) {
762 				eprintf(ofl->ofl_lml, ERR_WARNING,
763 				    fmt, mapfile, EC_XWORD(Line_num),
764 				    MSG_INTL(MSG_MAP_SEGALIGN));
765 				sgp->sg_phdr.p_align = 0;
766 			}
767 	}
768 	return (1);
769 }
770 
771 
772 /*
773  * Process a mapfile mapping directives definition.
774  * 	segment_name : section_attribute [ : file_name ]
775  * 	segment_attribute : section_name section_type section_flags;
776  */
777 static uintptr_t
778 map_colon(Ofl_desc *ofl, const char *mapfile, Ent_desc *enp)
779 {
780 	Token		tok;		/* Current token. */
781 
782 	Boolean		b_name = FALSE;
783 	Boolean		b_type = FALSE;
784 	Boolean		b_attr = FALSE;
785 	Boolean		b_bang = FALSE;
786 	static	Xword	index = 0;
787 
788 
789 	while (((tok = gettoken(ofl, mapfile, 0)) != TK_COLON) &&
790 	    (tok != TK_SEMICOLON)) {
791 		if ((tok == TK_ERROR) || (tok == TK_EOF))
792 			return (S_ERROR);
793 
794 		/* Segment type. */
795 
796 		if (*Start_tok == '$') {
797 			if (b_type) {
798 				eprintf(ofl->ofl_lml, ERR_FATAL,
799 				    MSG_INTL(MSG_MAP_MOREONCE), mapfile,
800 				    EC_XWORD(Line_num),
801 				    MSG_INTL(MSG_MAP_SECTYP));
802 				return (S_ERROR);
803 			}
804 			b_type = TRUE;
805 			Start_tok++;
806 			lowercase(Start_tok);
807 			if (strcmp(Start_tok, MSG_ORIG(MSG_STR_PROGBITS)) == 0)
808 				enp->ec_type = SHT_PROGBITS;
809 			else if (strcmp(Start_tok,
810 			    MSG_ORIG(MSG_STR_SYMTAB)) == 0)
811 				enp->ec_type = SHT_SYMTAB;
812 			else if (strcmp(Start_tok,
813 			    MSG_ORIG(MSG_STR_DYNSYM)) == 0)
814 				enp->ec_type = SHT_DYNSYM;
815 			else if (strcmp(Start_tok,
816 			    MSG_ORIG(MSG_STR_STRTAB)) == 0)
817 				enp->ec_type = SHT_STRTAB;
818 			else if ((strcmp(Start_tok,
819 			    MSG_ORIG(MSG_STR_REL)) == 0) ||
820 			    (strcmp(Start_tok, MSG_ORIG(MSG_STR_RELA)) == 0))
821 				enp->ec_type = ld_targ.t_m.m_rel_sht_type;
822 			else if (strcmp(Start_tok, MSG_ORIG(MSG_STR_HASH)) == 0)
823 				enp->ec_type = SHT_HASH;
824 			else if (strcmp(Start_tok, MSG_ORIG(MSG_STR_LIB)) == 0)
825 				enp->ec_type = SHT_SHLIB;
826 			else if (strcmp(Start_tok,
827 			    MSG_ORIG(MSG_STR_LD_DYNAMIC)) == 0)
828 				enp->ec_type = SHT_DYNAMIC;
829 			else if (strcmp(Start_tok, MSG_ORIG(MSG_STR_NOTE)) == 0)
830 				enp->ec_type = SHT_NOTE;
831 			else if (strcmp(Start_tok,
832 			    MSG_ORIG(MSG_STR_NOBITS)) == 0)
833 				enp->ec_type = SHT_NOBITS;
834 			else {
835 				eprintf(ofl->ofl_lml, ERR_FATAL,
836 				    MSG_INTL(MSG_MAP_UNKSECTYP), mapfile,
837 				    EC_XWORD(Line_num), Start_tok);
838 				return (S_ERROR);
839 			}
840 
841 		/*
842 		 * Segment flags.
843 		 * If a segment flag is specified then the appropriate bit is
844 		 * set in the ec_attrmask, the ec_attrbits fields determine
845 		 * whether the attrmask fields must be tested true or false
846 		 * ie.	for  ?A the attrmask is set and the attrbit is set,
847 		 *	for ?!A the attrmask is set and the attrbit is clear.
848 		 */
849 		} else if (*Start_tok == '?') {
850 			if (b_attr) {
851 				eprintf(ofl->ofl_lml, ERR_FATAL,
852 				    MSG_INTL(MSG_MAP_MOREONCE), mapfile,
853 				    EC_XWORD(Line_num),
854 				    MSG_INTL(MSG_MAP_SECFLAG));
855 				return (S_ERROR);
856 			}
857 			b_attr = TRUE;
858 			b_bang = FALSE;
859 			Start_tok++;
860 			lowercase(Start_tok);
861 			for (; *Start_tok != '\0'; Start_tok++)
862 				switch (*Start_tok) {
863 				case '!':
864 					if (b_bang) {
865 						eprintf(ofl->ofl_lml, ERR_FATAL,
866 						    MSG_INTL(MSG_MAP_BADFLAG),
867 						    mapfile, EC_XWORD(Line_num),
868 						    Start_tok);
869 						return (S_ERROR);
870 					}
871 					b_bang = TRUE;
872 					break;
873 				case 'a':
874 					if (enp->ec_attrmask & SHF_ALLOC) {
875 						eprintf(ofl->ofl_lml, ERR_FATAL,
876 						    MSG_INTL(MSG_MAP_BADFLAG),
877 						    mapfile, EC_XWORD(Line_num),
878 						    Start_tok);
879 						return (S_ERROR);
880 					}
881 					enp->ec_attrmask |= SHF_ALLOC;
882 					if (!b_bang)
883 						enp->ec_attrbits |= SHF_ALLOC;
884 					b_bang = FALSE;
885 					break;
886 				case 'w':
887 					if (enp->ec_attrmask & SHF_WRITE) {
888 						eprintf(ofl->ofl_lml, ERR_FATAL,
889 						    MSG_INTL(MSG_MAP_BADFLAG),
890 						    mapfile, EC_XWORD(Line_num),
891 						    Start_tok);
892 						return (S_ERROR);
893 					}
894 					enp->ec_attrmask |= SHF_WRITE;
895 					if (!b_bang)
896 						enp->ec_attrbits |= SHF_WRITE;
897 					b_bang = FALSE;
898 					break;
899 				case 'x':
900 					if (enp->ec_attrmask & SHF_EXECINSTR) {
901 						eprintf(ofl->ofl_lml, ERR_FATAL,
902 						    MSG_INTL(MSG_MAP_BADFLAG),
903 						    mapfile, EC_XWORD(Line_num),
904 						    Start_tok);
905 						return (S_ERROR);
906 					}
907 					enp->ec_attrmask |= SHF_EXECINSTR;
908 					if (!b_bang)
909 						enp->ec_attrbits |=
910 						    SHF_EXECINSTR;
911 					b_bang = FALSE;
912 					break;
913 				default:
914 					eprintf(ofl->ofl_lml, ERR_FATAL,
915 					    MSG_INTL(MSG_MAP_BADFLAG),
916 					    mapfile, EC_XWORD(Line_num),
917 					    Start_tok);
918 					return (S_ERROR);
919 				}
920 		/*
921 		 * Section name.
922 		 */
923 		} else {
924 			if (b_name) {
925 				eprintf(ofl->ofl_lml, ERR_FATAL,
926 				    MSG_INTL(MSG_MAP_MOREONCE), mapfile,
927 				    EC_XWORD(Line_num),
928 				    MSG_INTL(MSG_MAP_SECNAME));
929 				return (S_ERROR);
930 			}
931 			b_name = TRUE;
932 			if ((enp->ec_name =
933 			    libld_malloc(strlen(Start_tok) + 1)) == NULL)
934 				return (S_ERROR);
935 			(void) strcpy((char *)enp->ec_name, Start_tok);
936 			/*
937 			 * Set the index for text reordering.
938 			 */
939 			enp->ec_ordndx = ++index;
940 		}
941 	}
942 	if (tok == TK_COLON) {
943 		/*
944 		 * File names.
945 		 */
946 		while ((tok = gettoken(ofl, mapfile, 0)) != TK_SEMICOLON) {
947 			char	*file;
948 
949 			if (tok != TK_STRING) {
950 				if (tok != TK_ERROR)
951 					eprintf(ofl->ofl_lml, ERR_FATAL,
952 					    MSG_INTL(MSG_MAP_MALFORM), mapfile,
953 					    EC_XWORD(Line_num));
954 				return (S_ERROR);
955 			}
956 			if ((file =
957 			    libld_malloc(strlen(Start_tok) + 1)) == NULL)
958 				return (S_ERROR);
959 			(void) strcpy(file, Start_tok);
960 
961 			if (aplist_append(&(enp->ec_files), file,
962 			    AL_CNT_EC_FILES) == NULL)
963 				return (S_ERROR);
964 		}
965 	}
966 	return (1);
967 }
968 
969 /*
970  * Obtain a pseudo input file descriptor to assign to a mapfile.  This is
971  * required any time a symbol is generated.  Traverse the input file
972  * descriptors looking for a match.  As all mapfile processing occurs before
973  * any real input file processing this list is going to be small and we don't
974  * need to do any filename clash checking.
975  */
976 static Ifl_desc *
977 map_ifl(const char *mapfile, Ofl_desc *ofl)
978 {
979 	Ifl_desc	*ifl;
980 	Aliste		idx;
981 
982 	for (APLIST_TRAVERSE(ofl->ofl_objs, idx, ifl))
983 		if (strcmp(ifl->ifl_name, mapfile) == 0)
984 			return (ifl);
985 
986 	if ((ifl = libld_calloc(sizeof (Ifl_desc), 1)) == NULL)
987 		return ((Ifl_desc *)S_ERROR);
988 	ifl->ifl_name = mapfile;
989 	ifl->ifl_flags = (FLG_IF_MAPFILE | FLG_IF_NEEDED | FLG_IF_FILEREF);
990 	if ((ifl->ifl_ehdr = libld_calloc(sizeof (Ehdr), 1)) == NULL)
991 		return ((Ifl_desc *)S_ERROR);
992 	ifl->ifl_ehdr->e_type = ET_REL;
993 
994 	if (aplist_append(&ofl->ofl_objs, ifl, AL_CNT_OFL_OBJS) == NULL)
995 		return ((Ifl_desc *)S_ERROR);
996 	else
997 		return (ifl);
998 }
999 
1000 /*
1001  * Process a mapfile size symbol definition.
1002  * 	segment_name @ symbol_name;
1003  */
1004 static uintptr_t
1005 map_atsign(const char *mapfile, Sg_desc *sgp, Ofl_desc *ofl)
1006 {
1007 	Sym		*sym;		/* New symbol pointer */
1008 	Sym_desc	*sdp;		/* New symbol node pointer */
1009 	Ifl_desc	*ifl;		/* Dummy input file structure */
1010 	Token		tok;		/* Current token. */
1011 	avl_index_t	where;
1012 
1013 	if ((tok = gettoken(ofl, mapfile, 0)) != TK_STRING) {
1014 		if (tok != TK_ERROR)
1015 			eprintf(ofl->ofl_lml, ERR_FATAL,
1016 			    MSG_INTL(MSG_MAP_EXPSYM_1), mapfile,
1017 			    EC_XWORD(Line_num));
1018 		return (S_ERROR);
1019 	}
1020 
1021 	if (sgp->sg_sizesym != NULL) {
1022 		eprintf(ofl->ofl_lml, ERR_FATAL, MSG_INTL(MSG_MAP_SEGSIZE),
1023 		    mapfile, EC_XWORD(Line_num), sgp->sg_name);
1024 		return (S_ERROR);
1025 	}
1026 
1027 	/*
1028 	 * Make sure we have a pseudo file descriptor to associate to the
1029 	 * symbol.
1030 	 */
1031 	if ((ifl = map_ifl(mapfile, ofl)) == (Ifl_desc *)S_ERROR)
1032 		return (S_ERROR);
1033 
1034 	/*
1035 	 * Make sure the symbol doesn't already exist.  It is possible that the
1036 	 * symbol has been scoped or versioned, in which case it does exist
1037 	 * but we can freely update it here.
1038 	 */
1039 	if ((sdp = ld_sym_find(Start_tok, SYM_NOHASH, &where, ofl)) == NULL) {
1040 		char	*name;
1041 		Word hval;
1042 
1043 		if ((name = libld_malloc(strlen(Start_tok) + 1)) == NULL)
1044 			return (S_ERROR);
1045 		(void) strcpy(name, Start_tok);
1046 
1047 		if ((sym = libld_calloc(sizeof (Sym), 1)) == NULL)
1048 			return (S_ERROR);
1049 		sym->st_shndx = SHN_ABS;
1050 		sym->st_size = 0;
1051 		sym->st_info = ELF_ST_INFO(STB_GLOBAL, STT_OBJECT);
1052 
1053 		DBG_CALL(Dbg_map_size_new(ofl->ofl_lml, name));
1054 		/* LINTED */
1055 		hval = (Word)elf_hash(name);
1056 		if ((sdp = ld_sym_enter(name, sym, hval, ifl, ofl, 0, SHN_ABS,
1057 		    (FLG_SY_SPECSEC | FLG_SY_GLOBREF), &where)) ==
1058 		    (Sym_desc *)S_ERROR)
1059 			return (S_ERROR);
1060 		sdp->sd_flags &= ~FLG_SY_CLEAN;
1061 		DBG_CALL(Dbg_map_symbol(ofl, sdp));
1062 	} else {
1063 		sym = sdp->sd_sym;
1064 
1065 		if (sym->st_shndx == SHN_UNDEF) {
1066 			sdp->sd_shndx = sym->st_shndx = SHN_ABS;
1067 			sdp->sd_flags |= FLG_SY_SPECSEC;
1068 			sym->st_size = 0;
1069 			sym->st_info = ELF_ST_INFO(STB_GLOBAL, STT_OBJECT);
1070 
1071 			sdp->sd_flags &= ~FLG_SY_MAPREF;
1072 
1073 			DBG_CALL(Dbg_map_size_old(ofl, sdp));
1074 		} else {
1075 			eprintf(ofl->ofl_lml, ERR_FATAL,
1076 			    MSG_INTL(MSG_MAP_SYMDEF1), mapfile,
1077 			    EC_XWORD(Line_num), demangle(sdp->sd_name),
1078 			    sdp->sd_file->ifl_name,
1079 			    MSG_INTL(MSG_MAP_DIFF_SYMMUL));
1080 			return (S_ERROR);
1081 		}
1082 	}
1083 
1084 	/*
1085 	 * Assign the symbol to the segment.
1086 	 */
1087 	sgp->sg_sizesym = sdp;
1088 
1089 	if (gettoken(ofl, mapfile, 0) != TK_SEMICOLON) {
1090 		if (tok != TK_ERROR)
1091 			eprintf(ofl->ofl_lml, ERR_FATAL,
1092 			    MSG_INTL(MSG_MAP_EXPSCOL), mapfile,
1093 			    EC_XWORD(Line_num));
1094 		return (S_ERROR);
1095 	}
1096 
1097 	return (1);
1098 }
1099 
1100 
1101 static uintptr_t
1102 map_pipe(Ofl_desc *ofl, const char *mapfile, Sg_desc *sgp)
1103 {
1104 	char		*sec_name;	/* section name */
1105 	Token		tok;		/* current token. */
1106 	Sec_order	*sc_order;
1107 	static Word	index = 0;	/* used to maintain a increasing */
1108 					/* 	index for section ordering. */
1109 
1110 	if ((tok = gettoken(ofl, mapfile, 0)) != TK_STRING) {
1111 		if (tok != TK_ERROR)
1112 			eprintf(ofl->ofl_lml, ERR_FATAL,
1113 			    MSG_INTL(MSG_MAP_EXPSEC), mapfile,
1114 			    EC_XWORD(Line_num));
1115 		return (S_ERROR);
1116 	}
1117 
1118 	if ((sec_name = libld_malloc(strlen(Start_tok) + 1)) == NULL)
1119 		return (S_ERROR);
1120 	(void) strcpy(sec_name, Start_tok);
1121 
1122 	if ((sc_order = libld_malloc(sizeof (Sec_order))) == NULL)
1123 		return (S_ERROR);
1124 
1125 	sc_order->sco_secname = sec_name;
1126 	sc_order->sco_index = ++index;
1127 
1128 	if (aplist_append(&sgp->sg_secorder, sc_order,
1129 	    AL_CNT_SG_SECORDER) == NULL)
1130 		return (S_ERROR);
1131 
1132 	ofl->ofl_flags |= FLG_OF_SECORDER;
1133 	DBG_CALL(Dbg_map_pipe(ofl->ofl_lml, sgp, sec_name, index));
1134 
1135 	if ((tok = gettoken(ofl, mapfile, 0)) != TK_SEMICOLON) {
1136 		if (tok != TK_ERROR)
1137 			eprintf(ofl->ofl_lml, ERR_FATAL,
1138 			    MSG_INTL(MSG_MAP_EXPSCOL), mapfile,
1139 			    EC_XWORD(Line_num));
1140 		return (S_ERROR);
1141 	}
1142 
1143 	return (1);
1144 }
1145 
1146 /*
1147  * Process a mapfile library specification definition.
1148  * 	shared_object_name - shared object definition
1149  *	shared object definition : [ shared object type [ = SONAME ]]
1150  *					[ versions ];
1151  */
1152 static uintptr_t
1153 map_dash(const char *mapfile, char *name, Ofl_desc *ofl)
1154 {
1155 	char		*version;
1156 	Token		tok;
1157 	Sdf_desc	*sdf;
1158 	Sdv_desc	sdv;
1159 	enum {
1160 	    MD_NONE = 0,
1161 	    MD_ADDVERS,
1162 	}		dolkey = MD_NONE;
1163 
1164 
1165 	/*
1166 	 * If a shared object definition for this file already exists use it,
1167 	 * otherwise allocate a new descriptor.
1168 	 */
1169 	if ((sdf = sdf_find(name, ofl->ofl_socntl)) == NULL) {
1170 		if ((sdf = sdf_add(name, &ofl->ofl_socntl)) ==
1171 		    (Sdf_desc *)S_ERROR)
1172 			return (S_ERROR);
1173 		sdf->sdf_rfile = mapfile;
1174 	}
1175 
1176 	/*
1177 	 * Get the shared object descriptor string.
1178 	 */
1179 	while ((tok = gettoken(ofl, mapfile, 0)) != TK_SEMICOLON) {
1180 		if ((tok != TK_STRING) && (tok != TK_EQUAL)) {
1181 			if (tok != TK_ERROR)
1182 				eprintf(ofl->ofl_lml, ERR_FATAL,
1183 				    MSG_INTL(MSG_MAP_EXPSO), mapfile,
1184 				    EC_XWORD(Line_num));
1185 			return (S_ERROR);
1186 		}
1187 
1188 		/*
1189 		 * Determine if the library type is accompanied with a SONAME
1190 		 * definition.
1191 		 */
1192 		if (tok == TK_EQUAL) {
1193 			if ((tok = gettoken(ofl, mapfile, 0)) != TK_STRING) {
1194 				if (tok != TK_ERROR)
1195 					eprintf(ofl->ofl_lml, ERR_FATAL,
1196 					    MSG_INTL(MSG_MAP_EXPSO), mapfile,
1197 					    EC_XWORD(Line_num));
1198 				return (S_ERROR);
1199 			}
1200 			switch (dolkey) {
1201 			case MD_ADDVERS:
1202 				sdf->sdf_flags |= FLG_SDF_ADDVER;
1203 
1204 				if ((version = libld_malloc(
1205 				    strlen(Start_tok) + 1)) == NULL)
1206 					return (S_ERROR);
1207 				(void) strcpy(version, Start_tok);
1208 
1209 				sdv.sdv_name = version;
1210 				sdv.sdv_ref = mapfile;
1211 				sdv.sdv_flags = 0;
1212 
1213 				if (alist_append(&sdf->sdf_verneed, &sdv,
1214 				    sizeof (Sdv_desc),
1215 				    AL_CNT_SDF_VERSIONS) == NULL)
1216 					return (S_ERROR);
1217 				break;
1218 			case MD_NONE:
1219 				eprintf(ofl->ofl_lml, ERR_FATAL,
1220 				    MSG_INTL(MSG_MAP_UNEXTOK), mapfile,
1221 				    EC_XWORD(Line_num), '=');
1222 				return (S_ERROR);
1223 			}
1224 			dolkey = MD_NONE;
1225 			continue;
1226 		}
1227 
1228 		/*
1229 		 * A shared object type has been specified.  This may also be
1230 		 * accompanied by an SONAME redefinition (see above).
1231 		 */
1232 		if (*Start_tok == '$') {
1233 			if (dolkey != MD_NONE) {
1234 				eprintf(ofl->ofl_lml, ERR_FATAL,
1235 				    MSG_INTL(MSG_MAP_UNEXTOK), mapfile,
1236 				    EC_XWORD(Line_num), '$');
1237 				return (S_ERROR);
1238 			}
1239 			Start_tok++;
1240 			lowercase(Start_tok);
1241 			if (strcmp(Start_tok,
1242 			    MSG_ORIG(MSG_MAP_ADDVERS)) == 0)
1243 				dolkey = MD_ADDVERS;
1244 			else {
1245 				eprintf(ofl->ofl_lml, ERR_FATAL,
1246 				    MSG_INTL(MSG_MAP_UNKSOTYP), mapfile,
1247 				    EC_XWORD(Line_num), Start_tok);
1248 				return (S_ERROR);
1249 			}
1250 			continue;
1251 		}
1252 
1253 		/*
1254 		 * shared object version requirement.
1255 		 */
1256 		if ((version = libld_malloc(strlen(Start_tok) + 1)) == NULL)
1257 			return (S_ERROR);
1258 		(void) strcpy(version, Start_tok);
1259 
1260 		sdf->sdf_flags |= FLG_SDF_SELECT;
1261 
1262 		sdv.sdv_name = version;
1263 		sdv.sdv_ref = mapfile;
1264 		sdv.sdv_flags = 0;
1265 
1266 		if (alist_append(&sdf->sdf_vers, &sdv, sizeof (Sdv_desc),
1267 		    AL_CNT_SDF_VERSIONS) == NULL)
1268 			return (S_ERROR);
1269 	}
1270 
1271 	DBG_CALL(Dbg_map_dash(ofl->ofl_lml, name));
1272 	return (1);
1273 }
1274 
1275 
1276 /*
1277  * Process a symbol definition.  Historically, this originated from processing
1278  * a version definition.  However, this has evolved into a generic means of
1279  * defining symbol references and definitions (see Defining Additional Symbols
1280  * in the Linker and Libraries guide for the complete syntax).
1281  *
1282  * [ name ] {
1283  *	scope:
1284  *		 symbol [ = [ type ] [ value ] [ size ] [ attribute ] ];
1285  * } [ dependency ];
1286  *
1287  */
1288 #define	FLG_SCOPE_HIDD	0		/* symbol defined hidden/local */
1289 #define	FLG_SCOPE_DFLT	1		/* symbol defined default/global */
1290 #define	FLG_SCOPE_PROT	2		/* symbol defined protected/symbolic */
1291 #define	FLG_SCOPE_EXPT	3		/* symbol defined exported */
1292 #define	FLG_SCOPE_SNGL	4		/* symbol defined singleton */
1293 #define	FLG_SCOPE_ELIM	5		/* symbol defined eliminate */
1294 
1295 static uintptr_t
1296 map_version(const char *mapfile, char *name, Ofl_desc *ofl)
1297 {
1298 	Token		tok;
1299 	Sym		*sym;
1300 	int		scope = FLG_SCOPE_DFLT, errcnt = 0;
1301 	Ver_desc	*vdp;
1302 	Word		hash;
1303 	Ifl_desc	*ifl;
1304 	avl_index_t	where;
1305 
1306 	/*
1307 	 * If we're generating segments within the image then any symbol
1308 	 * reductions will be processed (ie. applied to relocations and symbol
1309 	 * table entries).  Otherwise (when creating a relocatable object) any
1310 	 * versioning information is simply recorded for use in a later
1311 	 * (segment generating) link-edit.
1312 	 */
1313 	if (ofl->ofl_flags & FLG_OF_RELOBJ)
1314 		ofl->ofl_flags |= FLG_OF_VERDEF;
1315 
1316 	/*
1317 	 * If this is a new mapfile reference generate an input file descriptor
1318 	 * to represent it.  Otherwise this must simply be a new version within
1319 	 * the mapfile we've previously been processing, in this case continue
1320 	 * to use the original input file descriptor.
1321 	 */
1322 	if ((ifl = map_ifl(mapfile, ofl)) == (Ifl_desc *)S_ERROR)
1323 		return (S_ERROR);
1324 
1325 	/*
1326 	 * If no version descriptors have yet been set up, initialize a base
1327 	 * version to represent the output file itself.  This `base' version
1328 	 * catches any internally generated symbols (_end, _etext, etc.) and
1329 	 * serves to initialize the output version descriptor count.
1330 	 */
1331 	if (ofl->ofl_vercnt == 0) {
1332 		if (ld_vers_base(ofl) == (Ver_desc *)S_ERROR)
1333 			return (S_ERROR);
1334 	}
1335 
1336 	/*
1337 	 * If this definition has an associated version name then generate a
1338 	 * new version descriptor and an associated version symbol index table.
1339 	 */
1340 	if (name) {
1341 		ofl->ofl_flags |= FLG_OF_VERDEF;
1342 
1343 		/*
1344 		 * Traverse the present version descriptor list to see if there
1345 		 * is already one of the same name, otherwise create a new one.
1346 		 */
1347 		/* LINTED */
1348 		hash = (Word)elf_hash(name);
1349 		if (((vdp = ld_vers_find(name, hash,
1350 		    ofl->ofl_verdesc)) == NULL) &&
1351 		    ((vdp = ld_vers_desc(name, hash,
1352 		    &ofl->ofl_verdesc)) == (Ver_desc *)S_ERROR))
1353 			return (S_ERROR);
1354 
1355 		/*
1356 		 * Initialize any new version with an index, the file from which
1357 		 * it was first referenced, and a WEAK flag (indicates that
1358 		 * there are no symbols assigned to it yet).
1359 		 */
1360 		if (vdp->vd_ndx == 0) {
1361 			/* LINTED */
1362 			vdp->vd_ndx = (Half)++ofl->ofl_vercnt;
1363 			vdp->vd_file = ifl;
1364 			vdp->vd_flags = VER_FLG_WEAK;
1365 		}
1366 	} else {
1367 		/*
1368 		 * If a version definition hasn't been specified assign any
1369 		 * symbols to the base version.
1370 		 */
1371 		vdp = (Ver_desc *)ofl->ofl_verdesc->apl_data[0];
1372 	}
1373 
1374 	/*
1375 	 * Scan the mapfile entry picking out scoping and symbol definitions.
1376 	 */
1377 	while ((tok = gettoken(ofl, mapfile, 0)) != TK_RIGHTBKT) {
1378 		Sym_desc	*sdp;
1379 		Word		shndx = SHN_UNDEF;
1380 		uchar_t 	type = STT_NOTYPE;
1381 		Addr		value = 0, size = 0;
1382 		char		*_name, *filtee = NULL;
1383 		sd_flag_t	sdflags = 0;
1384 		uint_t		filter = 0, novalue = 1, dftflag;
1385 		const char	*conflict;
1386 
1387 		if ((tok != TK_STRING) && (tok != TK_COLON)) {
1388 			if (tok == TK_ERROR)
1389 				eprintf(ofl->ofl_lml, ERR_FATAL,
1390 				    MSG_INTL(MSG_MAP_EXPSYM_2), mapfile,
1391 				    EC_XWORD(Line_num));
1392 			if ((tok == TK_ERROR) || (tok == TK_EOF))
1393 				return (S_ERROR);
1394 			errcnt++;
1395 			continue;
1396 		}
1397 
1398 		if ((_name = libld_malloc(strlen(Start_tok) + 1)) == NULL)
1399 			return (S_ERROR);
1400 		(void) strcpy(_name, Start_tok);
1401 
1402 		if (tok != TK_COLON) {
1403 			tok = gettoken(ofl, mapfile, 0);
1404 			if ((tok == TK_ERROR) || (tok == TK_EOF)) {
1405 				errcnt++;
1406 				continue;
1407 			}
1408 		}
1409 
1410 		/*
1411 		 * Turn off the WEAK flag to indicate that definitions are
1412 		 * associated with this version.  It would probably be more
1413 		 * accurate to only remove this flag with the specification of
1414 		 * global symbols, however setting it here allows enough slop
1415 		 * to compensate for the various user inputs we've seen so far.
1416 		 * Only if a closed version is specified (i.e., "SUNW_1.x {};")
1417 		 * will a user get a weak version (which is how we document the
1418 		 * creation of weak versions).
1419 		 */
1420 		vdp->vd_flags &= ~VER_FLG_WEAK;
1421 
1422 		switch (tok) {
1423 		case TK_COLON:
1424 			/*
1425 			 * Establish a new scope.  All symbols added by this
1426 			 * mapfile are actually global entries, and are assigned
1427 			 * the scope that is presently in effect.
1428 			 *
1429 			 * If a protected/symbolic scope is detected, remember
1430 			 * this.  If a protected/symbolic scope is the only
1431 			 * scope defined in this (or any other mapfiles), then
1432 			 * the mode -Bsymbolic is established.
1433 			 */
1434 			if ((strcmp(MSG_ORIG(MSG_MAP_DEFAULT), _name) == 0) ||
1435 			    (strcmp(MSG_ORIG(MSG_MAP_GLOBAL), _name) == 0)) {
1436 				scope = FLG_SCOPE_DFLT;
1437 				ofl->ofl_flags |= FLG_OF_MAPGLOB;
1438 
1439 			} else if ((strcmp(MSG_ORIG(MSG_MAP_HIDDEN),
1440 			    _name) == 0) ||
1441 			    (strcmp(MSG_ORIG(MSG_STR_LOCAL), _name) == 0)) {
1442 				scope = FLG_SCOPE_HIDD;
1443 
1444 			} else if ((strcmp(MSG_ORIG(MSG_MAP_PROTECTED),
1445 			    _name) == 0) ||
1446 			    (strcmp(MSG_ORIG(MSG_STR_SYMBOLIC), _name) == 0)) {
1447 				scope = FLG_SCOPE_PROT;
1448 				ofl->ofl_flags |= FLG_OF_MAPSYMB;
1449 
1450 			} else if (strcmp(MSG_ORIG(MSG_STR_EXPORTED),
1451 			    _name) == 0) {
1452 				scope = FLG_SCOPE_EXPT;
1453 
1454 			} else if (strcmp(MSG_ORIG(MSG_STR_SINGLETON),
1455 			    _name) == 0) {
1456 				scope = FLG_SCOPE_SNGL;
1457 				ofl->ofl_flags |= FLG_OF_MAPGLOB;
1458 
1459 			} else if (strcmp(MSG_ORIG(MSG_STR_ELIMINATE),
1460 			    _name) == 0) {
1461 				scope = FLG_SCOPE_ELIM;
1462 
1463 			} else {
1464 				eprintf(ofl->ofl_lml, ERR_FATAL,
1465 				    MSG_INTL(MSG_MAP_UNKSYMSCO), mapfile,
1466 				    EC_XWORD(Line_num), _name);
1467 				errcnt++;
1468 				break;
1469 			}
1470 			continue;
1471 
1472 		case TK_EQUAL:
1473 			/*
1474 			 * A full blown symbol definition follows.
1475 			 * Determine the symbol type and any virtual address or
1476 			 * alignment specified and then fall through to process
1477 			 * the entire symbols information.
1478 			 */
1479 			while ((tok = gettoken(ofl, mapfile, 0)) !=
1480 			    TK_SEMICOLON) {
1481 				if ((tok == TK_ERROR) || (tok == TK_EOF))
1482 					return (S_ERROR);
1483 				/*
1484 				 * If we had previously seen a filter or
1485 				 * auxiliary filter requirement, the next string
1486 				 * is the filtee itself.
1487 				 */
1488 				if (filter) {
1489 					if (filtee) {
1490 					    /* BEGIN CSTYLED */
1491 					    eprintf(ofl->ofl_lml, ERR_FATAL,
1492 						MSG_INTL(MSG_MAP_MULTFILTEE),
1493 						mapfile, EC_XWORD(Line_num));
1494 					    errcnt++;
1495 					    continue;
1496 					    /* END CSTYLED */
1497 					}
1498 					if ((filtee = libld_malloc(
1499 					    strlen(Start_tok) + 1)) == NULL)
1500 						return (S_ERROR);
1501 					(void) strcpy(filtee, Start_tok);
1502 					filter = 0;
1503 					continue;
1504 				}
1505 
1506 				/*
1507 				 * Determine any Value or Size attributes.
1508 				 */
1509 				lowercase(Start_tok);
1510 
1511 				if (Start_tok[0] == 'v' ||
1512 				    Start_tok[0] == 's') {
1513 					char		*end_tok;
1514 					Lword		number;
1515 
1516 					if ((number = (Lword)STRTOADDR(
1517 					    &Start_tok[1], &end_tok, 0)) ==
1518 					    XWORD_MAX) {
1519 						eprintf(ofl->ofl_lml, ERR_FATAL,
1520 						    MSG_INTL(MSG_MAP_SEGADDR),
1521 						    mapfile, EC_XWORD(Line_num),
1522 						    Start_tok,
1523 						    MSG_INTL(MSG_MAP_EXCLIMIT));
1524 						errcnt++;
1525 						continue;
1526 					}
1527 
1528 					if (end_tok !=
1529 					    strchr(Start_tok, '\0')) {
1530 						eprintf(ofl->ofl_lml, ERR_FATAL,
1531 						    MSG_INTL(MSG_MAP_SEGADDR),
1532 						    mapfile, EC_XWORD(Line_num),
1533 						    Start_tok,
1534 						    MSG_INTL(MSG_MAP_NOBADFRM));
1535 						errcnt++;
1536 						continue;
1537 					}
1538 
1539 					switch (*Start_tok) {
1540 					case 'v':
1541 					    /* BEGIN CSTYLED */
1542 					    if (value) {
1543 						eprintf(ofl->ofl_lml, ERR_FATAL,
1544 						    MSG_INTL(MSG_MAP_MOREONCE),
1545 						    mapfile, EC_XWORD(Line_num),
1546 						    MSG_INTL(MSG_MAP_SYMVAL));
1547 						errcnt++;
1548 						continue;
1549 					    }
1550 					    /* LINTED */
1551 					    value = (Addr)number;
1552 					    novalue = 0;
1553 					    break;
1554 					    /* END CSTYLED */
1555 					case 's':
1556 					    /* BEGIN CSTYLED */
1557 					    if (size) {
1558 						eprintf(ofl->ofl_lml, ERR_FATAL,
1559 						    MSG_INTL(MSG_MAP_MOREONCE),
1560 						    mapfile, EC_XWORD(Line_num),
1561 						    MSG_INTL(MSG_MAP_SYMSIZE));
1562 						errcnt++;
1563 						continue;
1564 					    }
1565 					    /* LINTED */
1566 					    size = (Addr)number;
1567 					    break;
1568 					    /* END CSTYLED */
1569 					}
1570 
1571 				} else if (strcmp(Start_tok,
1572 				    MSG_ORIG(MSG_MAP_FUNCTION)) == 0) {
1573 					shndx = SHN_ABS;
1574 					sdflags |= FLG_SY_SPECSEC;
1575 					type = STT_FUNC;
1576 				} else if (strcmp(Start_tok,
1577 				    MSG_ORIG(MSG_MAP_DATA)) == 0) {
1578 					shndx = SHN_ABS;
1579 					sdflags |= FLG_SY_SPECSEC;
1580 					type = STT_OBJECT;
1581 				} else if (strcmp(Start_tok,
1582 				    MSG_ORIG(MSG_MAP_COMMON)) == 0) {
1583 					shndx = SHN_COMMON;
1584 					sdflags |= FLG_SY_SPECSEC;
1585 					type = STT_OBJECT;
1586 				} else if (strcmp(Start_tok,
1587 				    MSG_ORIG(MSG_MAP_PARENT)) == 0) {
1588 					sdflags |= FLG_SY_PARENT;
1589 					ofl->ofl_flags |= FLG_OF_SYMINFO;
1590 				} else if (strcmp(Start_tok,
1591 				    MSG_ORIG(MSG_MAP_EXTERN)) == 0) {
1592 					sdflags |= FLG_SY_EXTERN;
1593 					ofl->ofl_flags |= FLG_OF_SYMINFO;
1594 				} else if (strcmp(Start_tok,
1595 				    MSG_ORIG(MSG_MAP_DIRECT)) == 0) {
1596 					sdflags |= FLG_SY_DIR;
1597 					ofl->ofl_flags |= FLG_OF_SYMINFO;
1598 				} else if (strcmp(Start_tok,
1599 				    MSG_ORIG(MSG_MAP_NODIRECT)) == 0) {
1600 					sdflags |= FLG_SY_NDIR;
1601 					ofl->ofl_flags |= FLG_OF_SYMINFO;
1602 					ofl->ofl_flags1 |=
1603 					    (FLG_OF1_NDIRECT | FLG_OF1_NGLBDIR);
1604 				} else if (strcmp(Start_tok,
1605 				    MSG_ORIG(MSG_MAP_FILTER)) == 0) {
1606 					/* BEGIN CSTYLED */
1607 					if (!(ofl->ofl_flags &
1608 					    FLG_OF_SHAROBJ)) {
1609 					    eprintf(ofl->ofl_lml, ERR_FATAL,
1610 						MSG_INTL(MSG_MAP_FLTR_ONLYAVL),
1611 						mapfile, EC_XWORD(Line_num));
1612 					    errcnt++;
1613 					    break;
1614 					}
1615 					/* END CSTYLED */
1616 					dftflag = filter = FLG_SY_STDFLTR;
1617 					sdflags |= FLG_SY_STDFLTR;
1618 					ofl->ofl_flags |= FLG_OF_SYMINFO;
1619 					continue;
1620 				} else if (strcmp(Start_tok,
1621 				    MSG_ORIG(MSG_MAP_AUXILIARY)) == 0) {
1622 					/* BEGIN CSTYLED */
1623 					if (!(ofl->ofl_flags &
1624 					    FLG_OF_SHAROBJ)) {
1625 					    eprintf(ofl->ofl_lml, ERR_FATAL,
1626 						MSG_INTL(MSG_MAP_FLTR_ONLYAVL),
1627 						mapfile, EC_XWORD(Line_num));
1628 					    errcnt++;
1629 					    break;
1630 					}
1631 					/* END CSTYLED */
1632 					dftflag = filter = FLG_SY_AUXFLTR;
1633 					sdflags |= FLG_SY_AUXFLTR;
1634 					ofl->ofl_flags |= FLG_OF_SYMINFO;
1635 					continue;
1636 				} else if (strcmp(Start_tok,
1637 				    MSG_ORIG(MSG_MAP_INTERPOSE)) == 0) {
1638 					/* BEGIN CSTYLED */
1639 					if (!(ofl->ofl_flags & FLG_OF_EXEC)) {
1640 					    eprintf(ofl->ofl_lml, ERR_FATAL,
1641 						MSG_INTL(MSG_MAP_NOINTPOSE),
1642 						mapfile, EC_XWORD(Line_num));
1643 					    errcnt++;
1644 					    break;
1645 					}
1646 					/* END CSTYLED */
1647 					sdflags |= FLG_SY_INTPOSE;
1648 					ofl->ofl_flags |= FLG_OF_SYMINFO;
1649 					ofl->ofl_dtflags_1 |= DF_1_SYMINTPOSE;
1650 					continue;
1651 				} else if (strcmp(Start_tok,
1652 				    MSG_ORIG(MSG_MAP_DYNSORT)) == 0) {
1653 					sdflags |= FLG_SY_DYNSORT;
1654 					sdflags &= ~FLG_SY_NODYNSORT;
1655 					continue;
1656 				} else if (strcmp(Start_tok,
1657 				    MSG_ORIG(MSG_MAP_NODYNSORT)) == 0) {
1658 					sdflags &= ~FLG_SY_DYNSORT;
1659 					sdflags |= FLG_SY_NODYNSORT;
1660 					continue;
1661 				} else {
1662 					eprintf(ofl->ofl_lml, ERR_FATAL,
1663 					    MSG_INTL(MSG_MAP_UNKSYMDEF),
1664 					    mapfile, EC_XWORD(Line_num),
1665 					    Start_tok);
1666 					errcnt++;
1667 					continue;
1668 				}
1669 			}
1670 			/* FALLTHROUGH */
1671 
1672 		case TK_SEMICOLON:
1673 			/*
1674 			 * The special auto-reduction directive `*' can be
1675 			 * specified in hidden/local, and eliminate scope.  This
1676 			 * directive indicates that all symbols processed that
1677 			 * are not explicitly defined to be global are to be
1678 			 * reduced to hidden/local scope in, or eliminated from,
1679 			 * the output image.
1680 			 *
1681 			 * An auto-reduction directive also implies that a
1682 			 * version definition be created, as the user has
1683 			 * effectively defined an interface.
1684 			 */
1685 			if (*_name == '*') {
1686 				if (scope == FLG_SCOPE_HIDD)
1687 					ofl->ofl_flags |=
1688 					    (FLG_OF_VERDEF | FLG_OF_AUTOLCL);
1689 				else if (scope == FLG_SCOPE_ELIM) {
1690 					ofl->ofl_flags |=
1691 					    (FLG_OF_VERDEF | FLG_OF_AUTOELM);
1692 				}
1693 				continue;
1694 			}
1695 
1696 			/*
1697 			 * Add the new symbol.  It should be noted that all
1698 			 * symbols added by the mapfile start out with global
1699 			 * scope, thus they will fall through the normal symbol
1700 			 * resolution process.  Symbols defined as locals will
1701 			 * be reduced in scope after all input file processing.
1702 			 */
1703 			/* LINTED */
1704 			hash = (Word)elf_hash(_name);
1705 			DBG_CALL(Dbg_map_version(ofl->ofl_lml, name, _name,
1706 			    scope));
1707 			if ((sdp = ld_sym_find(_name, hash, &where,
1708 			    ofl)) == NULL) {
1709 				if ((sym =
1710 				    libld_calloc(sizeof (Sym), 1)) == NULL)
1711 					return (S_ERROR);
1712 
1713 				/*
1714 				 * Make sure any parent or external declarations
1715 				 * fall back to references.
1716 				 */
1717 				if (sdflags & (FLG_SY_PARENT | FLG_SY_EXTERN)) {
1718 					/*
1719 					 * Turn it into a reference by setting
1720 					 * the section index to UNDEF.
1721 					 */
1722 					sym->st_shndx = shndx = SHN_UNDEF;
1723 
1724 					/*
1725 					 * It is wrong to to specify size
1726 					 * or value for an external symbol.
1727 					 */
1728 					if ((novalue == 0) || (size != 0)) {
1729 						eprintf(ofl->ofl_lml, ERR_FATAL,
1730 						    MSG_INTL(MSG_MAP_NOEXVLSZ),
1731 						    mapfile,
1732 						    EC_XWORD(Line_num));
1733 						errcnt++;
1734 						continue;
1735 					}
1736 				} else {
1737 					sym->st_shndx = (Half)shndx;
1738 				}
1739 
1740 				sym->st_value = value;
1741 				sym->st_size = size;
1742 				sym->st_info = ELF_ST_INFO(STB_GLOBAL, type);
1743 
1744 				if ((sdp = ld_sym_enter(_name, sym, hash,
1745 				    ifl, ofl, 0, shndx, sdflags,
1746 				    &where)) == (Sym_desc *)S_ERROR)
1747 					return (S_ERROR);
1748 
1749 				sdp->sd_flags &= ~FLG_SY_CLEAN;
1750 
1751 				/*
1752 				 * Identify any references.  FLG_SY_MAPREF is
1753 				 * turned off once a relocatable object with
1754 				 * the same symbol is found, thus the existence
1755 				 * of FLG_SY_MAPREF at symbol validation is
1756 				 * used to flag undefined/misspelled entries.
1757 				 */
1758 				if (sym->st_shndx == SHN_UNDEF)
1759 					sdp->sd_flags |=
1760 					    (FLG_SY_MAPREF | FLG_SY_GLOBREF);
1761 
1762 			} else {
1763 				conflict = NULL;
1764 				sym = sdp->sd_sym;
1765 
1766 				/*
1767 				 * If this symbol already exists, make sure this
1768 				 * definition doesn't conflict with the former.
1769 				 * Provided it doesn't, multiple definitions
1770 				 * from different mapfiles can augment each
1771 				 * other.
1772 				 */
1773 				/* BEGIN CSTYLED */
1774 				if (sym->st_value) {
1775 				    if (value && (sym->st_value != value))
1776 					conflict =
1777 					    MSG_INTL(MSG_MAP_DIFF_SYMVAL);
1778 				} else {
1779 					sym->st_value = value;
1780 				}
1781 				if (sym->st_size) {
1782 				    if (size && (sym->st_size != size))
1783 					conflict = MSG_INTL(MSG_MAP_DIFF_SYMSZ);
1784 				} else {
1785 					sym->st_size = size;
1786 				}
1787 				if (ELF_ST_TYPE(sym->st_info) != STT_NOTYPE) {
1788 				    if ((type != STT_NOTYPE) &&
1789 					(ELF_ST_TYPE(sym->st_info) != type))
1790 					    conflict =
1791 						MSG_INTL(MSG_MAP_DIFF_SYMTYP);
1792 				} else {
1793 					sym->st_info =
1794 					    ELF_ST_INFO(STB_GLOBAL, type);
1795 				}
1796 				if (sym->st_shndx != SHN_UNDEF) {
1797 				    if ((shndx != SHN_UNDEF) &&
1798 					(sym->st_shndx != shndx))
1799 					    conflict =
1800 						MSG_INTL(MSG_MAP_DIFF_SYMNDX);
1801 				} else {
1802 					sym->st_shndx = sdp->sd_shndx = shndx;
1803 				}
1804 				/* END CSTYLED */
1805 
1806 				if ((sdp->sd_flags & MSK_SY_GLOBAL) &&
1807 				    (sdp->sd_aux->sa_overndx !=
1808 				    VER_NDX_GLOBAL) &&
1809 				    (vdp->vd_ndx != VER_NDX_GLOBAL) &&
1810 				    (sdp->sd_aux->sa_overndx != vdp->vd_ndx)) {
1811 					conflict =
1812 					    MSG_INTL(MSG_MAP_DIFF_SYMVER);
1813 				}
1814 
1815 				if (conflict) {
1816 					eprintf(ofl->ofl_lml, ERR_FATAL,
1817 					    MSG_INTL(MSG_MAP_SYMDEF1), mapfile,
1818 					    EC_XWORD(Line_num), demangle(_name),
1819 					    sdp->sd_file->ifl_name, conflict);
1820 					errcnt++;
1821 					continue;
1822 				}
1823 
1824 				/*
1825 				 * If this mapfile entry supplies a definition,
1826 				 * indicate that the symbol is now used.
1827 				 */
1828 				if (shndx != SHN_UNDEF)
1829 					sdp->sd_flags |= FLG_SY_MAPUSED;
1830 			}
1831 
1832 			/*
1833 			 * A symbol declaration that defines a size but no
1834 			 * value is processed as a request to create an
1835 			 * associated backing section.  The intent behind this
1836 			 * functionality is to provide OBJT definitions within
1837 			 * filters that are not ABS.  ABS symbols don't allow
1838 			 * copy-relocations to be established to filter OBJT
1839 			 * definitions.
1840 			 */
1841 			if ((shndx == SHN_ABS) && size && novalue) {
1842 				/* Create backing section if not there */
1843 				if (sdp->sd_isc == NULL) {
1844 					Is_desc	*isp;
1845 
1846 					if (type == STT_OBJECT) {
1847 						if ((isp = ld_make_data(ofl,
1848 						    size)) ==
1849 						    (Is_desc *)S_ERROR)
1850 							return (S_ERROR);
1851 					} else {
1852 						if ((isp = ld_make_text(ofl,
1853 						    size)) ==
1854 						    (Is_desc *)S_ERROR)
1855 							return (S_ERROR);
1856 					}
1857 
1858 					sdp->sd_isc = isp;
1859 					isp->is_file = ifl;
1860 				}
1861 
1862 				/*
1863 				 * Now that backing storage has been created,
1864 				 * associate the symbol descriptor.  Remove the
1865 				 * symbols special section tag so that it will
1866 				 * be assigned the correct section index as part
1867 				 * of update symbol processing.
1868 				 */
1869 				sdp->sd_flags &= ~FLG_SY_SPECSEC;
1870 				sdflags &= ~FLG_SY_SPECSEC;
1871 			}
1872 
1873 			/*
1874 			 * Indicate the new symbols scope.  Although the
1875 			 * symbols st_other field will eventually be updated as
1876 			 * part of writing out the final symbol, update the
1877 			 * st_other field here to trigger better diagnostics
1878 			 * during symbol validation (for example, undefined
1879 			 * references that are defined symbolic in a mapfile).
1880 			 */
1881 			if (scope == FLG_SCOPE_HIDD) {
1882 				/*
1883 				 * This symbol needs to be reduced to local.
1884 				 */
1885 				if (ofl->ofl_flags & FLG_OF_REDLSYM) {
1886 					sdp->sd_flags |=
1887 					    (FLG_SY_HIDDEN | FLG_SY_ELIM);
1888 					sdp->sd_sym->st_other = STV_ELIMINATE;
1889 				} else {
1890 					sdp->sd_flags |= FLG_SY_HIDDEN;
1891 					sdp->sd_sym->st_other = STV_HIDDEN;
1892 				}
1893 			} else if (scope == FLG_SCOPE_ELIM) {
1894 				/*
1895 				 * This symbol needs to be eliminated.  Note,
1896 				 * the symbol is also tagged as local to trigger
1897 				 * any necessary relocation processing prior
1898 				 * to the symbol being eliminated.
1899 				 */
1900 				sdp->sd_flags |= (FLG_SY_HIDDEN | FLG_SY_ELIM);
1901 				sdp->sd_sym->st_other = STV_ELIMINATE;
1902 
1903 			} else {
1904 				/*
1905 				 * This symbol is explicitly defined to remain
1906 				 * global.
1907 				 */
1908 				sdp->sd_flags |= sdflags;
1909 
1910 				/*
1911 				 * Qualify any global scope.
1912 				 */
1913 				if (scope == FLG_SCOPE_SNGL) {
1914 					sdp->sd_flags |=
1915 					    (FLG_SY_SINGLE | FLG_SY_NDIR);
1916 					sdp->sd_sym->st_other = STV_SINGLETON;
1917 				} else if (scope == FLG_SCOPE_PROT) {
1918 					sdp->sd_flags |= FLG_SY_PROTECT;
1919 					sdp->sd_sym->st_other = STV_PROTECTED;
1920 				} else if (scope == FLG_SCOPE_EXPT) {
1921 					sdp->sd_flags |= FLG_SY_EXPORT;
1922 					sdp->sd_sym->st_other = STV_EXPORTED;
1923 				} else
1924 					sdp->sd_flags |= FLG_SY_DEFAULT;
1925 
1926 				/*
1927 				 * Record the present version index for later
1928 				 * potential versioning.
1929 				 */
1930 				if ((sdp->sd_aux->sa_overndx == 0) ||
1931 				    (sdp->sd_aux->sa_overndx == VER_NDX_GLOBAL))
1932 					sdp->sd_aux->sa_overndx = vdp->vd_ndx;
1933 				vdp->vd_flags |= FLG_VER_REFER;
1934 			}
1935 
1936 			conflict = NULL;
1937 
1938 			/*
1939 			 * Carry out some validity checks to ensure incompatible
1940 			 * symbol characteristics have not been defined.
1941 			 * These checks are carried out after symbols are added
1942 			 * or resolved, to catch single instance, and
1943 			 * multi-instance definition inconsistencies.
1944 			 */
1945 			if ((sdp->sd_flags & (FLG_SY_HIDDEN | FLG_SY_ELIM)) &&
1946 			    ((scope != FLG_SCOPE_HIDD) &&
1947 			    (scope != FLG_SCOPE_ELIM))) {
1948 				conflict = MSG_INTL(MSG_MAP_DIFF_SYMLCL);
1949 
1950 			} else if ((sdp->sd_flags &
1951 			    (FLG_SY_SINGLE | FLG_SY_EXPORT)) &&
1952 			    ((scope != FLG_SCOPE_DFLT) &&
1953 			    (scope != FLG_SCOPE_EXPT) &&
1954 			    (scope != FLG_SCOPE_SNGL))) {
1955 				conflict = MSG_INTL(MSG_MAP_DIFF_SYMGLOB);
1956 
1957 			} else if ((sdp->sd_flags & FLG_SY_PROTECT) &&
1958 			    ((scope != FLG_SCOPE_DFLT) &&
1959 			    (scope != FLG_SCOPE_PROT))) {
1960 				conflict = MSG_INTL(MSG_MAP_DIFF_SYMPROT);
1961 
1962 			} else if ((sdp->sd_flags & FLG_SY_NDIR) &&
1963 			    (scope == FLG_SCOPE_PROT)) {
1964 				conflict = MSG_INTL(MSG_MAP_DIFF_PROTNDIR);
1965 
1966 			} else if ((sdp->sd_flags & FLG_SY_DIR) &&
1967 			    (scope == FLG_SCOPE_SNGL)) {
1968 				conflict = MSG_INTL(MSG_MAP_DIFF_SNGLDIR);
1969 			}
1970 
1971 			if (conflict) {
1972 				/*
1973 				 * Select the conflict message from either a
1974 				 * single instance or multi-instance definition.
1975 				 */
1976 				if (sdp->sd_file->ifl_name == mapfile) {
1977 					eprintf(ofl->ofl_lml, ERR_FATAL,
1978 					    MSG_INTL(MSG_MAP_SYMDEF2), mapfile,
1979 					    EC_XWORD(Line_num), demangle(_name),
1980 					    conflict);
1981 				} else {
1982 					eprintf(ofl->ofl_lml, ERR_FATAL,
1983 					    MSG_INTL(MSG_MAP_SYMDEF1), mapfile,
1984 					    EC_XWORD(Line_num), demangle(_name),
1985 					    sdp->sd_file->ifl_name, conflict);
1986 				}
1987 				errcnt++;
1988 				continue;
1989 			}
1990 
1991 			/*
1992 			 * Indicate that this symbol has been explicitly
1993 			 * contributed from a mapfile.
1994 			 */
1995 			sdp->sd_flags |= (FLG_SY_MAPFILE | FLG_SY_EXPDEF);
1996 
1997 			/*
1998 			 * If we've encountered a symbol definition simulate
1999 			 * that an input file has been processed - this allows
2000 			 * things like filters to be created purely from a
2001 			 * mapfile.
2002 			 */
2003 			if (type != STT_NOTYPE)
2004 				ofl->ofl_objscnt++;
2005 			DBG_CALL(Dbg_map_symbol(ofl, sdp));
2006 
2007 			/*
2008 			 * If this symbol has an associated filtee, record the
2009 			 * filtee string and associate the string index with the
2010 			 * symbol.  This is used later to associate the syminfo
2011 			 * information with the necessary .dynamic entry.
2012 			 */
2013 			if (filter && (filtee == NULL)) {
2014 				eprintf(ofl->ofl_lml, ERR_FATAL,
2015 				    MSG_INTL(MSG_MAP_NOFILTER), mapfile,
2016 				    EC_XWORD(Line_num), _name);
2017 				errcnt++;
2018 				continue;
2019 			}
2020 
2021 			if (filtee) {
2022 				Dfltr_desc *	dftp;
2023 				Sfltr_desc	sft;
2024 				Aliste		idx, _idx, nitems;
2025 
2026 				/*
2027 				 * Make sure we don't duplicate any filtee
2028 				 * strings, and create a new descriptor if
2029 				 * necessary.
2030 				 */
2031 				idx = nitems = alist_nitems(ofl->ofl_dtsfltrs);
2032 				for (ALIST_TRAVERSE(ofl->ofl_dtsfltrs, _idx,
2033 				    dftp)) {
2034 					if ((dftflag != dftp->dft_flag) ||
2035 					    (strcmp(dftp->dft_str, filtee)))
2036 						continue;
2037 					idx = _idx;
2038 					break;
2039 				}
2040 				if (idx == nitems) {
2041 					Dfltr_desc	dft;
2042 
2043 					dft.dft_str = filtee;
2044 					dft.dft_flag = dftflag;
2045 					dft.dft_ndx = 0;
2046 
2047 					/*
2048 					 * The following append puts the new
2049 					 * item at the offset contained in
2050 					 * idx, because we know idx contains
2051 					 * the index of the next available slot.
2052 					 */
2053 					if (alist_append(&ofl->ofl_dtsfltrs,
2054 					    &dft, sizeof (Dfltr_desc),
2055 					    AL_CNT_OFL_DTSFLTRS) == NULL)
2056 						return (S_ERROR);
2057 				}
2058 
2059 				/*
2060 				 * Create a new filter descriptor for this
2061 				 * symbol.
2062 				 */
2063 				sft.sft_sdp = sdp;
2064 				sft.sft_idx = idx;
2065 
2066 				if (alist_append(&ofl->ofl_symfltrs,
2067 				    &sft, sizeof (Sfltr_desc),
2068 				    AL_CNT_OFL_SYMFLTRS) == NULL)
2069 					return (S_ERROR);
2070 			}
2071 			break;
2072 
2073 		default:
2074 			eprintf(ofl->ofl_lml, ERR_FATAL,
2075 			    MSG_INTL(MSG_MAP_EXPSCOL), mapfile,
2076 			    EC_XWORD(Line_num));
2077 			errcnt++;
2078 			continue;
2079 		}
2080 	}
2081 
2082 	if (errcnt)
2083 		return (S_ERROR);
2084 
2085 	/*
2086 	 * Determine if any version references are provided after the close
2087 	 * bracket.
2088 	 */
2089 	while ((tok = gettoken(ofl, mapfile, 0)) != TK_SEMICOLON) {
2090 		Ver_desc	*_vdp;
2091 		char		*_name;
2092 
2093 		if (tok != TK_STRING) {
2094 			if (tok != TK_ERROR)
2095 				eprintf(ofl->ofl_lml, ERR_FATAL,
2096 				    MSG_INTL(MSG_MAP_EXPVERS), mapfile,
2097 				    EC_XWORD(Line_num));
2098 			return (S_ERROR);
2099 		}
2100 
2101 		name = Start_tok;
2102 		if (vdp->vd_ndx == VER_NDX_GLOBAL) {
2103 			eprintf(ofl->ofl_lml, ERR_WARNING,
2104 			    MSG_INTL(MSG_MAP_UNEXDEP), mapfile,
2105 			    EC_XWORD(Line_num), name);
2106 			continue;
2107 		}
2108 
2109 		/*
2110 		 * Generate a new version descriptor if it doesn't already
2111 		 * exist.
2112 		 */
2113 		/* LINTED */
2114 		hash = (Word)elf_hash(name);
2115 		if ((_vdp = ld_vers_find(name, hash,
2116 		    ofl->ofl_verdesc)) == NULL) {
2117 			if ((_name = libld_malloc(strlen(name) + 1)) == NULL)
2118 				return (S_ERROR);
2119 			(void) strcpy(_name, name);
2120 
2121 			if ((_vdp = ld_vers_desc(_name, hash,
2122 			    &ofl->ofl_verdesc)) == (Ver_desc *)S_ERROR)
2123 				return (S_ERROR);
2124 		}
2125 
2126 		/*
2127 		 * Add the new version descriptor to the parent version
2128 		 * descriptors reference list.  Indicate the version descriptors
2129 		 * first reference (used for error disgnostics if undefined
2130 		 * version dependencies remain).
2131 		 */
2132 		if (ld_vers_find(name, hash, vdp->vd_deps) == NULL)
2133 			if (aplist_append(&vdp->vd_deps, _vdp,
2134 			    AL_CNT_VERDESCS) == NULL)
2135 				return (S_ERROR);
2136 
2137 		if (_vdp->vd_ref == NULL)
2138 			_vdp->vd_ref = vdp;
2139 	}
2140 	return (1);
2141 }
2142 
2143 /*
2144  * If a user has provided segment definitions via a mapfile, and these segments
2145  * have been assigned virtual addresses, sort the associated segments by
2146  * increasing virtual address.
2147  *
2148  * Only PT_LOAD segments can be assigned a virtual address.  These segments can
2149  * be one of two types:
2150  *
2151  *  -	Standard segments for text, data or bss.  These segments will have been
2152  *	inserted before the default text (first PT_LOAD) segment.
2153  *
2154  *  -	Empty (reservation) segments.  These segment will have been inserted at
2155  *	the end of any default PT_LOAD segments.
2156  *
2157  * Any standard segments that are assigned a virtual address will be sorted,
2158  * and as their definitions precede any default PT_LOAD segments, these segments
2159  * will be assigned sections before any defaults.
2160  *
2161  * Any reservation segments are also sorted amoung themselves, as these segments
2162  * must still follow the standard default segments.
2163  */
2164 uintptr_t
2165 ld_sort_seg_list(Ofl_desc *ofl)
2166 {
2167 	APlist	*seg1 = NULL, *seg2 = NULL;
2168 	Sg_desc	*sgp1;
2169 	Aliste	idx1;
2170 
2171 #define	FIRST_SEGMENT(type) \
2172 	((type == PT_PHDR) || (type == PT_INTERP) || (type == PT_SUNWCAP))
2173 
2174 	/*
2175 	 * Add the .phdr and .interp segments to our list.  These segments must
2176 	 * occur before any PT_LOAD segments (refer exec/elf/elf.c).  Also add
2177 	 * the capabilities segment.  This isn't essential, but the capabilities
2178 	 * section is one of the first in an object.
2179 	 */
2180 	for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp1)) {
2181 		Word	type = sgp1->sg_phdr.p_type;
2182 
2183 		if (FIRST_SEGMENT(type)) {
2184 			if (aplist_append(&seg1, sgp1, AL_CNT_SEGMENTS) == NULL)
2185 				return (S_ERROR);
2186 		}
2187 	}
2188 
2189 	/*
2190 	 * Add the loadable segments to another list in sorted order.
2191 	 */
2192 	DBG_CALL(Dbg_map_sort(ofl->ofl_lml));
2193 	for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp1)) {
2194 		DBG_CALL(Dbg_map_sort_seg(ofl->ofl_lml, sgp1, 1));
2195 
2196 		if (sgp1->sg_phdr.p_type != PT_LOAD)
2197 			continue;
2198 
2199 		/*
2200 		 * If the loadable segment does not contain a vaddr, simply
2201 		 * append it to the new list.
2202 		 */
2203 		if ((sgp1->sg_flags & FLG_SG_VADDR) == 0) {
2204 			if (aplist_append(&seg2, sgp1, AL_CNT_SEGMENTS) == NULL)
2205 				return (S_ERROR);
2206 
2207 		} else {
2208 			Aliste		idx2;
2209 			Sg_desc		*sgp2;
2210 			int		inserted = 0;
2211 
2212 			/*
2213 			 * Traverse the segment list we are creating, looking
2214 			 * for a segment that defines a vaddr.
2215 			 */
2216 			for (APLIST_TRAVERSE(seg2, idx2, sgp2)) {
2217 				/*
2218 				 * Any real segments that contain vaddr's need
2219 				 * to be sorted.  Any reservation segments also
2220 				 * need to be sorted.  However, any reservation
2221 				 * segments should be placed after any real
2222 				 * segments.
2223 				 */
2224 				if (((sgp2->sg_flags &
2225 				    (FLG_SG_VADDR | FLG_SG_EMPTY)) == 0) &&
2226 				    (sgp1->sg_flags & FLG_SG_EMPTY))
2227 					continue;
2228 
2229 				if ((sgp2->sg_flags & FLG_SG_VADDR) &&
2230 				    ((sgp2->sg_flags & FLG_SG_EMPTY) ==
2231 				    (sgp1->sg_flags & FLG_SG_EMPTY))) {
2232 					if (sgp1->sg_phdr.p_vaddr ==
2233 					    sgp2->sg_phdr.p_vaddr) {
2234 						eprintf(ofl->ofl_lml, ERR_FATAL,
2235 						    MSG_INTL(MSG_MAP_SEGSAME),
2236 						    sgp1->sg_name,
2237 						    sgp2->sg_name);
2238 						return (S_ERROR);
2239 					}
2240 
2241 					if (sgp1->sg_phdr.p_vaddr >
2242 					    sgp2->sg_phdr.p_vaddr)
2243 						continue;
2244 				}
2245 
2246 				/*
2247 				 * Insert this segment before the segment on
2248 				 * the seg2 list.
2249 				 */
2250 				if (aplist_insert(&seg2, sgp1, AL_CNT_SEGMENTS,
2251 				    idx2) == NULL)
2252 					return (S_ERROR);
2253 				inserted = 1;
2254 				break;
2255 			}
2256 
2257 			/*
2258 			 * If the segment being inspected has not been inserted
2259 			 * in the segment list, simply append it to the list.
2260 			 */
2261 			if ((inserted == 0) && (aplist_append(&seg2,
2262 			    sgp1, AL_CNT_SEGMENTS) == NULL))
2263 				return (S_ERROR);
2264 		}
2265 	}
2266 
2267 	/*
2268 	 * Add the sorted loadable segments to our initial segment list.
2269 	 */
2270 	for (APLIST_TRAVERSE(seg2, idx1, sgp1)) {
2271 		if (aplist_append(&seg1, sgp1, AL_CNT_SEGMENTS) == NULL)
2272 			return (S_ERROR);
2273 	}
2274 
2275 	/*
2276 	 * Add all other segments to our list.
2277 	 */
2278 	for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp1)) {
2279 		Word	type = sgp1->sg_phdr.p_type;
2280 
2281 		if (!FIRST_SEGMENT(type) && (type != PT_LOAD)) {
2282 			if (aplist_append(&seg1, sgp1, AL_CNT_SEGMENTS) == NULL)
2283 				return (S_ERROR);
2284 		}
2285 	}
2286 	free((void *)ofl->ofl_segs);
2287 	ofl->ofl_segs = NULL;
2288 
2289 	/*
2290 	 * Now rebuild the original list and process all of the
2291 	 * segment/section ordering information if present.
2292 	 */
2293 	for (APLIST_TRAVERSE(seg1, idx1, sgp1)) {
2294 		DBG_CALL(Dbg_map_sort_seg(ofl->ofl_lml, sgp1, 0));
2295 		if (aplist_append(&ofl->ofl_segs, sgp1,
2296 		    AL_CNT_SEGMENTS) == NULL)
2297 			return (S_ERROR);
2298 	}
2299 
2300 #undef	FIRST_SEGMENT
2301 
2302 	return (1);
2303 }
2304 
2305 /*
2306  * Parse the mapfile.
2307  */
2308 uintptr_t
2309 ld_map_parse(const char *mapfile, Ofl_desc *ofl)
2310 {
2311 	struct stat	stat_buf;	/* stat of mapfile */
2312 	int		mapfile_fd;	/* descriptor for mapfile */
2313 	Sg_desc		*sgp1;		/* seg descriptor being manipulated */
2314 	Sg_desc		*sgp2;		/* temp segment descriptor pointer */
2315 	Ent_desc	*enp;		/* Segment entrance criteria. */
2316 	Token		tok;		/* current token. */
2317 	Aliste		endx = 0;	/* next place for entrance criterion */
2318 	Boolean		new_segment;	/* If true, defines new segment. */
2319 	char		*name;
2320 	static	int	num_stack = 0;	/* number of stack segment */
2321 	int		err;
2322 
2323 	DBG_CALL(Dbg_map_parse(ofl->ofl_lml, mapfile));
2324 
2325 	/*
2326 	 * Determine if we're dealing with a file or a directory.
2327 	 */
2328 	if (stat(mapfile, &stat_buf) == -1) {
2329 		err = errno;
2330 		eprintf(ofl->ofl_lml, ERR_FATAL, MSG_INTL(MSG_SYS_STAT),
2331 		    mapfile, strerror(err));
2332 		return (S_ERROR);
2333 	}
2334 	if (S_ISDIR(stat_buf.st_mode)) {
2335 		DIR		*dirp;
2336 		struct dirent	*denp;
2337 
2338 		/*
2339 		 * Open the directory and interpret each visible file as a
2340 		 * mapfile.
2341 		 */
2342 		if ((dirp = opendir(mapfile)) == NULL)
2343 			return (1);
2344 
2345 		while ((denp = readdir(dirp)) != NULL) {
2346 			char	path[PATH_MAX];
2347 
2348 			/*
2349 			 * Ignore any hidden filenames.  Construct the full
2350 			 * pathname to the new mapfile.
2351 			 */
2352 			if (*denp->d_name == '.')
2353 				continue;
2354 			(void) snprintf(path, PATH_MAX, MSG_ORIG(MSG_STR_PATH),
2355 			    mapfile, denp->d_name);
2356 			if (ld_map_parse(path, ofl) == S_ERROR)
2357 				return (S_ERROR);
2358 		}
2359 		(void) closedir(dirp);
2360 		return (1);
2361 	} else if (!S_ISREG(stat_buf.st_mode)) {
2362 		eprintf(ofl->ofl_lml, ERR_FATAL, MSG_INTL(MSG_SYS_NOTREG),
2363 		    mapfile);
2364 		return (S_ERROR);
2365 	}
2366 
2367 	/*
2368 	 * We read the entire mapfile into memory.
2369 	 */
2370 	if ((Mapspace = libld_malloc(stat_buf.st_size + 1)) == NULL)
2371 		return (S_ERROR);
2372 	if ((mapfile_fd = open(mapfile, O_RDONLY)) == -1) {
2373 		err = errno;
2374 		eprintf(ofl->ofl_lml, ERR_FATAL, MSG_INTL(MSG_SYS_OPEN),
2375 		    mapfile, strerror(err));
2376 		return (S_ERROR);
2377 	}
2378 
2379 	if (read(mapfile_fd, Mapspace, stat_buf.st_size) != stat_buf.st_size) {
2380 		err = errno;
2381 		eprintf(ofl->ofl_lml, ERR_FATAL, MSG_INTL(MSG_SYS_READ),
2382 		    mapfile, strerror(err));
2383 		return (S_ERROR);
2384 	}
2385 	Mapspace[stat_buf.st_size] = '\0';
2386 	nextchr = Mapspace;
2387 
2388 	/*
2389 	 * Set up any global variables, the line number counter and file name.
2390 	 */
2391 	Line_num = 1;
2392 
2393 	/*
2394 	 * We now parse the mapfile until the gettoken routine returns EOF.
2395 	 */
2396 	while ((tok = gettoken(ofl, mapfile, 1)) != TK_EOF) {
2397 		Aliste	idx;
2398 		int	ndx;
2399 
2400 		/*
2401 		 * Don't know which segment yet.
2402 		 */
2403 		sgp1 = NULL;
2404 
2405 		/*
2406 		 * At this point we are at the beginning of a line, and the
2407 		 * variable `Start_tok' points to the first string on the line.
2408 		 * All mapfile entries start with some string token except it
2409 		 * is possible for a scoping definition to start with `{'.
2410 		 */
2411 		if (tok == TK_LEFTBKT) {
2412 			if (map_version(mapfile, (char *)0, ofl) == S_ERROR)
2413 				return (S_ERROR);
2414 			continue;
2415 		}
2416 		if (tok != TK_STRING) {
2417 			if (tok != TK_ERROR)
2418 				eprintf(ofl->ofl_lml, ERR_FATAL,
2419 				    MSG_INTL(MSG_MAP_EXPSEGNAM), mapfile,
2420 				    EC_XWORD(Line_num));
2421 			return (S_ERROR);
2422 		}
2423 
2424 		/*
2425 		 * Save the initial token.
2426 		 */
2427 		if ((name = libld_malloc(strlen(Start_tok) + 1)) == NULL)
2428 			return (S_ERROR);
2429 		(void) strcpy(name, Start_tok);
2430 
2431 		/*
2432 		 * Now check the second character on the line.  The special `-'
2433 		 * and `{' characters do not involve any segment manipulation so
2434 		 * we handle them first.
2435 		 */
2436 		tok = gettoken(ofl, mapfile, 0);
2437 		if ((tok == TK_ERROR) || (tok == TK_EOF))
2438 			return (S_ERROR);
2439 		if (tok == TK_DASH) {
2440 			if (map_dash(mapfile, name, ofl) == S_ERROR)
2441 				return (S_ERROR);
2442 			continue;
2443 		}
2444 		if (tok == TK_LEFTBKT) {
2445 			if (map_version(mapfile, name, ofl) == S_ERROR)
2446 				return (S_ERROR);
2447 			continue;
2448 		}
2449 
2450 		/*
2451 		 * If we're here we need to interpret the first string as a
2452 		 * segment name.  Find the segment named in the token.
2453 		 */
2454 		ndx = 0;
2455 		for (APLIST_TRAVERSE(ofl->ofl_segs, idx, sgp2)) {
2456 			if (strcmp(sgp2->sg_name, name) == 0) {
2457 				sgp1 = sgp2;
2458 				sgp2->sg_flags &= ~FLG_SG_DISABLED;
2459 				new_segment = FALSE;
2460 				break;
2461 			}
2462 			ndx++;
2463 		}
2464 
2465 		/*
2466 		 * If the second token is a '|' then we had better have found a
2467 		 * segment.  It is illegal to perform section within segment
2468 		 * ordering before the segment has been declared.
2469 		 */
2470 		if (tok == TK_PIPE) {
2471 			if (sgp1 == NULL) {
2472 				eprintf(ofl->ofl_lml, ERR_FATAL,
2473 				    MSG_INTL(MSG_MAP_SECINSEG), mapfile,
2474 				    EC_XWORD(Line_num), name);
2475 				return (S_ERROR);
2476 			} else {
2477 				if (map_pipe(ofl, mapfile, sgp1) == S_ERROR)
2478 					return (S_ERROR);
2479 				continue;
2480 			}
2481 		}
2482 
2483 		/*
2484 		 * If segment is still NULL then it does not exist.  Create a
2485 		 * new segment, and leave its values as 0 so that map_equal()
2486 		 * can detect changing attributes.
2487 		 */
2488 		if (sgp1 == NULL) {
2489 			if ((sgp1 =
2490 			    libld_calloc(sizeof (Sg_desc), 1)) == NULL)
2491 				return (S_ERROR);
2492 			sgp1->sg_phdr.p_type = PT_NULL;
2493 			sgp1->sg_name = name;
2494 			new_segment = TRUE;
2495 		}
2496 
2497 		if ((strcmp(sgp1->sg_name, MSG_ORIG(MSG_STR_INTERP)) == 0) ||
2498 		    (strcmp(sgp1->sg_name, MSG_ORIG(MSG_STR_LD_DYNAMIC)) ==
2499 		    0)) {
2500 			eprintf(ofl->ofl_lml, ERR_FATAL,
2501 			    MSG_INTL(MSG_MAP_SEGRESV), mapfile,
2502 			    EC_XWORD(Line_num));
2503 			return (S_ERROR);
2504 		}
2505 
2506 		/*
2507 		 * Now check the second token from the input line.
2508 		 */
2509 		if (tok == TK_EQUAL) {
2510 			if (strcmp(sgp1->sg_name,
2511 			    MSG_ORIG(MSG_STR_HWCAP_1)) == 0) {
2512 				if (map_cap(mapfile, CA_SUNW_HW_1,
2513 				    ofl) == S_ERROR)
2514 					return (S_ERROR);
2515 				DBG_CALL(Dbg_cap_mapfile(ofl->ofl_lml,
2516 				    CA_SUNW_HW_1, ofl->ofl_hwcap_1,
2517 				    ld_targ.t_m.m_mach));
2518 				continue;
2519 
2520 			} else if (strcmp(sgp1->sg_name,
2521 			    MSG_ORIG(MSG_STR_SFCAP_1)) == 0) {
2522 				if (map_cap(mapfile, CA_SUNW_SF_1,
2523 				    ofl) == S_ERROR)
2524 					return (S_ERROR);
2525 				DBG_CALL(Dbg_cap_mapfile(ofl->ofl_lml,
2526 				    CA_SUNW_SF_1, ofl->ofl_sfcap_1,
2527 				    ld_targ.t_m.m_mach));
2528 				continue;
2529 
2530 			} else {
2531 				if (map_equal(mapfile, sgp1, ofl) == S_ERROR)
2532 					return (S_ERROR);
2533 				DBG_CALL(Dbg_map_set_equal(new_segment));
2534 			}
2535 		} else if (tok == TK_COLON) {
2536 			/*
2537 			 * If this is an existing segment reservation, sections
2538 			 * can't be assigned to it.
2539 			 */
2540 			if ((new_segment == FALSE) &&
2541 			    (sgp1->sg_flags & FLG_SG_EMPTY)) {
2542 				eprintf(ofl->ofl_lml, ERR_FATAL,
2543 				    MSG_INTL(MSG_MAP_SEGEMPSEC), mapfile,
2544 				    EC_XWORD(Line_num));
2545 				return (S_ERROR);
2546 			}
2547 
2548 			/*
2549 			 * We are looking at a new entrance criteria line.
2550 			 * Note that entrance criteria are added in the order
2551 			 * they are found in the mapfile, but are placed before
2552 			 * any default criteria.
2553 			 */
2554 			if ((enp = alist_insert(&(ofl->ofl_ents), NULL,
2555 			    sizeof (Ent_desc), AL_CNT_OFL_ENTRANCE,
2556 			    endx)) == NULL)
2557 				return (S_ERROR);
2558 
2559 			enp->ec_segment = sgp1;
2560 			endx++;
2561 
2562 			if (map_colon(ofl, mapfile, enp) == S_ERROR)
2563 				return (S_ERROR);
2564 			DBG_CALL(Dbg_map_ent(ofl->ofl_lml, new_segment,
2565 			    enp, ofl));
2566 		} else if (tok == TK_ATSIGN) {
2567 			if (map_atsign(mapfile, sgp1, ofl) == S_ERROR)
2568 				return (S_ERROR);
2569 			DBG_CALL(Dbg_map_set_atsign(new_segment));
2570 		} else if (tok != TK_ERROR) {
2571 			eprintf(ofl->ofl_lml, ERR_FATAL,
2572 			    MSG_INTL(MSG_MAP_EXPEQU), mapfile,
2573 			    EC_XWORD(Line_num));
2574 			return (S_ERROR);
2575 		}
2576 
2577 		/*
2578 		 * Having completed parsing an entry in the mapfile determine
2579 		 * if the segment to which it applies is new.
2580 		 */
2581 		if (new_segment) {
2582 			/*
2583 			 * If specific fields have not been supplied via
2584 			 * map_equal(), make sure defaults are supplied.
2585 			 */
2586 			if (((sgp1->sg_flags & FLG_SG_TYPE) == 0) &&
2587 			    (sgp1->sg_phdr.p_type == PT_NULL)) {
2588 				/*
2589 				 * Default to a loadable segment.
2590 				 */
2591 				sgp1->sg_phdr.p_type = PT_LOAD;
2592 				sgp1->sg_flags |= FLG_SG_TYPE;
2593 			}
2594 			if (sgp1->sg_phdr.p_type == PT_LOAD) {
2595 				if ((sgp1->sg_flags & FLG_SG_FLAGS) == 0) {
2596 					/*
2597 					 * Default to read/write and execute.
2598 					 */
2599 					sgp1->sg_phdr.p_flags =
2600 					    PF_R + PF_W + PF_X;
2601 					sgp1->sg_flags |= FLG_SG_FLAGS;
2602 				}
2603 				if ((sgp1->sg_flags & FLG_SG_ALIGN) == 0) {
2604 					/*
2605 					 * Default to segment alignment
2606 					 */
2607 					sgp1->sg_phdr.p_align =
2608 					    ld_targ.t_m.m_segm_align;
2609 					sgp1->sg_flags |= FLG_SG_ALIGN;
2610 				}
2611 			}
2612 
2613 			/*
2614 			 * Determine where the new item should be inserted in
2615 			 * the segment descriptor list.  Presently the user can
2616 			 * only add the following:
2617 			 *
2618 			 *  PT_LOAD	added before the text segment.
2619 			 *  PT_NULL/empty PT_LOAD
2620 			 *		added after the data/bss segments, thus
2621 			 *		we add before the dynamic segment.
2622 			 *  PT_SUNWSTACK
2623 			 *		added before the final note segment.
2624 			 *  PT_NOTE	added before the final note segment.
2625 			 *
2626 			 * Note that any new segments must always be added
2627 			 * after any PT_PHDR and PT_INTERP (refer Generic ABI,
2628 			 * Page 5-4).
2629 			 */
2630 			switch (sgp1->sg_phdr.p_type) {
2631 			case PT_LOAD:
2632 			case PT_NULL:
2633 				if (sgp1->sg_flags & FLG_SG_EMPTY)
2634 					sgp1->sg_id = LD_DYN;
2635 				else
2636 					sgp1->sg_id = LD_TEXT;
2637 				break;
2638 			case PT_SUNWSTACK:
2639 				sgp1->sg_id = LD_NOTE;
2640 				if (++num_stack >= 2) {
2641 					/*
2642 					 * Currently the number of sunw_stack
2643 					 * segment is limited to 1.
2644 					 */
2645 					eprintf(ofl->ofl_lml, ERR_WARNING,
2646 					    MSG_INTL(MSG_MAP_NOSTACK2),
2647 					    mapfile, EC_XWORD(Line_num));
2648 					continue;
2649 				}
2650 				break;
2651 			case PT_NOTE:
2652 				sgp1->sg_id = LD_NOTE;
2653 				break;
2654 			default:
2655 				eprintf(ofl->ofl_lml, ERR_FATAL,
2656 				    MSG_INTL(MSG_MAP_UNKSEGTYP), mapfile,
2657 				    EC_XWORD(Line_num),
2658 				    EC_WORD(sgp1->sg_phdr.p_type));
2659 				return (S_ERROR);
2660 			}
2661 
2662 			ndx = 0;
2663 			for (APLIST_TRAVERSE(ofl->ofl_segs, idx, sgp2)) {
2664 				if (sgp1->sg_id > sgp2->sg_id) {
2665 					ndx++;
2666 					continue;
2667 				}
2668 
2669 				if (aplist_insert(&ofl->ofl_segs, sgp1,
2670 				    AL_CNT_SEGMENTS, idx) == NULL)
2671 					return (S_ERROR);
2672 				break;
2673 			}
2674 		}
2675 		DBG_CALL(Dbg_map_seg(ofl, ndx, sgp1));
2676 	}
2677 
2678 	/*
2679 	 * If the output file is a static file without an interpreter, and
2680 	 * if any virtual address is specified, then set the ?N flag for
2681 	 * backward compatibility.
2682 	 */
2683 	if (!(ofl->ofl_flags & FLG_OF_DYNAMIC) &&
2684 	    !(ofl->ofl_flags & FLG_OF_RELOBJ) &&
2685 	    !(ofl->ofl_osinterp) &&
2686 	    (ofl->ofl_flags1 & FLG_OF1_VADDR))
2687 		ofl->ofl_dtflags_1 |= DF_1_NOHDR;
2688 
2689 	/*
2690 	 * If the output file is a relocatable file, then ?N has no effect.
2691 	 * Make sure this flag isn't set.
2692 	 */
2693 	if (ofl->ofl_flags & FLG_OF_RELOBJ)
2694 		ofl->ofl_dtflags_1 &= ~DF_1_NOHDR;
2695 
2696 	return (1);
2697 }
2698