Mercurial > repo
comparison nasmbuild/nasm-2.13rc9/asm/exprlib.c @ 10554:587a0a262d22
<moonythedwarf> ` cd nasmbuild; tar -xf nasm.tar.gz
author | HackBot |
---|---|
date | Thu, 30 Mar 2017 20:58:41 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
10553:93dc2a984de0 | 10554:587a0a262d22 |
---|---|
1 /* ----------------------------------------------------------------------- * | |
2 * | |
3 * Copyright 1996-2017 The NASM Authors - All Rights Reserved | |
4 * See the file AUTHORS included with the NASM distribution for | |
5 * the specific copyright holders. | |
6 * | |
7 * Redistribution and use in source and binary forms, with or without | |
8 * modification, are permitted provided that the following | |
9 * conditions are met: | |
10 * | |
11 * * Redistributions of source code must retain the above copyright | |
12 * notice, this list of conditions and the following disclaimer. | |
13 * * Redistributions in binary form must reproduce the above | |
14 * copyright notice, this list of conditions and the following | |
15 * disclaimer in the documentation and/or other materials provided | |
16 * with the distribution. | |
17 * | |
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND | |
19 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, | |
20 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF | |
21 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |
22 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR | |
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | |
25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | |
26 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN | |
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR | |
29 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, | |
30 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
31 * | |
32 * ----------------------------------------------------------------------- */ | |
33 | |
34 /* | |
35 * exprlib.c | |
36 * | |
37 * Library routines to manipulate expression data types. | |
38 */ | |
39 | |
40 #include "nasm.h" | |
41 | |
42 /* | |
43 * Return true if the argument is a simple scalar. (Or a far- | |
44 * absolute, which counts.) | |
45 */ | |
46 bool is_simple(const expr *vect) | |
47 { | |
48 while (vect->type && !vect->value) | |
49 vect++; | |
50 if (!vect->type) | |
51 return true; | |
52 if (vect->type != EXPR_SIMPLE) | |
53 return false; | |
54 do { | |
55 vect++; | |
56 } while (vect->type && !vect->value); | |
57 if (vect->type && vect->type < EXPR_SEGBASE + SEG_ABS) | |
58 return false; | |
59 return true; | |
60 } | |
61 | |
62 /* | |
63 * Return true if the argument is a simple scalar, _NOT_ a far- | |
64 * absolute. | |
65 */ | |
66 bool is_really_simple(const expr *vect) | |
67 { | |
68 while (vect->type && !vect->value) | |
69 vect++; | |
70 if (!vect->type) | |
71 return true; | |
72 if (vect->type != EXPR_SIMPLE) | |
73 return false; | |
74 do { | |
75 vect++; | |
76 } while (vect->type && !vect->value); | |
77 if (vect->type) | |
78 return false; | |
79 return true; | |
80 } | |
81 | |
82 /* | |
83 * Return true if the argument is relocatable (i.e. a simple | |
84 * scalar, plus at most one segment-base, possibly a subtraction | |
85 * of the current segment base, plus possibly a WRT). | |
86 */ | |
87 bool is_reloc(const expr *vect) | |
88 { | |
89 bool has_rel = false; /* Has a self-segment-subtract */ | |
90 bool has_seg = false; /* Has a segment base */ | |
91 | |
92 for (; vect->type; vect++) { | |
93 if (!vect->value) { | |
94 /* skip value-0 terms */ | |
95 continue; | |
96 } else if (vect->type < EXPR_SIMPLE) { | |
97 /* false if a register is present */ | |
98 return false; | |
99 } else if (vect->type == EXPR_SIMPLE) { | |
100 /* skip over a pure number term... */ | |
101 continue; | |
102 } else if (vect->type == EXPR_WRT) { | |
103 /* skip over a WRT term... */ | |
104 continue; | |
105 } else if (vect->type < EXPR_SEGBASE) { | |
106 /* other special type -> problem */ | |
107 return false; | |
108 } else if (vect->value == 1) { | |
109 if (has_seg) | |
110 return false; /* only one segbase allowed */ | |
111 has_seg = true; | |
112 } else if (vect->value == -1) { | |
113 if (vect->type != location.segment + EXPR_SEGBASE) | |
114 return false; /* can only subtract current segment */ | |
115 if (has_rel) | |
116 return false; /* already is relative */ | |
117 has_rel = true; | |
118 } | |
119 } | |
120 | |
121 return true; | |
122 } | |
123 | |
124 /* | |
125 * Return true if the argument contains an `unknown' part. | |
126 */ | |
127 bool is_unknown(const expr *vect) | |
128 { | |
129 while (vect->type && vect->type < EXPR_UNKNOWN) | |
130 vect++; | |
131 return (vect->type == EXPR_UNKNOWN); | |
132 } | |
133 | |
134 /* | |
135 * Return true if the argument contains nothing but an `unknown' | |
136 * part. | |
137 */ | |
138 bool is_just_unknown(const expr *vect) | |
139 { | |
140 while (vect->type && !vect->value) | |
141 vect++; | |
142 return (vect->type == EXPR_UNKNOWN); | |
143 } | |
144 | |
145 /* | |
146 * Return the scalar part of a relocatable vector. (Including | |
147 * simple scalar vectors - those qualify as relocatable.) | |
148 */ | |
149 int64_t reloc_value(const expr *vect) | |
150 { | |
151 while (vect->type && !vect->value) | |
152 vect++; | |
153 if (!vect->type) | |
154 return 0; | |
155 if (vect->type == EXPR_SIMPLE) | |
156 return vect->value; | |
157 else | |
158 return 0; | |
159 } | |
160 | |
161 /* | |
162 * Return the segment number of a relocatable vector, or NO_SEG for | |
163 * simple scalars. | |
164 */ | |
165 int32_t reloc_seg(const expr *vect) | |
166 { | |
167 for (; vect->type; vect++) { | |
168 if (vect->type >= EXPR_SEGBASE && vect->value == 1) | |
169 return vect->type - EXPR_SEGBASE; | |
170 } | |
171 | |
172 return NO_SEG; | |
173 } | |
174 | |
175 /* | |
176 * Return the WRT segment number of a relocatable vector, or NO_SEG | |
177 * if no WRT part is present. | |
178 */ | |
179 int32_t reloc_wrt(const expr *vect) | |
180 { | |
181 while (vect->type && vect->type < EXPR_WRT) | |
182 vect++; | |
183 if (vect->type == EXPR_WRT) { | |
184 return vect->value; | |
185 } else | |
186 return NO_SEG; | |
187 } | |
188 | |
189 /* | |
190 * Return true if this expression contains a subtraction of the location | |
191 */ | |
192 bool is_self_relative(const expr *vect) | |
193 { | |
194 for (; vect->type; vect++) { | |
195 if (vect->type == location.segment + EXPR_SEGBASE && vect->value == -1) | |
196 return true; | |
197 } | |
198 | |
199 return false; | |
200 } |