|
0
|
1 module dmd.backend.iasm;
|
|
|
2
|
|
|
3 import dmd.Dsymbol;
|
|
|
4 import dmd.LabelDsymbol;
|
|
|
5 import dmd.AsmStatement;
|
|
|
6 import dmd.Type;
|
|
|
7 import dmd.Scope;
|
|
|
8 import dmd.Loc;
|
|
|
9 import dmd.Token;
|
|
|
10 import dmd.TOK;
|
|
|
11 import dmd.Identifier;
|
|
|
12 import dmd.Declaration;
|
|
|
13 import dmd.VarDeclaration;
|
|
|
14 import dmd.EnumMember;
|
|
|
15 import dmd.ExpInitializer;
|
|
|
16 import dmd.Expression;
|
|
|
17 import dmd.IdentifierExp;
|
|
|
18 import dmd.StringExp;
|
|
|
19 import dmd.Global;
|
|
|
20 import dmd.WANT;
|
|
|
21 import dmd.STC;
|
|
|
22 import dmd.TY;
|
|
|
23 import dmd.EnumUtils;
|
|
|
24 import dmd.TupleDeclaration;
|
|
|
25 import dmd.VarExp;
|
|
|
26 import dmd.Id;
|
|
|
27 import dmd.FuncExp;
|
|
|
28 import dmd.DotIdExp;
|
|
|
29
|
|
|
30 import dmd.backend.code;
|
|
|
31 import dmd.backend.Srcpos;
|
|
|
32 import dmd.backend.FL;
|
|
|
33 import dmd.backend.Util;
|
|
|
34 import dmd.backend.regm_t;
|
|
|
35 import dmd.backend.Config;
|
|
|
36 import dmd.backend.targ_types;
|
|
|
37 import dmd.backend.elem;
|
|
|
38 import dmd.Util;
|
|
|
39
|
|
|
40 import std.stdio : writef, writefln;
|
|
|
41 import std.string : toStringz;
|
|
|
42 import std.algorithm : min;
|
|
|
43
|
|
4
|
44 import core.memory;
|
|
|
45
|
|
|
46 import core.stdc.stdio : printf;
|
|
0
|
47 import core.stdc.string : strlen;
|
|
|
48 import core.stdc.limits;
|
|
|
49
|
|
|
50 import std.bitmanip;
|
|
|
51
|
|
|
52 alias int[10] jmp_buf;
|
|
|
53
|
|
|
54 extern (C) extern
|
|
|
55 {
|
|
|
56 int setjmp(jmp_buf env);
|
|
|
57 void longjmp(jmp_buf env, int value);
|
|
|
58
|
|
|
59 void cod3_set386();
|
|
|
60 code* genlinnum(code*, Srcpos);
|
|
|
61 code *code_calloc();
|
|
|
62
|
|
|
63 __gshared int BPRM;
|
|
|
64 }
|
|
|
65
|
|
|
66 const(char)*[ASMTK.ASMTKmax] apszAsmtk = [
|
|
|
67 "__LOCAL_SIZE",
|
|
|
68 "dword".ptr,
|
|
|
69 "even".ptr,
|
|
|
70 "far".ptr,
|
|
|
71 "naked".ptr,
|
|
|
72 "near".ptr,
|
|
|
73 "ptr".ptr,
|
|
|
74 "qword".ptr,
|
|
|
75 "seg".ptr,
|
|
|
76 "word".ptr,
|
|
|
77 ];
|
|
|
78
|
|
|
79 extern (Pascal) extern {
|
|
|
80 code* cat(code* c1 , code* c2 );
|
|
|
81 }
|
|
|
82
|
|
|
83 extern (C++) extern
|
|
|
84 {
|
|
|
85 void init_optab();
|
|
|
86 OP* asm_op_lookup(const(char)* s);
|
|
|
87 const(char)* asm_opstr(OP* pop);
|
|
|
88 int binary(const(char)* p , const(char)** tab, int high);
|
|
|
89 }
|
|
|
90
|
|
|
91 static ubyte asm_TKlbra_seen = false;
|
|
|
92
|
|
|
93 struct REG
|
|
|
94 {
|
|
|
95 char regstr[6];
|
|
|
96 ubyte val;
|
|
|
97 opflag_t ty;
|
|
|
98 }
|
|
|
99
|
|
|
100 OP* asm_op_lookup(string s)
|
|
|
101 {
|
|
|
102 return asm_op_lookup(toStringz(s));
|
|
|
103 }
|
|
|
104
|
|
|
105 // For amod (3 bits)
|
|
|
106 enum ASM_MODIFIERS : ubyte
|
|
|
107 {
|
|
|
108 _normal, // Normal register value
|
|
|
109 _rseg, // Segment registers
|
|
|
110 _rspecial, // Special registers
|
|
|
111 _addr16, // 16 bit address
|
|
|
112 _addr32, // 32 bit address
|
|
|
113 _fn16, // 16 bit function call
|
|
|
114 _fn32, // 32 bit function call
|
|
|
115 _flbl // Label
|
|
|
116 }
|
|
|
117
|
|
|
118 mixin(BringToCurrentScope!(ASM_MODIFIERS));
|
|
|
119
|
|
|
120 // For aopty (3 bits)
|
|
|
121 enum ASM_OPERAND_TYPE : ubyte
|
|
|
122 {
|
|
|
123 _reg, // _r8, _r16, _r32
|
|
|
124 _m, // _m8, _m16, _m32, _m48
|
|
|
125 _imm, // _imm8, _imm16, _imm32
|
|
|
126 _rel, // _rel8, _rel16, _rel32
|
|
|
127 _mnoi, // _m1616, _m1632
|
|
|
128 _p, // _p1616, _p1632
|
|
|
129 _rm, // _rm8, _rm16, _rm32
|
|
|
130 _float // Floating point operand, look at cRegmask for the
|
|
|
131 // actual size
|
|
|
132 }
|
|
|
133
|
|
|
134 mixin(BringToCurrentScope!(ASM_OPERAND_TYPE));
|
|
|
135
|
|
|
136 /* Register definitions */
|
|
|
137
|
|
|
138 enum AX = 0;
|
|
|
139 enum CX = 1;
|
|
|
140 enum DX = 2;
|
|
|
141 enum BX = 3;
|
|
|
142 enum SP = 4;
|
|
|
143 enum BP = 5;
|
|
|
144 enum SI = 6;
|
|
|
145 enum DI = 7;
|
|
|
146
|
|
|
147 enum ES = 9;
|
|
|
148 enum PSW = 10;
|
|
|
149 enum STACK = 11; // top of stack
|
|
|
150 enum MEM = 12; // memory
|
|
|
151 enum OTHER = 13; // other things
|
|
|
152 enum ST0 = 14; // 8087 top of stack register
|
|
|
153 enum ST01 = 15; // top two 8087 registers; for complex types
|
|
|
154
|
|
|
155 enum NOREG = 100; // no register
|
|
|
156
|
|
|
157 enum AL = 0;
|
|
|
158 enum CL = 1;
|
|
|
159 enum DL = 2;
|
|
|
160 enum BL = 3;
|
|
|
161 enum AH = 4;
|
|
|
162 enum CH = 5;
|
|
|
163 enum DH = 6;
|
|
|
164 enum BH = 7;
|
|
|
165
|
|
|
166 enum mAX = 1;
|
|
|
167 enum mCX = 2;
|
|
|
168 enum mDX = 4;
|
|
|
169 enum mBX = 8;
|
|
|
170 enum mSP = 0x10;
|
|
|
171 enum mBP = 0x20;
|
|
|
172 enum mSI = 0x40;
|
|
|
173 enum mDI = 0x80;
|
|
|
174 enum mES = (1 << ES); // 0x200
|
|
|
175 enum mPSW = (1 << PSW); // 0x400
|
|
|
176
|
|
|
177 enum mSTACK = (1 << STACK); // 0x800
|
|
|
178 enum mMEM = (1 << MEM); // 0x1000
|
|
|
179 enum mOTHER = (1 << OTHER); // 0x2000
|
|
|
180
|
|
|
181 enum mST0 = (1 << ST0); // 0x4000
|
|
|
182 enum mST01 = (1 << ST01); // 0x8000
|
|
|
183
|
|
|
184 version (XXX) { ///TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_SOLARIS
|
|
|
185 // To support positional independent code,
|
|
|
186 // must be able to remove BX from available registers
|
|
|
187 ///extern regm_t ALLREGS;
|
|
|
188 ///#define ALLREGS_INIT (mAX|mBX|mCX|mDX|mSI|mDI)
|
|
|
189 ///#define ALLREGS_INIT_PIC (mAX|mCX|mDX|mSI|mDI)
|
|
|
190 ///extern regm_t BYTEREGS;
|
|
|
191 ///#define BYTEREGS_INIT (mAX|mBX|mCX|mDX)
|
|
|
192 ///#define BYTEREGS_INIT_PIC (mAX|mCX|mDX)
|
|
|
193 } else {
|
|
|
194 enum ALLREGS = (mAX|mBX|mCX|mDX|mSI|mDI);
|
|
|
195 ///#define ALLREGS_INIT ALLREGS
|
|
|
196 ///#undef BYTEREGS
|
|
|
197 ///#define BYTEREGS (mAX|mBX|mCX|mDX)
|
|
|
198 }
|
|
|
199
|
|
|
200 //#define NPTRSIZE tysize[TYnptr]
|
|
|
201 enum NPTRSIZE = 4;
|
|
|
202
|
|
|
203 uint ADDFWAIT() { return 0; }
|
|
|
204
|
|
|
205 enum I16 = 0; // no 16 bit code for D
|
|
|
206 enum I32 = (NPTRSIZE == 4);
|
|
|
207 enum I64 = (NPTRSIZE == 8); // true if generating 64 bit code
|
|
|
208
|
|
|
209 // For uRegmask (6 bits)
|
|
|
210
|
|
|
211 // uRegmask flags when aopty == _float
|
|
|
212 enum _rst = 0x1;
|
|
|
213 enum _rsti = 0x2;
|
|
|
214 enum _64 = 0x4;
|
|
|
215 enum _80 = 0x8;
|
|
|
216 enum _128 = 0x40;
|
|
|
217 enum _112 = 0x10;
|
|
|
218 enum _224 = 0x20;
|
|
|
219
|
|
|
220 ushort CONSTRUCT_FLAGS(ushort uSizemask, ubyte aopty, ubyte amod, ushort uRegmask ) {
|
|
|
221 return cast(ushort)( (uSizemask) | (aopty) << 4 | (amod) << 7 | (uRegmask) << 10);
|
|
|
222 }
|
|
|
223
|
|
|
224 // _seg register values (amod == _rseg)
|
|
|
225 //
|
|
|
226 enum _ds = CONSTRUCT_FLAGS( 0, 0, _rseg, 0x01 );
|
|
|
227 enum _es = CONSTRUCT_FLAGS( 0, 0, _rseg, 0x02 );
|
|
|
228 enum _ss = CONSTRUCT_FLAGS( 0, 0, _rseg, 0x04 );
|
|
|
229 enum _fs = CONSTRUCT_FLAGS( 0, 0, _rseg, 0x08 );
|
|
|
230 enum _gs = CONSTRUCT_FLAGS( 0, 0, _rseg, 0x10 );
|
|
|
231 enum _cs = CONSTRUCT_FLAGS( 0, 0, _rseg, 0x20 );
|
|
|
232
|
|
|
233 //
|
|
|
234 // _special register values
|
|
|
235 //
|
|
|
236 enum _crn = CONSTRUCT_FLAGS( 0, 0, ASM_MODIFIERS._rspecial, 0x01 ); // CRn register (0,2,3)
|
|
|
237 enum _drn = CONSTRUCT_FLAGS( 0, 0, ASM_MODIFIERS._rspecial, 0x02 ); // DRn register (0-3,6-7)
|
|
|
238 enum _trn = CONSTRUCT_FLAGS( 0, 0, ASM_MODIFIERS._rspecial, 0x04 ); // TRn register (3-7)
|
|
|
239 enum _mm = CONSTRUCT_FLAGS( 0, 0, ASM_MODIFIERS._rspecial, 0x08 ); // MMn register (0-7)
|
|
|
240 enum _xmm = CONSTRUCT_FLAGS( 0, 0, ASM_MODIFIERS._rspecial, 0x10 ); // XMMn register (0-7)
|
|
|
241
|
|
|
242 //
|
|
|
243 // Default register values
|
|
|
244 //
|
|
|
245 enum _al = CONSTRUCT_FLAGS( 0, 0, ASM_MODIFIERS._normal, 0x01 ); // AL register
|
|
|
246 enum _ax = CONSTRUCT_FLAGS( 0, 0, ASM_MODIFIERS._normal, 0x02 ); // AX register
|
|
|
247 enum _eax = CONSTRUCT_FLAGS( 0, 0, ASM_MODIFIERS._normal, 0x04 ); // EAX register
|
|
|
248 enum _dx = CONSTRUCT_FLAGS( 0, 0, ASM_MODIFIERS._normal, 0x08 ); // DX register
|
|
|
249 enum _cl = CONSTRUCT_FLAGS( 0, 0, ASM_MODIFIERS._normal, 0x10 ); // CL register
|
|
|
250
|
|
|
251 enum _rplus_r = 0x20;
|
|
|
252 //#define _plus_r CONSTRUCT_FLAGS( 0, 0, 0, _rplus_r )
|
|
|
253 // Add the register to the opcode (no mod r/m)
|
|
|
254
|
|
|
255 ubyte ASM_GET_uSizemask(uint us) {
|
|
|
256 return ((us) & 0x0F);
|
|
|
257 }
|
|
|
258
|
|
|
259 ASM_OPERAND_TYPE ASM_GET_aopty(uint us) {
|
|
|
260 return cast(ASM_OPERAND_TYPE)(((us) & 0x70) >> 4);
|
|
|
261 }
|
|
|
262
|
|
|
263 ASM_MODIFIERS ASM_GET_amod(uint us) {
|
|
|
264 return (cast(ASM_MODIFIERS)(((us) & 0x380) >> 7));
|
|
|
265 }
|
|
|
266
|
|
|
267 ubyte ASM_GET_uRegmask(uint us) {
|
|
|
268 return (((us) & 0xFC00) >> 10);
|
|
|
269 }
|
|
|
270
|
|
|
271 enum _st = CONSTRUCT_FLAGS( 0, _float, 0, _rst ); // stack register 0
|
|
|
272 enum _m112 = CONSTRUCT_FLAGS( 0, _m, 0, _112 );
|
|
|
273 enum _m224 = CONSTRUCT_FLAGS( 0, _m, 0, _224 );
|
|
|
274 enum _m512 = _m224;
|
|
|
275 enum _sti = CONSTRUCT_FLAGS( 0, _float, 0, _rsti );
|
|
|
276
|
|
|
277 REG regFp = { "ST", 0, _st };
|
|
|
278
|
|
|
279 REG[8] aregFp = [
|
|
|
280 { "ST(0)", 0, _sti },
|
|
|
281 { "ST(1)", 1, _sti },
|
|
|
282 { "ST(2)", 2, _sti },
|
|
|
283 { "ST(3)", 3, _sti },
|
|
|
284 { "ST(4)", 4, _sti },
|
|
|
285 { "ST(5)", 5, _sti },
|
|
|
286 { "ST(6)", 6, _sti },
|
|
|
287 { "ST(7)", 7, _sti }
|
|
|
288 ];
|
|
|
289
|
|
|
290 // For uSizemask (4 bits)
|
|
|
291 enum _8 = 0x1;
|
|
|
292 enum _16 = 0x2;
|
|
|
293 enum _32 = 0x4;
|
|
|
294 enum _48 = 0x8;
|
|
|
295 enum _anysize = (_8 | _16 | _32 | _48 );
|
|
|
296
|
|
|
297 enum _modrm = 0x10;
|
|
|
298
|
|
|
299 //// This is for when the reg field of modregrm specifies which instruction it is
|
|
|
300 enum NUM_MASK = 0x7;
|
|
|
301 //#define _0 (0x0 | _modrm) // insure that some _modrm bit is set
|
|
|
302 //#define _1 0x1 // with _0
|
|
|
303 //#define _2 0x2
|
|
|
304 //#define _3 0x3
|
|
|
305 //#define _4 0x4
|
|
|
306 //#define _5 0x5
|
|
|
307 //#define _6 0x6
|
|
|
308 //#define _7 0x7
|
|
|
309 //
|
|
|
310 //#define _modrm 0x10
|
|
|
311 //
|
|
|
312 //#define _r _modrm
|
|
|
313 //#define _cb _modrm
|
|
|
314 //#define _cw _modrm
|
|
|
315 //#define _cd _modrm
|
|
|
316 //#define _cp _modrm
|
|
|
317 //#define _ib 0
|
|
|
318 //#define _iw 0
|
|
|
319 //#define _id 0
|
|
|
320 //#define _rb 0
|
|
|
321 //#define _rw 0
|
|
|
322 //#define _rd 0
|
|
|
323 enum _16_bit = 0x20;
|
|
|
324 enum _32_bit = 0x40;
|
|
|
325 enum _I386 = 0x80; // opcode is only for 386 and later
|
|
|
326 enum _16_bit_addr = 0x100;
|
|
|
327 enum _32_bit_addr = 0x200;
|
|
|
328 enum _fwait = 0x400; // Add an FWAIT prior to the instruction opcode
|
|
|
329 enum _nfwait = 0x800; // Do not add an FWAIT prior to the instruction
|
|
|
330
|
|
|
331 enum MOD_MASK = 0xF000; // Mod mask
|
|
|
332 enum _modsi = 0x1000; // Instruction modifies SI
|
|
|
333 enum _moddx = 0x2000; // Instruction modifies DX
|
|
|
334 enum _mod2 = 0x3000; // Instruction modifies second operand
|
|
|
335 enum _modax = 0x4000; // Instruction modifies AX
|
|
|
336 enum _modnot1 = 0x5000; // Instruction does not modify first operand
|
|
|
337 enum _modaxdx = 0x6000; // instruction modifies AX and DX
|
|
|
338 enum _moddi = 0x7000; // Instruction modifies DI
|
|
|
339 enum _modsidi = 0x8000; // Instruction modifies SI and DI
|
|
|
340 enum _modcx = 0x9000; // Instruction modifies CX
|
|
|
341 enum _modes = 0xa000; // Instruction modifies ES
|
|
|
342 enum _modall = 0xb000; // Instruction modifies all register values
|
|
|
343 enum _modsiax = 0xc000; // Instruction modifies AX and SI
|
|
|
344 enum _modsinot1 = 0xd000; // Instruction modifies SI and not first param
|
|
|
345
|
|
|
346 /////////////////////////////////////////////////
|
|
|
347 // Operand flags - usOp1, usOp2, usOp3
|
|
|
348 //
|
|
|
349
|
|
|
350 alias ushort opflag_t;
|
|
|
351
|
|
|
352 // Operand flags for normal opcodes
|
|
|
353
|
|
|
354 enum _r8 = CONSTRUCT_FLAGS( _8, ASM_OPERAND_TYPE._reg, ASM_MODIFIERS._normal, 0 );
|
|
|
355 enum _r16 = CONSTRUCT_FLAGS(_16, ASM_OPERAND_TYPE._reg, ASM_MODIFIERS._normal, 0 );
|
|
|
356 enum _r32 = CONSTRUCT_FLAGS(_32, ASM_OPERAND_TYPE._reg, ASM_MODIFIERS._normal, 0 );
|
|
|
357 enum _m8 = CONSTRUCT_FLAGS(_8, ASM_OPERAND_TYPE._m, ASM_MODIFIERS._normal, 0 );
|
|
|
358 enum _m16 = CONSTRUCT_FLAGS(_16, ASM_OPERAND_TYPE._m, ASM_MODIFIERS._normal, 0 );
|
|
|
359 enum _m32 = CONSTRUCT_FLAGS(_32, ASM_OPERAND_TYPE._m, ASM_MODIFIERS._normal, 0 );
|
|
|
360 enum _m48 = CONSTRUCT_FLAGS( _48, ASM_OPERAND_TYPE._m, ASM_MODIFIERS._normal, 0 );
|
|
|
361 enum _m64 = CONSTRUCT_FLAGS( _anysize, ASM_OPERAND_TYPE._m, ASM_MODIFIERS._normal, 0 );
|
|
|
362 enum _m128 = CONSTRUCT_FLAGS( _anysize, ASM_OPERAND_TYPE._m, ASM_MODIFIERS._normal, 0 );
|
|
|
363 enum _rm8 = CONSTRUCT_FLAGS(_8, ASM_OPERAND_TYPE._rm, ASM_MODIFIERS._normal, 0 );
|
|
|
364 enum _rm16 = CONSTRUCT_FLAGS(_16, ASM_OPERAND_TYPE._rm, ASM_MODIFIERS._normal, 0 );
|
|
|
365 enum _rm32 = CONSTRUCT_FLAGS(_32, ASM_OPERAND_TYPE._rm, ASM_MODIFIERS._normal, 0);
|
|
|
366 enum _r32m16 = CONSTRUCT_FLAGS(_32|_16, ASM_OPERAND_TYPE._rm, ASM_MODIFIERS._normal, 0);
|
|
|
367 enum _imm8 = CONSTRUCT_FLAGS(_8, ASM_OPERAND_TYPE._imm, ASM_MODIFIERS._normal, 0 );
|
|
|
368 enum _imm16 = CONSTRUCT_FLAGS(_16, ASM_OPERAND_TYPE._imm, ASM_MODIFIERS._normal, 0);
|
|
|
369 enum _imm32 = CONSTRUCT_FLAGS(_32, ASM_OPERAND_TYPE._imm, ASM_MODIFIERS._normal, 0);
|
|
|
370 enum _rel8 = CONSTRUCT_FLAGS(_8, ASM_OPERAND_TYPE._rel, ASM_MODIFIERS._normal, 0);
|
|
|
371 enum _rel16 = CONSTRUCT_FLAGS(_16, ASM_OPERAND_TYPE._rel, ASM_MODIFIERS._normal, 0);
|
|
|
372 enum _rel32 = CONSTRUCT_FLAGS(_32, ASM_OPERAND_TYPE._rel, ASM_MODIFIERS._normal, 0);
|
|
|
373 enum _p1616 = CONSTRUCT_FLAGS(_32, ASM_OPERAND_TYPE._p, ASM_MODIFIERS._normal, 0);
|
|
|
374 enum _m1616 = CONSTRUCT_FLAGS(_32, ASM_OPERAND_TYPE._mnoi, ASM_MODIFIERS._normal, 0);
|
|
|
375 enum _p1632 = CONSTRUCT_FLAGS(_48, ASM_OPERAND_TYPE._p, ASM_MODIFIERS._normal, 0 );
|
|
|
376 enum _m1632 = CONSTRUCT_FLAGS(_48, ASM_OPERAND_TYPE._mnoi, ASM_MODIFIERS._normal, 0);
|
|
|
377 enum _special = CONSTRUCT_FLAGS( 0, 0, ASM_MODIFIERS._rspecial, 0 );
|
|
|
378 enum _seg = CONSTRUCT_FLAGS( 0, 0, ASM_MODIFIERS._rseg, 0 );
|
|
|
379 enum _a16 = CONSTRUCT_FLAGS( 0, 0, ASM_MODIFIERS._addr16, 0 );
|
|
|
380 enum _a32 = CONSTRUCT_FLAGS( 0, 0, ASM_MODIFIERS._addr32, 0 );
|
|
|
381 enum _f16 = CONSTRUCT_FLAGS( 0, 0, ASM_MODIFIERS._fn16, 0);
|
|
|
382 // Near function pointer
|
|
|
383 enum _f32 = CONSTRUCT_FLAGS( 0, 0, ASM_MODIFIERS._fn32, 0);
|
|
|
384 // Far function pointer
|
|
|
385 enum _lbl = CONSTRUCT_FLAGS( 0, 0, ASM_MODIFIERS._flbl, 0 );
|
|
|
386 // Label (in current function)
|
|
|
387
|
|
|
388 enum _mmm32 = CONSTRUCT_FLAGS( 0, ASM_OPERAND_TYPE._m, 0, _32);
|
|
|
389 enum _mmm64 = CONSTRUCT_FLAGS( 0, ASM_OPERAND_TYPE._m, 0, _64);
|
|
|
390 enum _mmm128 = CONSTRUCT_FLAGS( 0, ASM_OPERAND_TYPE._m, 0, _128);
|
|
|
391
|
|
|
392 enum _xmm_m32 = CONSTRUCT_FLAGS( _32, ASM_OPERAND_TYPE._m, ASM_MODIFIERS._rspecial, 0);
|
|
|
393 enum _xmm_m64 =CONSTRUCT_FLAGS( _anysize, ASM_OPERAND_TYPE._m, ASM_MODIFIERS._rspecial, 0);
|
|
|
394 enum _xmm_m128 =CONSTRUCT_FLAGS( _anysize, ASM_OPERAND_TYPE._m, ASM_MODIFIERS._rspecial, 0);
|
|
|
395
|
|
|
396 enum _moffs8 = (_rel8);
|
|
|
397 enum _moffs16 = (_rel16 );
|
|
|
398 enum _moffs32 = (_rel32 );
|
|
|
399
|
|
|
400 ////////////////////////////////////////////////////////////////////
|
|
|
401 // Operand flags for floating point opcodes are all just aliases for
|
|
|
402 // normal opcode variants and only asm_determine_operator_flags should
|
|
|
403 // need to care.
|
|
|
404 //
|
|
|
405 enum _fm80 = CONSTRUCT_FLAGS( 0, ASM_OPERAND_TYPE._m, 0, _80 );
|
|
|
406 enum _fm64 = CONSTRUCT_FLAGS( 0, ASM_OPERAND_TYPE._m, 0, _64 );
|
|
|
407 enum _fm128 = CONSTRUCT_FLAGS( 0, ASM_OPERAND_TYPE._m, 0, _128 );
|
|
|
408 enum _fanysize = (_64 | _80 | _112 | _224);
|
|
|
409
|
|
|
410 enum _AL =0;
|
|
|
411 enum _AH =4;
|
|
|
412 enum _AX =0;
|
|
|
413 enum _EAX =0;
|
|
|
414 enum _BL =3;
|
|
|
415 enum _BH =7;
|
|
|
416 enum _BX =3;
|
|
|
417 enum _EBX =3;
|
|
|
418 enum _CL =1;
|
|
|
419 enum _CH =5;
|
|
|
420 enum _CX =1;
|
|
|
421 enum _ECX =1;
|
|
|
422 enum _DL =2;
|
|
|
423 enum _DH =6;
|
|
|
424 enum _DX =2;
|
|
|
425 enum _EDX =2;
|
|
|
426 enum _BP =5;
|
|
|
427 enum _EBP =5;
|
|
|
428 enum _SP =4;
|
|
|
429 enum _ESP =4;
|
|
|
430 enum _DI =7;
|
|
|
431 enum _EDI =7;
|
|
|
432 enum _SI =6;
|
|
|
433 enum _ESI =6;
|
|
|
434 enum _ES =0;
|
|
|
435 enum _CS =1;
|
|
|
436 enum _SS =2;
|
|
|
437 enum _DS =3;
|
|
|
438 enum _GS =5;
|
|
|
439 enum _FS =4;
|
|
|
440
|
|
|
441 enum ASM = 0x36; // string of asm bytes, actually an SS: opcode
|
|
|
442 enum ASM_END = 0xffff; // special opcode meaning end of table
|
|
|
443
|
|
|
444 struct PTRNTAB0
|
|
|
445 {
|
|
|
446 uint usOpcode;
|
|
|
447 // #define ASM_END 0xffff // special opcode meaning end of table
|
|
|
448 ushort usFlags;
|
|
|
449 }
|
|
|
450
|
|
|
451 struct PTRNTAB1
|
|
|
452 {
|
|
|
453 uint usOpcode;
|
|
|
454 ushort usFlags;
|
|
|
455 opflag_t usOp1;
|
|
|
456 }
|
|
|
457
|
|
|
458 struct PTRNTAB2
|
|
|
459 {
|
|
|
460 uint usOpcode;
|
|
|
461 ushort usFlags;
|
|
|
462 opflag_t usOp1;
|
|
|
463 opflag_t usOp2;
|
|
|
464 }
|
|
|
465
|
|
|
466 struct PTRNTAB3
|
|
|
467 {
|
|
|
468 uint usOpcode;
|
|
|
469 ushort usFlags;
|
|
|
470 opflag_t usOp1;
|
|
|
471 opflag_t usOp2;
|
|
|
472 opflag_t usOp3;
|
|
|
473 }
|
|
|
474
|
|
|
475 union PTRNTAB
|
|
|
476 {
|
|
|
477 PTRNTAB0 *pptb0;
|
|
|
478 PTRNTAB1 *pptb1;
|
|
|
479 PTRNTAB2 *pptb2;
|
|
|
480 PTRNTAB3 *pptb3;
|
|
|
481 }
|
|
|
482
|
|
|
483 struct OP
|
|
|
484 {
|
|
|
485 ubyte usNumops;
|
|
|
486 PTRNTAB ptb;
|
|
|
487 }
|
|
|
488
|
|
|
489 enum ASM_JUMPTYPE
|
|
|
490 {
|
|
|
491 ASM_JUMPTYPE_UNSPECIFIED,
|
|
|
492 ASM_JUMPTYPE_SHORT,
|
|
|
493 ASM_JUMPTYPE_NEAR,
|
|
|
494 ASM_JUMPTYPE_FAR
|
|
|
495 } // ajt
|
|
|
496
|
|
|
497 mixin(BringToCurrentScope!(ASM_JUMPTYPE));
|
|
|
498
|
|
|
499 struct OPND
|
|
|
500 {
|
|
|
501 REG* base; // if plain register
|
|
|
502 REG* pregDisp1; // if [register1]
|
|
|
503 REG* pregDisp2;
|
|
|
504 REG* segreg; // if segment override
|
|
|
505 char indirect = 0; // if had a '*' or '.'
|
|
|
506 char bOffset = 0; // if 'offset' keyword
|
|
|
507 char bSeg = 0; // if 'segment' keyword
|
|
|
508 char bPtr = 0; // if 'ptr' keyword
|
|
|
509 uint uchMultiplier; // register multiplier; valid values are 0,1,2,4,8
|
|
|
510 opflag_t usFlags;
|
|
|
511 Dsymbol s;
|
|
|
512 int disp;
|
|
|
513 real real_ = 0;
|
|
|
514 Type ptype;
|
|
|
515 ASM_JUMPTYPE ajt;
|
|
|
516 }
|
|
|
517
|
|
|
518 struct ASM_STATE
|
|
|
519 {
|
|
|
520 ubyte ucItype; // Instruction type
|
|
|
521 Loc loc;
|
|
|
522 ubyte bInit;
|
|
|
523 LabelDsymbol psDollar;
|
|
|
524 Dsymbol psLocalsize;
|
|
|
525 jmp_buf env;
|
|
|
526 ubyte bReturnax;
|
|
|
527 AsmStatement statement;
|
|
|
528 Scope sc;
|
|
|
529 }
|
|
|
530
|
|
|
531 enum IT
|
|
|
532 {
|
|
|
533 ITprefix = 0x10, // special prefix
|
|
|
534 ITjump = 0x20, // jump instructions CALL, Jxx and LOOPxx
|
|
|
535 ITimmed = 0x30, // value of an immediate operand controls
|
|
|
536 // code generation
|
|
|
537 ITopt = 0x40, // not all operands are required
|
|
|
538 ITshift = 0x50, // rotate and shift instructions
|
|
|
539 ITfloat = 0x60, // floating point coprocessor instructions
|
|
|
540 ITdata = 0x70, // DB, DW, DD, DQ, DT pseudo-ops
|
|
|
541 ITaddr = 0x80, // DA (define addresss) pseudo-op
|
|
|
542 ITMASK = 0xF0,
|
|
|
543 ITSIZE = 0x0F, // mask for size
|
|
|
544 }
|
|
|
545
|
|
|
546 alias IT.ITprefix ITprefix;
|
|
|
547 alias IT.ITjump ITjump;
|
|
|
548 alias IT.ITimmed ITimmed;
|
|
|
549 alias IT.ITopt ITopt;
|
|
|
550 alias IT.ITshift ITshift;
|
|
|
551 alias IT.ITfloat ITfloat;
|
|
|
552 alias IT.ITdata ITdata;
|
|
|
553 alias IT.ITaddr ITaddr;
|
|
|
554 alias IT.ITMASK ITMASK;
|
|
|
555 alias IT.ITSIZE ITSIZE;
|
|
|
556
|
|
|
557 __gshared ASM_STATE asmstate;
|
|
|
558 __gshared Token* asmtok;
|
|
|
559 __gshared TOK tok_value;
|
|
|
560
|
|
|
561 // Additional tokens for the inline assembler
|
|
|
562 enum ASMTK
|
|
|
563 {
|
|
|
564 ASMTKlocalsize = TOKMAX + 1,
|
|
|
565 ASMTKdword,
|
|
|
566 ASMTKeven,
|
|
|
567 ASMTKfar,
|
|
|
568 ASMTKnaked,
|
|
|
569 ASMTKnear,
|
|
|
570 ASMTKptr,
|
|
|
571 ASMTKqword,
|
|
|
572 ASMTKseg,
|
|
|
573 ASMTKword,
|
|
|
574 ASMTKmax = ASMTKword - (TOK.TOKMAX + 1) + 1
|
|
|
575 }
|
|
|
576
|
|
|
577 mixin(BringToCurrentScope!(ASMTK));
|
|
|
578
|
|
|
579 enum OP_DB
|
|
|
580 {
|
|
|
581 ///version (SCPP) {
|
|
|
582 /// // These are the number of bytes
|
|
|
583 /// OPdb = 1,
|
|
|
584 /// OPdw = 2,
|
|
|
585 /// OPdd = 4,
|
|
|
586 /// OPdq = 8,
|
|
|
587 /// OPdt = 10,
|
|
|
588 /// OPdf = 4,
|
|
|
589 /// OPde = 10,
|
|
|
590 /// OPds = 2,
|
|
|
591 /// OPdi = 4,
|
|
|
592 /// OPdl = 8,
|
|
|
593 ///}
|
|
|
594 ///version (MARS) {
|
|
|
595 // Integral types
|
|
|
596 OPdb,
|
|
|
597 OPds,
|
|
|
598 OPdi,
|
|
|
599 OPdl,
|
|
|
600
|
|
|
601 // Float types
|
|
|
602 OPdf,
|
|
|
603 OPdd,
|
|
|
604 OPde,
|
|
|
605
|
|
|
606 // Deprecated
|
|
|
607 OPdw = OPds,
|
|
|
608 OPdq = OPdl,
|
|
|
609 OPdt = OPde,
|
|
|
610 ///}
|
|
|
611 }
|
|
|
612
|
|
|
613 OPND* opnd_calloc()
|
|
|
614 {
|
|
|
615 return new OPND();
|
|
|
616 }
|
|
|
617
|
|
|
618 void opnd_free(OPND* o)
|
|
|
619 {
|
|
|
620 delete o;
|
|
|
621 }
|
|
|
622
|
|
|
623 /******************************
|
|
|
624 * Convert assembly instruction into a code, and append
|
|
|
625 * it to the code generated for this block.
|
|
|
626 */
|
|
|
627
|
|
|
628 code* asm_emit(Loc loc, uint usNumops, PTRNTAB ptb, OP* pop, OPND* popnd1, OPND* popnd2, OPND* popnd3)
|
|
|
629 {
|
|
|
630 debug {
|
|
|
631 ubyte auchOpcode[16];
|
|
|
632 uint usIdx = 0;
|
|
|
633 void emit(ubyte op) {
|
|
|
634 auchOpcode[usIdx++] = op;
|
|
|
635 }
|
|
|
636 } else {
|
|
|
637 void emit(ubyte op) {}
|
|
|
638 }
|
|
|
639 Identifier id;
|
|
|
640 // ushort us;
|
|
|
641 ubyte* puc;
|
|
|
642 uint usDefaultseg;
|
|
|
643 code* pc = null;
|
|
|
644 OPND* popndTmp;
|
|
|
645 ASM_OPERAND_TYPE aoptyTmp;
|
|
|
646 ushort uSizemaskTmp;
|
|
|
647 REG* pregSegment;
|
|
|
648 code* pcPrefix = null;
|
|
|
649
|
|
|
650 uint uSizemask1 = 0;
|
|
|
651 uint uSizemask2 = 0;
|
|
|
652 uint uSizemask3 = 0;
|
|
|
653
|
|
|
654 //ASM_OPERAND_TYPE aopty1 = ASM_OPERAND_TYPE._reg , aopty2 = 0, aopty3 = 0;
|
|
|
655 ASM_MODIFIERS amod1 = ASM_MODIFIERS._normal;
|
|
|
656 ASM_MODIFIERS amod2 = ASM_MODIFIERS._normal;
|
|
|
657 ASM_MODIFIERS amod3 = ASM_MODIFIERS._normal;
|
|
|
658
|
|
|
659 uint uRegmask1 = 0;
|
|
|
660 uint uRegmask2 = 0;
|
|
|
661 uint uRegmask3 = 0;
|
|
|
662
|
|
|
663 uint uSizemaskTable1 = 0;
|
|
|
664 uint uSizemaskTable2 = 0;
|
|
|
665 uint uSizemaskTable3 = 0;
|
|
|
666
|
|
|
667 ASM_OPERAND_TYPE aoptyTable1 = ASM_OPERAND_TYPE._reg;
|
|
|
668 ASM_OPERAND_TYPE aoptyTable2 = ASM_OPERAND_TYPE._reg;
|
|
|
669 ASM_OPERAND_TYPE aoptyTable3 = ASM_OPERAND_TYPE._reg;
|
|
|
670
|
|
|
671 ASM_MODIFIERS amodTable1 = ASM_MODIFIERS._normal;
|
|
|
672 ASM_MODIFIERS amodTable2 = ASM_MODIFIERS._normal;
|
|
|
673 ASM_MODIFIERS amodTable3 = ASM_MODIFIERS._normal;
|
|
|
674
|
|
|
675 uint uRegmaskTable1 = 0;
|
|
|
676 uint uRegmaskTable2 = 0;
|
|
|
677 uint uRegmaskTable3 = 0;
|
|
|
678
|
|
|
679 pc = code_calloc();
|
|
|
680 pc.Iflags |= CF.CFpsw; // assume we want to keep the flags
|
|
|
681
|
|
|
682 if (popnd1)
|
|
|
683 {
|
|
|
684 uSizemask1 = ASM_GET_uSizemask(popnd1.usFlags);
|
|
|
685 //aopty1 = ASM_GET_aopty(popnd1.usFlags);
|
|
|
686 amod1 = ASM_GET_amod(popnd1.usFlags);
|
|
|
687 uRegmask1 = ASM_GET_uRegmask(popnd1.usFlags);
|
|
|
688
|
|
|
689 uSizemaskTable1 = ASM_GET_uSizemask(ptb.pptb1.usOp1);
|
|
|
690 aoptyTable1 = ASM_GET_aopty(ptb.pptb1.usOp1);
|
|
|
691 amodTable1 = ASM_GET_amod(ptb.pptb1.usOp1);
|
|
|
692 uRegmaskTable1 = ASM_GET_uRegmask(ptb.pptb1.usOp1);
|
|
|
693
|
|
|
694 }
|
|
|
695
|
|
|
696 if (popnd2)
|
|
|
697 {
|
|
|
698 static if (false) {
|
|
|
699 printf("\nasm_emit:\nop: ");
|
|
|
700 asm_output_flags(popnd2.usFlags);
|
|
|
701 printf("\ntb: ");
|
|
|
702 asm_output_flags(ptb.pptb2.usOp2);
|
|
|
703 printf("\n");
|
|
|
704 }
|
|
|
705 uSizemask2 = ASM_GET_uSizemask(popnd2.usFlags);
|
|
|
706 //aopty2 = ASM_GET_aopty(popnd2.usFlags);
|
|
|
707 amod2 = ASM_GET_amod(popnd2.usFlags);
|
|
|
708 uRegmask2 = ASM_GET_uRegmask(popnd2.usFlags);
|
|
|
709
|
|
|
710 uSizemaskTable2 = ASM_GET_uSizemask(ptb.pptb2.usOp2);
|
|
|
711 aoptyTable2 = ASM_GET_aopty(ptb.pptb2.usOp2);
|
|
|
712 amodTable2 = ASM_GET_amod(ptb.pptb2.usOp2);
|
|
|
713 uRegmaskTable2 = ASM_GET_uRegmask(ptb.pptb2.usOp2);
|
|
|
714 }
|
|
|
715 if (popnd3)
|
|
|
716 {
|
|
|
717 uSizemask3 = ASM_GET_uSizemask(popnd3.usFlags);
|
|
|
718 //aopty3 = ASM_GET_aopty(popnd3.usFlags);
|
|
|
719 amod3 = ASM_GET_amod(popnd3.usFlags);
|
|
|
720 uRegmask3 = ASM_GET_uRegmask(popnd3.usFlags);
|
|
|
721
|
|
|
722 uSizemaskTable3 = ASM_GET_uSizemask(ptb.pptb3.usOp3);
|
|
|
723 aoptyTable3 = ASM_GET_aopty(ptb.pptb3.usOp3);
|
|
|
724 amodTable3 = ASM_GET_amod(ptb.pptb3.usOp3);
|
|
|
725 uRegmaskTable3 = ASM_GET_uRegmask(ptb.pptb3.usOp3);
|
|
|
726 }
|
|
|
727
|
|
|
728 asmstate.statement.regs |= asm_modify_regs(ptb, popnd1, popnd2);
|
|
|
729
|
|
|
730 if (!I32 && ptb.pptb0.usFlags & _I386)
|
|
|
731 {
|
|
|
732 switch (usNumops)
|
|
|
733 {
|
|
|
734 case 0:
|
|
|
735 break;
|
|
|
736
|
|
|
737 case 1:
|
|
|
738 if (popnd1 && popnd1.s)
|
|
|
739 {
|
|
|
740 L386_WARNING:
|
|
|
741 id = popnd1.s.ident;
|
|
|
742 L386_WARNING2:
|
|
|
743 if (config.target_cpu < TARGET.TARGET_80386)
|
|
|
744 {
|
|
|
745 // Reference to %s caused a 386 instruction to be generated
|
|
|
746 //warerr(WM_386_op, id.toChars());
|
|
|
747 }
|
|
|
748 }
|
|
|
749 break;
|
|
|
750
|
|
|
751 case 2:
|
|
|
752 case 3: // The third operand is always an ASM_OPERAND_TYPE._imm
|
|
|
753 if (popnd1 && popnd1.s)
|
|
|
754 goto L386_WARNING;
|
|
|
755 if (popnd2 && popnd2.s)
|
|
|
756 {
|
|
|
757 id = popnd2.s.ident;
|
|
|
758 goto L386_WARNING2;
|
|
|
759 }
|
|
|
760 break;
|
|
|
761 }
|
|
|
762 }
|
|
|
763
|
|
|
764 switch (usNumops)
|
|
|
765 {
|
|
|
766 case 0:
|
|
|
767 if ((I32 && (ptb.pptb0.usFlags & _16_bit)) || (!I32 && (ptb.pptb0.usFlags & _32_bit)))
|
|
|
768 {
|
|
|
769 emit(0x66);
|
|
|
770 pc.Iflags |= CF.CFopsize;
|
|
|
771 }
|
|
|
772 break;
|
|
|
773
|
|
|
774 // 3 and 2 are the same because the third operand is always
|
|
|
775 // an immediate and does not affect operation size
|
|
|
776 case 3:
|
|
|
777 case 2:
|
|
|
778 if ((I32 &&
|
|
|
779 (amod2 == ASM_MODIFIERS._addr16 ||
|
|
|
780 (uSizemaskTable2 & _16 && aoptyTable2 == ASM_OPERAND_TYPE._rel) ||
|
|
|
781 (uSizemaskTable2 & _32 && aoptyTable2 == ASM_OPERAND_TYPE._mnoi) ||
|
|
|
782 (ptb.pptb2.usFlags & _16_bit_addr)
|
|
|
783 )
|
|
|
784 ) ||
|
|
|
785 (!I32 &&
|
|
|
786 (amod2 == ASM_MODIFIERS._addr32 ||
|
|
|
787 (uSizemaskTable2 & _32 && aoptyTable2 == ASM_OPERAND_TYPE._rel) ||
|
|
|
788 (uSizemaskTable2 & _48 && aoptyTable2 == ASM_OPERAND_TYPE._mnoi) ||
|
|
|
789 (ptb.pptb2.usFlags & _32_bit_addr)))
|
|
|
790 )
|
|
|
791 {
|
|
|
792 emit(0x67);
|
|
|
793 pc.Iflags |= CF.CFaddrsize;
|
|
|
794
|
|
|
795 if (I32)
|
|
|
796 amod2 = ASM_MODIFIERS._addr16;
|
|
|
797 else
|
|
|
798 amod2 = ASM_MODIFIERS._addr32;
|
|
|
799
|
|
|
800 popnd2.usFlags &= ~CONSTRUCT_FLAGS(0,0,7,0);
|
|
|
801 popnd2.usFlags |= CONSTRUCT_FLAGS(0,0,amod2,0);
|
|
|
802 }
|
|
|
803
|
|
|
804
|
|
|
805 /* Fall through, operand 1 controls the opsize, but the
|
|
|
806 address size can be in either operand 1 or operand 2,
|
|
|
807 hence the extra checking the flags tested for SHOULD
|
|
|
808 be mutex on operand 1 and operand 2 because there is
|
|
|
809 only one MOD R/M byte
|
|
|
810 */
|
|
|
811
|
|
|
812 case 1:
|
|
|
813 if ((I32 &&
|
|
|
814 (amod1 == ASM_MODIFIERS._addr16 ||
|
|
|
815 (uSizemaskTable1 & _16 && aoptyTable1 == ASM_OPERAND_TYPE._rel) ||
|
|
|
816 (uSizemaskTable1 & _32 && aoptyTable1 == ASM_OPERAND_TYPE._mnoi) ||
|
|
|
817 (ptb.pptb1.usFlags & _16_bit_addr))) ||
|
|
|
818 (!I32 &&
|
|
|
819 (amod1 == ASM_MODIFIERS._addr32 ||
|
|
|
820 (uSizemaskTable1 & _32 && aoptyTable1 == ASM_OPERAND_TYPE._rel) ||
|
|
|
821 (uSizemaskTable1 & _48 && aoptyTable1 == ASM_OPERAND_TYPE._mnoi) ||
|
|
|
822 (ptb.pptb1.usFlags & _32_bit_addr))))
|
|
|
823 {
|
|
|
824 emit(0x67); // address size prefix
|
|
|
825 pc.Iflags |= CF.CFaddrsize;
|
|
|
826 if (I32)
|
|
|
827 amod1 = ASM_MODIFIERS._addr16;
|
|
|
828 else
|
|
|
829 amod1 = ASM_MODIFIERS._addr32;
|
|
|
830 popnd1.usFlags &= ~CONSTRUCT_FLAGS(0,0,7,0);
|
|
|
831 popnd1.usFlags |= CONSTRUCT_FLAGS(0,0,amod1,0);
|
|
|
832 }
|
|
|
833
|
|
|
834 // If the size of the operand is unknown, assume that it is
|
|
|
835 // the default size
|
|
|
836 if ((I32 && (ptb.pptb0.usFlags & _16_bit)) ||
|
|
|
837 (!I32 && (ptb.pptb0.usFlags & _32_bit)))
|
|
|
838 {
|
|
|
839 //if (asmstate.ucItype != ITjump)
|
|
|
840 { emit(0x66);
|
|
|
841 pc.Iflags |= CF.CFopsize;
|
|
|
842 }
|
|
|
843 }
|
|
|
844 if (((pregSegment = (popndTmp = popnd1).segreg) != null) ||
|
|
|
845 ((popndTmp = popnd2) != null &&
|
|
|
846 (pregSegment = popndTmp.segreg) != null)
|
|
|
847 )
|
|
|
848 {
|
|
|
849 if ((popndTmp.pregDisp1 &&
|
|
|
850 popndTmp.pregDisp1.val == _BP) ||
|
|
|
851 popndTmp.pregDisp2 &&
|
|
|
852 popndTmp.pregDisp2.val == _BP)
|
|
|
853 usDefaultseg = _SS;
|
|
|
854 else
|
|
|
855 usDefaultseg = _DS;
|
|
|
856 if (pregSegment.val != usDefaultseg)
|
|
|
857 switch (pregSegment.val) {
|
|
|
858 case _CS:
|
|
|
859 emit(0x2e);
|
|
|
860 pc.Iflags |= CF.CFcs;
|
|
|
861 break;
|
|
|
862 case _SS:
|
|
|
863 emit(0x36);
|
|
|
864 pc.Iflags |= CF.CFss;
|
|
|
865 break;
|
|
|
866 case _DS:
|
|
|
867 emit(0x3e);
|
|
|
868 pc.Iflags |= CF.CFds;
|
|
|
869 break;
|
|
|
870 case _ES:
|
|
|
871 emit(0x26);
|
|
|
872 pc.Iflags |= CF.CFes;
|
|
|
873 break;
|
|
|
874 case _FS:
|
|
|
875 emit(0x64);
|
|
|
876 pc.Iflags |= CF.CFfs;
|
|
|
877 break;
|
|
|
878 case _GS:
|
|
|
879 emit(0x65);
|
|
|
880 pc.Iflags |= CF.CFgs;
|
|
|
881 break;
|
|
|
882 default:
|
|
|
883 assert(0);
|
|
|
884 }
|
|
|
885 }
|
|
|
886 break;
|
|
|
887 }
|
|
|
888 uint usOpcode = ptb.pptb0.usOpcode;
|
|
|
889
|
|
|
890 if ((usOpcode & 0xFFFFFF00) == 0x660F3A00 || // SSE4
|
|
|
891 (usOpcode & 0xFFFFFF00) == 0x660F3800) // SSE4
|
|
|
892 {
|
|
|
893 pc.Iflags |= CF.CFopsize;
|
|
|
894 pc.Iop = 0x0F;
|
|
|
895 pc.Iop2 = (usOpcode >> 8) & 0xFF;
|
|
|
896 pc.Iop3 = usOpcode & 0xFF;
|
|
|
897 goto L3;
|
|
|
898 }
|
|
|
899 switch (usOpcode & 0xFF0000)
|
|
|
900 {
|
|
|
901 case 0:
|
|
|
902 break;
|
|
|
903
|
|
|
904 case 0x660000:
|
|
|
905 pc.Iflags |= CF.CFopsize;
|
|
|
906 usOpcode &= 0xFFFF;
|
|
|
907 break;
|
|
|
908
|
|
|
909 case 0xF20000: // REPNE
|
|
|
910 case 0xF30000: // REP/REPE
|
|
|
911 // BUG: What if there's an address size prefix or segment
|
|
|
912 // override prefix? Must the REP be adjacent to the rest
|
|
|
913 // of the opcode?
|
|
|
914 pcPrefix = code_calloc();
|
|
|
915 pcPrefix.Iop = cast(ubyte)(usOpcode >> 16);
|
|
|
916 usOpcode &= 0xFFFF;
|
|
|
917 break;
|
|
|
918
|
|
|
919 case 0x0F0000: // an AMD instruction
|
|
|
920 puc = (cast(ubyte*) &usOpcode);
|
|
|
921 if (puc[1] != 0x0F) // if not AMD instruction 0x0F0F
|
|
|
922 goto L4;
|
|
|
923 emit(puc[2]);
|
|
|
924 emit(puc[1]);
|
|
|
925 emit(puc[0]);
|
|
|
926 pc.Iop = puc[2];
|
|
|
927 pc.Iop2 = puc[1];
|
|
|
928 pc.IEVint2() = puc[0];
|
|
|
929 pc.IFL2 = FL.FLconst;
|
|
|
930 goto L3;
|
|
|
931
|
|
|
932 default:
|
|
|
933 puc = (cast(ubyte*) &usOpcode);
|
|
|
934 L4:
|
|
|
935 emit(puc[2]);
|
|
|
936 emit(puc[1]);
|
|
|
937 emit(puc[0]);
|
|
|
938 pc.Iop = puc[2];
|
|
|
939 pc.Iop2 = puc[1];
|
|
|
940 pc.Irm = puc[0];
|
|
|
941 goto L3;
|
|
|
942 }
|
|
|
943 if (usOpcode & 0xff00)
|
|
|
944 {
|
|
|
945 puc = (cast(ubyte*) &(usOpcode));
|
|
|
946 emit(puc[1]);
|
|
|
947 emit(puc[0]);
|
|
|
948 pc.Iop = puc[1];
|
|
|
949 if (pc.Iop == 0x0f)
|
|
|
950 pc.Iop2 = puc[0];
|
|
|
951 else
|
|
|
952 {
|
|
|
953 if (usOpcode == 0xDFE0) // FSTSW AX
|
|
|
954 { pc.Irm = puc[0];
|
|
|
955 goto L2;
|
|
|
956 }
|
|
|
957 if (asmstate.ucItype == IT.ITfloat)
|
|
|
958 pc.Irm = puc[0];
|
|
|
959 else
|
|
|
960 {
|
|
|
961 pc.IEVint2() = puc[0];
|
|
|
962 pc.IFL2 = FL.FLconst;
|
|
|
963 }
|
|
|
964 }
|
|
|
965 }
|
|
|
966 else
|
|
|
967 {
|
|
|
968 emit(cast(ubyte)usOpcode);
|
|
|
969 pc.Iop = cast(ubyte)usOpcode;
|
|
|
970 }
|
|
|
971 L3: ;
|
|
|
972
|
|
|
973 // If CALL, Jxx or LOOPx to a symbolic location
|
|
|
974 if (/*asmstate.ucItype == ITjump &&*/
|
|
|
975 popnd1 && popnd1.s && popnd1.s.isLabel())
|
|
|
976 {
|
|
|
977 Dsymbol s = popnd1.s;
|
|
|
978 if (s == asmstate.psDollar)
|
|
|
979 {
|
|
|
980 pc.IFL2 = FL.FLconst;
|
|
|
981 if (uSizemaskTable1 & (_8 | _16))
|
|
|
982 pc.IEVint2() = popnd1.disp;
|
|
|
983 else if (uSizemaskTable1 & _32)
|
|
|
984 pc.IEVpointer2() = cast(targ_size_t) popnd1.disp;
|
|
|
985 }
|
|
|
986 else
|
|
|
987 {
|
|
|
988 LabelDsymbol label = s.isLabel();
|
|
|
989 if (label)
|
|
|
990 {
|
|
|
991 if ((pc.Iop & 0xF0) == 0x70)
|
|
|
992 pc.Iflags |= CF.CFjmp16;
|
|
|
993 if (usNumops == 1)
|
|
|
994 {
|
|
|
995 pc.IFL2 = FL.FLblock;
|
|
|
996 pc.IEVlsym2() = label;
|
|
|
997 }
|
|
|
998 else
|
|
|
999 {
|
|
|
1000 pc.IFL1 = FL.FLblock;
|
|
|
1001 pc.IEVlsym1() = label;
|
|
|
1002 }
|
|
|
1003 }
|
|
|
1004 }
|
|
|
1005 }
|
|
|
1006
|
|
|
1007 switch (usNumops)
|
|
|
1008 {
|
|
|
1009 case 0:
|
|
|
1010 break;
|
|
|
1011
|
|
|
1012 case 1:
|
|
|
1013 if (((aoptyTable1 == ASM_OPERAND_TYPE._reg || aoptyTable1 == ASM_OPERAND_TYPE._float) &&
|
|
|
1014 amodTable1 == ASM_MODIFIERS._normal && (uRegmaskTable1 & _rplus_r)))
|
|
|
1015 {
|
|
|
1016 if (asmstate.ucItype == IT.ITfloat)
|
|
|
1017 pc.Irm += popnd1.base.val;
|
|
|
1018 else if (pc.Iop == 0x0f)
|
|
|
1019 pc.Iop2 += popnd1.base.val;
|
|
|
1020 else
|
|
|
1021 pc.Iop += popnd1.base.val;
|
|
|
1022 debug {
|
|
|
1023 auchOpcode[usIdx-1] += popnd1.base.val;
|
|
|
1024 }
|
|
|
1025 }
|
|
|
1026 else
|
|
|
1027 {
|
|
|
1028 asm_make_modrm_byte(
|
|
|
1029 ///debug {
|
|
|
1030 auchOpcode, &usIdx,
|
|
|
1031 ///}
|
|
|
1032 pc,
|
|
|
1033 ptb.pptb1.usFlags,
|
|
|
1034 popnd1, null);
|
|
|
1035 }
|
|
|
1036
|
|
|
1037 popndTmp = popnd1;
|
|
|
1038 aoptyTmp = aoptyTable1;
|
|
|
1039 uSizemaskTmp = cast(ushort)uSizemaskTable1;
|
|
|
1040 L1:
|
|
|
1041 if (aoptyTmp == ASM_OPERAND_TYPE._imm)
|
|
|
1042 {
|
|
|
1043 Declaration d = popndTmp.s ? popndTmp.s.isDeclaration() : null;
|
|
|
1044 if (popndTmp.bSeg)
|
|
|
1045 {
|
|
|
1046 if (!(d && d.isDataseg()))
|
|
|
1047 asmerr(ASMERRMSGS.EM_bad_addr_mode); // illegal addressing mode
|
|
|
1048 }
|
|
|
1049 switch (uSizemaskTmp)
|
|
|
1050 {
|
|
|
1051 case _8:
|
|
|
1052 case _16:
|
|
|
1053 case _32:
|
|
|
1054 if (popndTmp.s is asmstate.psLocalsize)
|
|
|
1055 {
|
|
|
1056 pc.IFL2 = FL.FLlocalsize;
|
|
|
1057 pc.IEVdsym2() = null;
|
|
|
1058 pc.Iflags |= CF.CFoff;
|
|
|
1059 pc.IEVoffset2() = popndTmp.disp;
|
|
|
1060 }
|
|
|
1061 else if (d)
|
|
|
1062 {
|
|
|
1063 static if (false) {
|
|
|
1064 if ((pc.IFL2 = d.Sfl) == 0)
|
|
|
1065 pc.IFL2 = FL.FLdsymbol;
|
|
|
1066 } else {
|
|
|
1067 pc.IFL2 = FL.FLdsymbol;
|
|
|
1068 }
|
|
|
1069 pc.Iflags &= ~(CF.CFseg | CF.CFoff);
|
|
|
1070 if (popndTmp.bSeg)
|
|
|
1071 pc.Iflags |= CF.CFseg;
|
|
|
1072 else
|
|
|
1073 pc.Iflags |= CF.CFoff;
|
|
|
1074
|
|
|
1075 pc.IEVoffset2() = popndTmp.disp;
|
|
|
1076 pc.IEVdsym2() = d;
|
|
|
1077 }
|
|
|
1078 else
|
|
|
1079 {
|
|
|
1080 pc.IEVint2() = popndTmp.disp;
|
|
|
1081 pc.IFL2 = FL.FLconst;
|
|
|
1082 }
|
|
|
1083 break;
|
|
|
1084 }
|
|
|
1085 }
|
|
|
1086
|
|
|
1087 break;
|
|
|
1088 case 2:
|
|
|
1089 //
|
|
|
1090 // If there are two immediate operands then
|
|
|
1091 //
|
|
|
1092 if (aoptyTable1 == ASM_OPERAND_TYPE._imm && aoptyTable2 == ASM_OPERAND_TYPE._imm)
|
|
|
1093 {
|
|
|
1094 pc.IEVint1() = popnd1.disp;
|
|
|
1095 pc.IFL1 = FL.FLconst;
|
|
|
1096 pc.IEVint2() = popnd2.disp;
|
|
|
1097 pc.IFL2 = FL.FLconst;
|
|
|
1098 break;
|
|
|
1099 }
|
|
|
1100 if (aoptyTable2 == ASM_OPERAND_TYPE._m ||
|
|
|
1101 aoptyTable2 == ASM_OPERAND_TYPE._rel ||
|
|
|
1102 // If not MMX register (_mm) or XMM register (_xmm)
|
|
|
1103 (amodTable1 == ASM_MODIFIERS._rspecial && !(uRegmaskTable1 & (0x08 | 0x10)) && !uSizemaskTable1) ||
|
|
|
1104 aoptyTable2 == ASM_OPERAND_TYPE._rm ||
|
|
|
1105 (popnd1.usFlags == _r32 && popnd2.usFlags == _xmm) ||
|
|
|
1106 (popnd1.usFlags == _r32 && popnd2.usFlags == _mm))
|
|
|
1107 {
|
|
|
1108 static if (false) {
|
|
|
1109 printf("test4 %d,%d,%d,%d\n",
|
|
|
1110 (aoptyTable2 == ASM_OPERAND_TYPE._m),
|
|
|
1111 (aoptyTable2 == ASM_OPERAND_TYPE._rel),
|
|
|
1112 (amodTable1 == ASM_MODIFIERS._rspecial && !(uRegmaskTable1 & (0x08 | 0x10))),
|
|
|
1113 (aoptyTable2 == ASM_OPERAND_TYPE._rm)
|
|
|
1114 );
|
|
|
1115 printf("usOpcode = %x\n", usOpcode);
|
|
|
1116 }
|
|
|
1117 if (ptb.pptb0.usOpcode == 0x0F7E || // MOVD _rm32,_mm
|
|
|
1118 ptb.pptb0.usOpcode == 0x660F7E // MOVD _rm32,_xmm
|
|
|
1119 )
|
|
|
1120 {
|
|
|
1121 asm_make_modrm_byte(
|
|
|
1122 ///debug {
|
|
|
1123 auchOpcode, &usIdx,
|
|
|
1124 ///}
|
|
|
1125 pc,
|
|
|
1126 ptb.pptb1.usFlags,
|
|
|
1127 popnd1, popnd2);
|
|
|
1128 }
|
|
|
1129 else
|
|
|
1130 {
|
|
|
1131 asm_make_modrm_byte(
|
|
|
1132 ///debug {
|
|
|
1133 auchOpcode, &usIdx,
|
|
|
1134 ///}
|
|
|
1135 pc,
|
|
|
1136 ptb.pptb1.usFlags,
|
|
|
1137 popnd2, popnd1);
|
|
|
1138 }
|
|
|
1139 popndTmp = popnd1;
|
|
|
1140 aoptyTmp = aoptyTable1;
|
|
|
1141 uSizemaskTmp = cast(ushort)uSizemaskTable1;
|
|
|
1142 }
|
|
|
1143 else
|
|
|
1144 {
|
|
|
1145 if (((aoptyTable1 == ASM_OPERAND_TYPE._reg || aoptyTable1 == ASM_OPERAND_TYPE._float) &&
|
|
|
1146 amodTable1 == ASM_MODIFIERS._normal &&
|
|
|
1147 (uRegmaskTable1 & _rplus_r)))
|
|
|
1148 {
|
|
|
1149 if (asmstate.ucItype == IT.ITfloat)
|
|
|
1150 pc.Irm += popnd1.base.val;
|
|
|
1151 else if (pc.Iop == 0x0f)
|
|
|
1152 pc.Iop2 += popnd1.base.val;
|
|
|
1153 else
|
|
|
1154 pc.Iop += popnd1.base.val;
|
|
|
1155 debug {
|
|
|
1156 auchOpcode[usIdx-1] += popnd1.base.val;
|
|
|
1157 }
|
|
|
1158 }
|
|
|
1159 else if (((aoptyTable2 == ASM_OPERAND_TYPE._reg || aoptyTable2 == ASM_OPERAND_TYPE._float) &&
|
|
|
1160 amodTable2 == ASM_MODIFIERS._normal &&
|
|
|
1161 (uRegmaskTable2 & _rplus_r)))
|
|
|
1162 {
|
|
|
1163 if (asmstate.ucItype == IT.ITfloat)
|
|
|
1164 pc.Irm += popnd2.base.val;
|
|
|
1165 else if (pc.Iop == 0x0f)
|
|
|
1166 pc.Iop2 += popnd2.base.val;
|
|
|
1167 else
|
|
|
1168 pc.Iop += popnd2.base.val;
|
|
|
1169 debug {
|
|
|
1170 auchOpcode[usIdx-1] += popnd2.base.val;
|
|
|
1171 }
|
|
|
1172 }
|
|
|
1173 else if (ptb.pptb0.usOpcode == 0xF30FD6 ||
|
|
|
1174 ptb.pptb0.usOpcode == 0x0F12 ||
|
|
|
1175 ptb.pptb0.usOpcode == 0x0F16 ||
|
|
|
1176 ptb.pptb0.usOpcode == 0x660F50 ||
|
|
|
1177 ptb.pptb0.usOpcode == 0x0F50 ||
|
|
|
1178 ptb.pptb0.usOpcode == 0x660FD7 ||
|
|
|
1179 ptb.pptb0.usOpcode == 0x0FD7)
|
|
|
1180 {
|
|
|
1181 asm_make_modrm_byte(
|
|
|
1182 ///debug {
|
|
|
1183 auchOpcode, &usIdx,
|
|
|
1184 ///}
|
|
|
1185 pc,
|
|
|
1186 ptb.pptb1.usFlags,
|
|
|
1187 popnd2, popnd1);
|
|
|
1188 }
|
|
|
1189 else
|
|
|
1190 {
|
|
|
1191 asm_make_modrm_byte(
|
|
|
1192 ///debug {
|
|
|
1193 auchOpcode, &usIdx,
|
|
|
1194 ///}
|
|
|
1195 pc,
|
|
|
1196 ptb.pptb1.usFlags,
|
|
|
1197 popnd1, popnd2);
|
|
|
1198
|
|
|
1199 }
|
|
|
1200 if (aoptyTable1 == ASM_OPERAND_TYPE._imm)
|
|
|
1201 {
|
|
|
1202 popndTmp = popnd1;
|
|
|
1203 aoptyTmp = aoptyTable1;
|
|
|
1204 uSizemaskTmp = cast(ushort)uSizemaskTable1;
|
|
|
1205 }
|
|
|
1206 else
|
|
|
1207 {
|
|
|
1208 popndTmp = popnd2;
|
|
|
1209 aoptyTmp = aoptyTable2;
|
|
|
1210 uSizemaskTmp = cast(ushort)uSizemaskTable2;
|
|
|
1211 }
|
|
|
1212 }
|
|
|
1213 goto L1;
|
|
|
1214
|
|
|
1215 case 3:
|
|
|
1216 if (aoptyTable2 == ASM_OPERAND_TYPE._m || aoptyTable2 == ASM_OPERAND_TYPE._rm ||
|
|
|
1217 usOpcode == 0x0FC5) // PEXTRW
|
|
|
1218 {
|
|
|
1219 asm_make_modrm_byte(
|
|
|
1220 ///debug {
|
|
|
1221 auchOpcode, &usIdx,
|
|
|
1222 ///}
|
|
|
1223 pc,
|
|
|
1224 ptb.pptb1.usFlags,
|
|
|
1225 popnd2, popnd1);
|
|
|
1226 popndTmp = popnd3;
|
|
|
1227 aoptyTmp = aoptyTable3;
|
|
|
1228 uSizemaskTmp = cast(ushort)uSizemaskTable3;
|
|
|
1229 } else {
|
|
|
1230 if (((aoptyTable1 == ASM_OPERAND_TYPE._reg || aoptyTable1 == ASM_OPERAND_TYPE._float) &&
|
|
|
1231 amodTable1 == ASM_MODIFIERS._normal &&
|
|
|
1232 (uRegmaskTable1 &_rplus_r)))
|
|
|
1233 {
|
|
|
1234 if (asmstate.ucItype == IT.ITfloat)
|
|
|
1235 pc.Irm += popnd1.base.val;
|
|
|
1236 else if (pc.Iop == 0x0f)
|
|
|
1237 pc.Iop2 += popnd1.base.val;
|
|
|
1238 else
|
|
|
1239 pc.Iop += popnd1.base.val;
|
|
|
1240 debug {
|
|
|
1241 auchOpcode[usIdx-1] += popnd1.base.val;
|
|
|
1242 }
|
|
|
1243 }
|
|
|
1244 else if (((aoptyTable2 == ASM_OPERAND_TYPE._reg || aoptyTable2 == ASM_OPERAND_TYPE._float) &&
|
|
|
1245 amodTable2 == ASM_MODIFIERS._normal &&
|
|
|
1246 (uRegmaskTable2 &_rplus_r)))
|
|
|
1247 {
|
|
|
1248 if (asmstate.ucItype == IT.ITfloat)
|
|
|
1249 pc.Irm += popnd1.base.val;
|
|
|
1250 else if (pc.Iop == 0x0f)
|
|
|
1251 pc.Iop2 += popnd1.base.val;
|
|
|
1252 else
|
|
|
1253 pc.Iop += popnd2.base.val;
|
|
|
1254 debug {
|
|
|
1255 auchOpcode[usIdx-1] += popnd2.base.val;
|
|
|
1256 }
|
|
|
1257 }
|
|
|
1258 else
|
|
|
1259 asm_make_modrm_byte(
|
|
|
1260 ///debug {
|
|
|
1261 auchOpcode, &usIdx,
|
|
|
1262 ///}
|
|
|
1263 pc,
|
|
|
1264 ptb.pptb1.usFlags,
|
|
|
1265 popnd1, popnd2);
|
|
|
1266
|
|
|
1267 popndTmp = popnd3;
|
|
|
1268 aoptyTmp = aoptyTable3;
|
|
|
1269 uSizemaskTmp = cast(ushort)uSizemaskTable3;
|
|
|
1270 }
|
|
|
1271 goto L1;
|
|
|
1272 }
|
|
|
1273 L2:
|
|
|
1274
|
|
|
1275 if ((pc.Iop & 0xF8) == 0xD8 &&
|
|
|
1276 ADDFWAIT() &&
|
|
|
1277 !(ptb.pptb0.usFlags & _nfwait))
|
|
|
1278 pc.Iflags |= CF.CFwait;
|
|
|
1279 else if ((ptb.pptb0.usFlags & _fwait) &&
|
|
|
1280 config.target_cpu >= TARGET.TARGET_80386)
|
|
|
1281 pc.Iflags |= CF.CFwait;
|
|
|
1282
|
|
|
1283 debug {
|
|
|
1284 if (debuga)
|
|
|
1285 {
|
|
|
1286 uint u;
|
|
|
1287
|
|
|
1288 for (u = 0; u < usIdx; u++)
|
|
|
1289 printf(" %02X", auchOpcode[u]);
|
|
|
1290
|
|
|
1291 printf("\t%s\t", asm_opstr(pop));
|
|
|
1292 if (popnd1)
|
|
|
1293 asm_output_popnd(popnd1);
|
|
|
1294 if (popnd2) {
|
|
|
1295 printf(",");
|
|
|
1296 asm_output_popnd(popnd2);
|
|
|
1297 }
|
|
|
1298 if (popnd3) {
|
|
|
1299 printf(",");
|
|
|
1300 asm_output_popnd(popnd3);
|
|
|
1301 }
|
|
|
1302 printf("\n");
|
|
|
1303 }
|
|
|
1304 }
|
|
|
1305
|
|
|
1306 pc = cat(pcPrefix, pc);
|
|
|
1307 pc = asm_genloc(loc, pc);
|
|
|
1308 return pc;
|
|
|
1309 }
|
|
|
1310
|
|
|
1311 void asm_token_trans(Token* tok)
|
|
|
1312 {
|
|
|
1313 tok_value = TOK.TOKeof;
|
|
|
1314
|
|
|
1315 if (tok)
|
|
|
1316 {
|
|
|
1317 tok_value = tok.value;
|
|
|
1318 if (tok_value == TOK.TOKidentifier)
|
|
|
1319 {
|
|
|
1320 string id = tok.ident.toChars();
|
|
|
1321 size_t len = id.length;
|
|
|
1322 if (len < 20)
|
|
|
1323 {
|
|
|
1324 ASMTK asmtk = cast(ASMTK) binary(toStringz(id), apszAsmtk.ptr, ASMTK.ASMTKmax);
|
|
|
1325 if (cast(int)asmtk >= 0)
|
|
|
1326 tok_value = cast(TOK)(asmtk + TOK.TOKMAX + 1);
|
|
|
1327 }
|
|
|
1328 }
|
|
|
1329 }
|
|
|
1330 }
|
|
|
1331
|
|
|
1332 void asm_token()
|
|
|
1333 {
|
|
|
1334 if (asmtok)
|
|
|
1335 asmtok = asmtok.next;
|
|
|
1336
|
|
|
1337 asm_token_trans(asmtok);
|
|
|
1338 }
|
|
|
1339
|
|
|
1340
|
|
|
1341 /**********************
|
|
|
1342 * If c is a power of 2, return that power else -1.
|
|
|
1343 */
|
|
|
1344
|
|
|
1345 int ispow2(ulong c)
|
|
|
1346 {
|
|
|
1347 int i;
|
|
|
1348
|
|
|
1349 if (c == 0 || (c & (c - 1)))
|
|
|
1350 i = -1;
|
|
|
1351 else
|
|
|
1352 for (i = 0; c >>= 1; i++) {
|
|
|
1353 ;
|
|
|
1354 }
|
|
|
1355
|
|
|
1356 return i;
|
|
|
1357 }
|
|
|
1358
|
|
|
1359 // Error numbers
|
|
|
1360 enum ASMERRMSGS
|
|
|
1361 {
|
|
|
1362 EM_bad_float_op,
|
|
|
1363 EM_bad_addr_mode,
|
|
|
1364 EM_align,
|
|
|
1365 EM_opcode_exp,
|
|
|
1366 EM_prefix,
|
|
|
1367 EM_eol,
|
|
|
1368 EM_bad_operand,
|
|
|
1369 EM_bad_integral_operand,
|
|
|
1370 EM_ident_exp,
|
|
|
1371 EM_not_struct,
|
|
|
1372 EM_nops_expected,
|
|
|
1373 EM_bad_op,
|
|
|
1374 EM_const_init,
|
|
|
1375 EM_undefined,
|
|
|
1376 EM_pointer,
|
|
|
1377 EM_colon,
|
|
|
1378 EM_rbra,
|
|
|
1379 EM_rpar,
|
|
|
1380 EM_ptr_exp,
|
|
|
1381 EM_num,
|
|
|
1382 EM_float,
|
|
|
1383 EM_char,
|
|
|
1384 EM_label_expected,
|
|
|
1385 EM_uplevel,
|
|
|
1386 EM_type_as_operand,
|
|
|
1387 }
|
|
|
1388
|
|
|
1389 mixin(BringToCurrentScope!(ASMERRMSGS));
|
|
|
1390
|
|
|
1391 string[] asmerrmsgs =
|
|
|
1392 [
|
|
|
1393 "unknown operand for floating point instruction",
|
|
|
1394 "bad addr mode",
|
|
|
1395 "align %d must be a power of 2",
|
|
|
1396 "opcode expected, not %s",
|
|
|
1397 "prefix",
|
|
|
1398 "end of instruction",
|
|
|
1399 "bad operand",
|
|
|
1400 "bad integral operand",
|
|
|
1401 "identifier expected",
|
|
|
1402 "not struct",
|
|
|
1403 "nops expected",
|
|
|
1404 "bad type/size of operands '%s'",
|
|
|
1405 "constant initializer expected",
|
|
|
1406 "undefined identifier '%s'",
|
|
|
1407 "pointer",
|
|
|
1408 "colon",
|
|
|
1409 "] expected instead of '%s'",
|
|
|
1410 ") expected instead of '%s'",
|
|
|
1411 "ptr expected",
|
|
|
1412 "integer expected",
|
|
|
1413 "floating point expected",
|
|
|
1414 "character is truncated",
|
|
|
1415 "label expected",
|
|
|
1416 "uplevel nested reference to variable %s",
|
|
|
1417 "cannot use type %s as an operand"
|
|
|
1418 ];
|
|
|
1419
|
|
|
1420 void asmerr(T...)(int errnum, T t)
|
|
|
1421 {
|
|
|
1422 string format = asmerrmsgs[errnum];
|
|
|
1423 asmerr(format, t);
|
|
|
1424 }
|
|
|
1425
|
|
|
1426 void asmerr(T...)(string format, T t)
|
|
|
1427 {
|
|
|
1428 string p = asmstate.loc.toChars();
|
|
|
1429 if (p.length != 0)
|
|
|
1430 writef("%s: ", p);
|
|
|
1431
|
|
|
1432 writefln(format, t);
|
|
|
1433
|
|
|
1434 longjmp(asmstate.env,1);
|
|
|
1435 }
|
|
|
1436
|
|
|
1437 PTRNTAB asm_classify(OP* pop, OPND* popnd1, OPND* popnd2, OPND* popnd3, uint* pusNumops)
|
|
|
1438 {
|
|
|
1439 uint usNumops;
|
|
|
1440 uint usActual;
|
|
|
1441 PTRNTAB ptbRet = { null };
|
|
|
1442 opflag_t usFlags1 = 0 ;
|
|
|
1443 opflag_t usFlags2 = 0;
|
|
|
1444 opflag_t usFlags3 = 0;
|
|
|
1445
|
|
|
1446 PTRNTAB1 *pptb1;
|
|
|
1447 PTRNTAB2 *pptb2;
|
|
|
1448 PTRNTAB3 *pptb3;
|
|
|
1449
|
|
|
1450 char bFake = false;
|
|
|
1451
|
|
|
1452 ubyte bMatch1, bMatch2, bMatch3, bRetry = false;
|
|
|
1453
|
|
|
1454 // How many arguments are there? the parser is strictly left to right
|
|
|
1455 // so this should work.
|
|
|
1456
|
|
|
1457 if (!popnd1)
|
|
|
1458 usNumops = 0;
|
|
|
1459 else
|
|
|
1460 {
|
|
|
1461 popnd1.usFlags = usFlags1 = asm_determine_operand_flags(popnd1);
|
|
|
1462 if (!popnd2)
|
|
|
1463 usNumops = 1;
|
|
|
1464 else
|
|
|
1465 {
|
|
|
1466 popnd2.usFlags = usFlags2 = asm_determine_operand_flags(popnd2);
|
|
|
1467 if (!popnd3)
|
|
|
1468 usNumops = 2;
|
|
|
1469 else
|
|
|
1470 {
|
|
|
1471 popnd3.usFlags = usFlags3 = asm_determine_operand_flags(popnd3);
|
|
|
1472 usNumops = 3;
|
|
|
1473 }
|
|
|
1474 }
|
|
|
1475 }
|
|
|
1476
|
|
|
1477 // Now check to insure that the number of operands is correct
|
|
|
1478 usActual = (pop.usNumops & IT.ITSIZE);
|
|
|
1479 if (usActual != usNumops && asmstate.ucItype != IT.ITopt &&
|
|
|
1480 asmstate.ucItype != IT.ITfloat)
|
|
|
1481 {
|
|
|
1482 PARAM_ERROR:
|
|
|
1483 asmerr(ASMERRMSGS.EM_nops_expected, usActual, asm_opstr(pop), usNumops);
|
|
|
1484 }
|
|
|
1485 *pusNumops = usNumops;
|
|
|
1486 //
|
|
|
1487 // The number of arguments matches, now check to find the opcode
|
|
|
1488 // in the associated opcode table
|
|
|
1489 //
|
|
|
1490 RETRY:
|
|
|
1491 //printf("usActual = %d\n", usActual);
|
|
|
1492 switch (usActual)
|
|
|
1493 {
|
|
|
1494 case 0:
|
|
|
1495 ptbRet = pop.ptb ;
|
|
|
1496 goto RETURN_IT;
|
|
|
1497
|
|
|
1498 case 1:
|
|
|
1499 //printf("usFlags1 = "); asm_output_flags(usFlags1); printf("\n");
|
|
|
1500 for (pptb1 = pop.ptb.pptb1; pptb1.usOpcode != ASM_END;
|
|
|
1501 pptb1++)
|
|
|
1502 {
|
|
|
1503 //printf("table = "); asm_output_flags(pptb1.usOp1); printf("\n");
|
|
|
1504 bMatch1 = asm_match_flags(usFlags1, pptb1.usOp1);
|
|
|
1505 if (bMatch1)
|
|
|
1506 { if (pptb1.usOpcode == 0x68 &&
|
|
|
1507 I32 &&
|
|
|
1508 pptb1.usOp1 == _imm16
|
|
|
1509 )
|
|
|
1510 // Don't match PUSH imm16 in 32 bit code
|
|
|
1511 continue;
|
|
|
1512 break;
|
|
|
1513 }
|
|
|
1514 if ((asmstate.ucItype == IT.ITimmed) &&
|
|
|
1515 asm_match_flags(usFlags1,
|
|
|
1516 CONSTRUCT_FLAGS(_8 | _16 | _32, ASM_OPERAND_TYPE._imm, ASM_MODIFIERS._normal,
|
|
|
1517 0)) &&
|
|
|
1518 popnd1.disp == pptb1.usFlags)
|
|
|
1519 break;
|
|
|
1520 if ((asmstate.ucItype == IT.ITopt ||
|
|
|
1521 asmstate.ucItype == IT.ITfloat) &&
|
|
|
1522 !usNumops &&
|
|
|
1523 !pptb1.usOp1)
|
|
|
1524 {
|
|
|
1525 if (usNumops > 1)
|
|
|
1526 goto PARAM_ERROR;
|
|
|
1527 break;
|
|
|
1528 }
|
|
|
1529 }
|
|
|
1530 if (pptb1.usOpcode == ASM_END)
|
|
|
1531 {
|
|
|
1532 debug {
|
|
|
1533 if (debuga)
|
|
|
1534 {
|
|
|
1535 printf("\t%s\t", asm_opstr(pop));
|
|
|
1536 if (popnd1)
|
|
|
1537 asm_output_popnd(popnd1);
|
|
|
1538 if (popnd2) {
|
|
|
1539 printf(",");
|
|
|
1540 asm_output_popnd(popnd2);
|
|
|
1541 }
|
|
|
1542 if (popnd3) {
|
|
|
1543 printf(",");
|
|
|
1544 asm_output_popnd(popnd3);
|
|
|
1545 }
|
|
|
1546 printf("\n");
|
|
|
1547
|
|
|
1548 printf("OPCODE mism = ");
|
|
|
1549 if (popnd1)
|
|
|
1550 asm_output_flags(popnd1.usFlags);
|
|
|
1551 else
|
|
|
1552 printf("NONE");
|
|
|
1553 printf("\n");
|
|
|
1554 }
|
|
|
1555 }
|
|
|
1556 TYPE_SIZE_ERROR:
|
|
|
1557 if (popnd1 && ASM_GET_aopty(popnd1.usFlags) != ASM_OPERAND_TYPE._reg)
|
|
|
1558 {
|
|
|
1559 usFlags1 = popnd1.usFlags |= _anysize;
|
|
|
1560 if (asmstate.ucItype == IT.ITjump)
|
|
|
1561 {
|
|
|
1562 if (bRetry && popnd1.s && !popnd1.s.isLabel())
|
|
|
1563 {
|
|
|
1564 asmerr(ASMERRMSGS.EM_label_expected, popnd1.s.toChars());
|
|
|
1565 }
|
|
|
1566
|
|
|
1567 popnd1.usFlags |= CONSTRUCT_FLAGS(0, 0, 0, _fanysize);
|
|
|
1568 }
|
|
|
1569 }
|
|
|
1570 if (popnd2 && ASM_GET_aopty(popnd2.usFlags) != ASM_OPERAND_TYPE._reg) {
|
|
|
1571 usFlags2 = popnd2.usFlags |= (_anysize);
|
|
|
1572 if (asmstate.ucItype == IT.ITjump)
|
|
|
1573 popnd2.usFlags |= CONSTRUCT_FLAGS(0, 0, 0,
|
|
|
1574 _fanysize);
|
|
|
1575 }
|
|
|
1576 if (popnd3 && ASM_GET_aopty(popnd3.usFlags) != ASM_OPERAND_TYPE._reg) {
|
|
|
1577 usFlags3 = popnd3.usFlags |= (_anysize);
|
|
|
1578 if (asmstate.ucItype == IT.ITjump)
|
|
|
1579 popnd3.usFlags |= CONSTRUCT_FLAGS(0, 0, 0,
|
|
|
1580 _fanysize);
|
|
|
1581 }
|
|
|
1582 if (bRetry)
|
|
|
1583 {
|
|
|
1584 asmerr(ASMERRMSGS.EM_bad_op, fromStringz(asm_opstr(pop))); // illegal type/size of operands
|
|
|
1585 }
|
|
|
1586 bRetry = true;
|
|
|
1587 goto RETRY;
|
|
|
1588 }
|
|
|
1589 ptbRet.pptb1 = pptb1;
|
|
|
1590 goto RETURN_IT;
|
|
|
1591
|
|
|
1592 case 2:
|
|
|
1593 //printf("usFlags1 = "); asm_output_flags(usFlags1); printf(" ");
|
|
|
1594 //printf("usFlags2 = "); asm_output_flags(usFlags2); printf("\n");
|
|
|
1595 for (pptb2 = pop.ptb.pptb2;
|
|
|
1596 pptb2.usOpcode != ASM_END;
|
|
|
1597 pptb2++)
|
|
|
1598 {
|
|
|
1599 //printf("table1 = "); asm_output_flags(pptb2.usOp1); printf(" ");
|
|
|
1600 //printf("table2 = "); asm_output_flags(pptb2.usOp2); printf("\n");
|
|
|
1601 bMatch1 = asm_match_flags(usFlags1, pptb2.usOp1);
|
|
|
1602 bMatch2 = asm_match_flags(usFlags2, pptb2.usOp2);
|
|
|
1603 //printf("match1 = %d, match2 = %d\n",bMatch1,bMatch2);
|
|
|
1604 if (bMatch1 && bMatch2) {
|
|
|
1605
|
|
|
1606 //printf("match\n");
|
|
|
1607
|
|
|
1608 // OK, if they both match and the first op in the table is not AL
|
|
|
1609 // or size of 8 and the second is immediate 8,
|
|
|
1610 // then check to see if the constant
|
|
|
1611 // is a signed 8 bit constant. If so, then do not match, otherwise match
|
|
|
1612 //
|
|
|
1613 if (!bRetry &&
|
|
|
1614 !((ASM_GET_uSizemask(pptb2.usOp1) & _8) ||
|
|
|
1615 (ASM_GET_uRegmask(pptb2.usOp1) & _al)) &&
|
|
|
1616 (ASM_GET_aopty(pptb2.usOp2) == ASM_OPERAND_TYPE._imm) &&
|
|
|
1617 (ASM_GET_uSizemask(pptb2.usOp2) & _8))
|
|
|
1618 {
|
|
|
1619 if (popnd2.disp <= char.max)
|
|
|
1620 break;
|
|
|
1621 else
|
|
|
1622 bFake = true;
|
|
|
1623 }
|
|
|
1624 else
|
|
|
1625 break;
|
|
|
1626 }
|
|
|
1627 if (asmstate.ucItype == IT.ITopt || asmstate.ucItype == IT.ITfloat)
|
|
|
1628 {
|
|
|
1629 switch (usNumops)
|
|
|
1630 {
|
|
|
1631 case 0:
|
|
|
1632 if (!pptb2.usOp1)
|
|
|
1633 goto Lfound2;
|
|
|
1634 break;
|
|
|
1635 case 1:
|
|
|
1636 if (bMatch1 && !pptb2.usOp2)
|
|
|
1637 goto Lfound2;
|
|
|
1638 break;
|
|
|
1639 case 2:
|
|
|
1640 break;
|
|
|
1641 default:
|
|
|
1642 goto PARAM_ERROR;
|
|
|
1643 }
|
|
|
1644 }
|
|
|
1645 static if (false) {
|
|
|
1646 if (asmstate.ucItype == IT.ITshift &&
|
|
|
1647 !pptb2.usOp2 &&
|
|
|
1648 bMatch1 && popnd2.disp == 1 &&
|
|
|
1649 asm_match_flags(usFlags2,
|
|
|
1650 CONSTRUCT_FLAGS(_8|_16|_32, ASM_OPERAND_TYPE._imm,ASM_MODIFIERS._normal,0))
|
|
|
1651 )
|
|
|
1652 {
|
|
|
1653 break;
|
|
|
1654 }
|
|
|
1655 }
|
|
|
1656 }
|
|
|
1657 Lfound2:
|
|
|
1658 if (pptb2.usOpcode == ASM_END)
|
|
|
1659 {
|
|
|
1660 debug {
|
|
|
1661 if (debuga)
|
|
|
1662 {
|
|
|
1663 printf("\t%s\t", asm_opstr(pop));
|
|
|
1664 if (popnd1)
|
|
|
1665 asm_output_popnd(popnd1);
|
|
|
1666 if (popnd2) {
|
|
|
1667 printf(",");
|
|
|
1668 asm_output_popnd(popnd2);
|
|
|
1669 }
|
|
|
1670 if (popnd3) {
|
|
|
1671 printf(",");
|
|
|
1672 asm_output_popnd(popnd3);
|
|
|
1673 }
|
|
|
1674 printf("\n");
|
|
|
1675
|
|
|
1676 printf("OPCODE mismatch = ");
|
|
|
1677 if (popnd1)
|
|
|
1678 asm_output_flags(popnd1.usFlags);
|
|
|
1679 else
|
|
|
1680 printf("NONE");
|
|
|
1681 printf( " Op2 = ");
|
|
|
1682 if (popnd2)
|
|
|
1683 asm_output_flags(popnd2.usFlags);
|
|
|
1684 else
|
|
|
1685 printf("NONE");
|
|
|
1686 printf("\n");
|
|
|
1687 }
|
|
|
1688 }
|
|
|
1689 goto TYPE_SIZE_ERROR;
|
|
|
1690 }
|
|
|
1691 ptbRet.pptb2 = pptb2;
|
|
|
1692 goto RETURN_IT;
|
|
|
1693
|
|
|
1694 case 3:
|
|
|
1695 for (pptb3 = pop.ptb.pptb3;
|
|
|
1696 pptb3.usOpcode != ASM_END;
|
|
|
1697 pptb3++)
|
|
|
1698 {
|
|
|
1699 bMatch1 = asm_match_flags(usFlags1, pptb3.usOp1);
|
|
|
1700 bMatch2 = asm_match_flags(usFlags2, pptb3.usOp2);
|
|
|
1701 bMatch3 = asm_match_flags(usFlags3, pptb3.usOp3);
|
|
|
1702 if (bMatch1 && bMatch2 && bMatch3)
|
|
|
1703 goto Lfound3;
|
|
|
1704
|
|
|
1705 if (asmstate.ucItype == IT.ITopt)
|
|
|
1706 {
|
|
|
1707 switch (usNumops)
|
|
|
1708 {
|
|
|
1709 case 0:
|
|
|
1710 if (!pptb3.usOp1)
|
|
|
1711 goto Lfound3;
|
|
|
1712 break;
|
|
|
1713 case 1:
|
|
|
1714 if (bMatch1 && !pptb3.usOp2)
|
|
|
1715 goto Lfound3;
|
|
|
1716 break;
|
|
|
1717 case 2:
|
|
|
1718 if (bMatch1 && bMatch2 && !pptb3.usOp3)
|
|
|
1719 goto Lfound3;
|
|
|
1720 break;
|
|
|
1721 case 3:
|
|
|
1722 break;
|
|
|
1723 default:
|
|
|
1724 goto PARAM_ERROR;
|
|
|
1725 }
|
|
|
1726 }
|
|
|
1727 }
|
|
|
1728 Lfound3:
|
|
|
1729 if (pptb3.usOpcode == ASM_END)
|
|
|
1730 {
|
|
|
1731 debug {
|
|
|
1732 if (debuga)
|
|
|
1733 {
|
|
|
1734 printf("\t%s\t", asm_opstr(pop));
|
|
|
1735 if (popnd1)
|
|
|
1736 asm_output_popnd(popnd1);
|
|
|
1737 if (popnd2) {
|
|
|
1738 printf(",");
|
|
|
1739 asm_output_popnd(popnd2);
|
|
|
1740 }
|
|
|
1741 if (popnd3) {
|
|
|
1742 printf(",");
|
|
|
1743 asm_output_popnd(popnd3);
|
|
|
1744 }
|
|
|
1745 printf("\n");
|
|
|
1746
|
|
|
1747 printf("OPCODE mismatch = ");
|
|
|
1748 if (popnd1)
|
|
|
1749 asm_output_flags(popnd1.usFlags);
|
|
|
1750 else
|
|
|
1751 printf("NONE");
|
|
|
1752 printf( " Op2 = ");
|
|
|
1753 if (popnd2)
|
|
|
1754 asm_output_flags(popnd2.usFlags);
|
|
|
1755 else
|
|
|
1756 printf("NONE");
|
|
|
1757 if (popnd3)
|
|
|
1758 asm_output_flags(popnd3.usFlags);
|
|
|
1759 printf("\n");
|
|
|
1760 }
|
|
|
1761 }
|
|
|
1762 goto TYPE_SIZE_ERROR;
|
|
|
1763 }
|
|
|
1764
|
|
|
1765 ptbRet.pptb3 = pptb3;
|
|
|
1766 goto RETURN_IT;
|
|
|
1767 }
|
|
|
1768
|
|
|
1769 RETURN_IT:
|
|
|
1770 if (bRetry && !bFake)
|
|
|
1771 {
|
|
|
1772 asmerr(ASMERRMSGS.EM_bad_op, fromStringz(asm_opstr(pop)));
|
|
|
1773 }
|
|
|
1774 return ptbRet;
|
|
|
1775 }
|
|
|
1776
|
|
|
1777 /*******************************
|
|
|
1778 * start of inline assemblers expression parser
|
|
|
1779 * NOTE: functions in call order instead of alphabetical
|
|
|
1780 */
|
|
|
1781
|
|
|
1782 /*******************************************
|
|
|
1783 * Parse DA expression
|
|
|
1784 *
|
|
|
1785 * Very limited define address to place a code
|
|
|
1786 * address in the assembly
|
|
|
1787 * Problems:
|
|
|
1788 * o Should use dw offset and dd offset instead,
|
|
|
1789 * for near/far support.
|
|
|
1790 * o Should be able to add an offset to the label address.
|
|
|
1791 * o Blocks addressed by DA should get their Bpred set correctly
|
|
|
1792 * for optimizer.
|
|
|
1793 */
|
|
|
1794
|
|
|
1795 code* asm_da_parse(OP* pop)
|
|
|
1796 {
|
|
|
1797 code* clst = null;
|
|
|
1798 elem* e;
|
|
|
1799
|
|
|
1800 while (1)
|
|
|
1801 {
|
|
|
1802 code* c;
|
|
|
1803
|
|
|
1804 if (tok_value == TOK.TOKidentifier)
|
|
|
1805 {
|
|
|
1806 LabelDsymbol label = asmstate.sc.func.searchLabel(asmtok.ident);
|
|
|
1807 if (!label)
|
|
|
1808 error(asmstate.loc, "label '%s' not found\n", asmtok.ident.toChars());
|
|
|
1809
|
|
|
1810 c = code_calloc();
|
|
|
1811 c.Iop = ASM;
|
|
|
1812 c.Iflags = CF.CFaddrsize;
|
|
|
1813 c.IFL1 = FL.FLblockoff;
|
|
|
1814 c.IEVlsym1() = label;
|
|
|
1815 c = asm_genloc(asmstate.loc, c);
|
|
|
1816 clst = cat(clst,c);
|
|
|
1817 }
|
|
|
1818 else
|
|
|
1819 asmerr(ASMERRMSGS.EM_bad_addr_mode); // illegal addressing mode
|
|
|
1820
|
|
|
1821 asm_token();
|
|
|
1822 if (tok_value != TOK.TOKcomma)
|
|
|
1823 break;
|
|
|
1824
|
|
|
1825 asm_token();
|
|
|
1826 }
|
|
|
1827
|
|
|
1828 asmstate.statement.regs |= mES | ALLREGS;
|
|
|
1829 asmstate.bReturnax = true;
|
|
|
1830
|
|
|
1831 return clst;
|
|
|
1832 }
|
|
|
1833
|
|
|
1834 /*******************************************
|
|
|
1835 * Parse DB, DW, DD, DQ and DT expressions.
|
|
|
1836 */
|
|
|
1837
|
|
|
1838 code* asm_db_parse(OP* pop)
|
|
|
1839 {
|
|
|
1840 uint usSize;
|
|
|
1841 uint usMaxbytes;
|
|
|
1842 uint usBytes;
|
|
|
1843
|
|
|
1844 union DT
|
|
|
1845 {
|
|
|
1846 targ_ullong ul;
|
|
|
1847 targ_float f;
|
|
|
1848 targ_double d;
|
|
|
1849 targ_ldouble ld;
|
|
|
1850 char value[10];
|
|
|
1851 }
|
|
|
1852
|
|
|
1853 DT dt;
|
|
|
1854
|
|
|
1855 code* c;
|
|
|
1856 uint op;
|
|
|
1857 static ubyte[7] opsize = [ 1,2,4,8,4,8,10 ];
|
|
|
1858
|
|
|
1859 op = pop.usNumops & IT.ITSIZE;
|
|
|
1860 usSize = opsize[op];
|
|
|
1861
|
|
|
1862 usBytes = 0;
|
|
|
1863 usMaxbytes = 0;
|
|
|
1864 c = code_calloc();
|
|
|
1865 c.Iop = ASM;
|
|
|
1866
|
|
|
1867 while (1)
|
|
|
1868 {
|
|
|
1869 size_t len;
|
|
|
1870 ubyte* q;
|
|
|
1871
|
|
|
1872 if (usBytes+usSize > usMaxbytes)
|
|
|
1873 {
|
|
|
1874 usMaxbytes = usBytes + usSize + 10;
|
|
2
|
1875 c.IEV1.as.bytes = cast(char*)GC.realloc(c.IEV1.as.bytes,usMaxbytes);
|
|
0
|
1876 }
|
|
|
1877 switch (tok_value)
|
|
|
1878 {
|
|
|
1879 case TOK.TOKint32v:
|
|
|
1880 dt.ul = asmtok.int32value;
|
|
|
1881 goto L1;
|
|
|
1882 case TOK.TOKuns32v:
|
|
|
1883 dt.ul = asmtok.uns32value;
|
|
|
1884 goto L1;
|
|
|
1885 case TOK.TOKint64v:
|
|
|
1886 dt.ul = asmtok.int64value;
|
|
|
1887 goto L1;
|
|
|
1888 case TOK.TOKuns64v:
|
|
|
1889 dt.ul = asmtok.uns64value;
|
|
|
1890 goto L1;
|
|
|
1891 L1:
|
|
|
1892 switch (op)
|
|
|
1893 {
|
|
|
1894 case OP_DB.OPdb:
|
|
|
1895 case OP_DB.OPds:
|
|
|
1896 case OP_DB.OPdi:
|
|
|
1897 case OP_DB.OPdl:
|
|
|
1898 break;
|
|
|
1899 default:
|
|
|
1900 asmerr(ASMERRMSGS.EM_float);
|
|
|
1901 }
|
|
|
1902 goto L2;
|
|
|
1903
|
|
|
1904 case TOK.TOKfloat32v:
|
|
|
1905 case TOK.TOKfloat64v:
|
|
|
1906 case TOK.TOKfloat80v:
|
|
|
1907 switch (op)
|
|
|
1908 {
|
|
|
1909 case OP_DB.OPdf:
|
|
|
1910 dt.f = asmtok.float80value;
|
|
|
1911 break;
|
|
|
1912 case OP_DB.OPdd:
|
|
|
1913 dt.d = asmtok.float80value;
|
|
|
1914 break;
|
|
|
1915 case OP_DB.OPde:
|
|
|
1916 dt.ld = asmtok.float80value;
|
|
|
1917 break;
|
|
|
1918 default:
|
|
|
1919 asmerr(ASMERRMSGS.EM_num);
|
|
|
1920 }
|
|
|
1921 goto L2;
|
|
|
1922
|
|
|
1923 L2:
|
|
|
1924 memcpy(c.IEV1.as.bytes + usBytes,&dt,usSize);
|
|
|
1925 usBytes += usSize;
|
|
|
1926 break;
|
|
|
1927
|
|
|
1928 case TOK.TOKstring:
|
|
|
1929 len = asmtok.len;
|
|
|
1930 q = cast(ubyte*)asmtok.ustring;
|
|
|
1931 L3:
|
|
|
1932 if (len)
|
|
|
1933 {
|
|
|
1934 usMaxbytes += len * usSize;
|
|
2
|
1935 c.IEV1.as.bytes = cast(char*)GC.realloc(c.IEV1.as.bytes,usMaxbytes);
|
|
0
|
1936 memcpy(c.IEV1.as.bytes + usBytes,asmtok.ustring,len);
|
|
|
1937
|
|
|
1938 char* p = c.IEV1.as.bytes + usBytes;
|
|
|
1939 for (size_t i = 0; i < len; i++)
|
|
|
1940 {
|
|
|
1941 // Be careful that this works
|
|
|
1942 memset(p, 0, usSize);
|
|
|
1943 switch (op)
|
|
|
1944 {
|
|
|
1945 case OP_DB.OPdb:
|
|
|
1946 *p = cast(ubyte)*q;
|
|
|
1947 if (*p != *q)
|
|
|
1948 asmerr(ASMERRMSGS.EM_char);
|
|
|
1949 break;
|
|
|
1950
|
|
|
1951 case OP_DB.OPds:
|
|
|
1952 *cast(short*)p = *cast(ubyte*)q;
|
|
|
1953 if (*cast(short*)p != *q)
|
|
|
1954 asmerr(ASMERRMSGS.EM_char);
|
|
|
1955 break;
|
|
|
1956
|
|
|
1957 case OP_DB.OPdi:
|
|
|
1958 case OP_DB.OPdl:
|
|
|
1959 *cast(int*)p = *q;
|
|
|
1960 break;
|
|
|
1961
|
|
|
1962 default:
|
|
|
1963 asmerr(ASMERRMSGS.EM_float);
|
|
|
1964 }
|
|
|
1965 q++;
|
|
|
1966 p += usSize;
|
|
|
1967 }
|
|
|
1968
|
|
|
1969 usBytes += len * usSize;
|
|
|
1970 }
|
|
|
1971 break;
|
|
|
1972
|
|
|
1973 case TOK.TOKidentifier:
|
|
|
1974 {
|
|
|
1975 Expression e = new IdentifierExp(asmstate.loc, asmtok.ident);
|
|
|
1976 e = e.semantic(asmstate.sc);
|
|
|
1977 e = e.optimize(WANT.WANTvalue | WANT.WANTinterpret);
|
|
|
1978 if (e.op == TOK.TOKint64)
|
|
|
1979 {
|
|
|
1980 dt.ul = e.toInteger();
|
|
|
1981 goto L2;
|
|
|
1982 }
|
|
|
1983 else if (e.op == TOK.TOKfloat64)
|
|
|
1984 {
|
|
|
1985 switch (op)
|
|
|
1986 {
|
|
|
1987 case OP_DB.OPdf:
|
|
|
1988 dt.f = e.toReal();
|
|
|
1989 break;
|
|
|
1990 case OP_DB.OPdd:
|
|
|
1991 dt.d = e.toReal();
|
|
|
1992 break;
|
|
|
1993 case OP_DB.OPde:
|
|
|
1994 dt.ld = e.toReal();
|
|
|
1995 break;
|
|
|
1996 default:
|
|
|
1997 asmerr(ASMERRMSGS.EM_num);
|
|
|
1998 }
|
|
|
1999 goto L2;
|
|
|
2000 }
|
|
|
2001 else if (e.op == TOK.TOKstring)
|
|
|
2002 {
|
|
|
2003 StringExp se = cast(StringExp)e;
|
|
|
2004 q = cast(ubyte*)se.string_;
|
|
|
2005 len = se.len;
|
|
|
2006 goto L3;
|
|
|
2007 }
|
|
|
2008 goto Ldefault;
|
|
|
2009 }
|
|
|
2010
|
|
|
2011 default:
|
|
|
2012 Ldefault:
|
|
|
2013 asmerr(ASMERRMSGS.EM_const_init); // constant initializer
|
|
|
2014 break;
|
|
|
2015 }
|
|
|
2016 c.IEV1.as.len = usBytes;
|
|
|
2017
|
|
|
2018 asm_token();
|
|
|
2019 if (tok_value != TOK.TOKcomma)
|
|
|
2020 break;
|
|
|
2021
|
|
|
2022 asm_token();
|
|
|
2023 }
|
|
|
2024
|
|
|
2025 c = asm_genloc(asmstate.loc, c);
|
|
|
2026
|
|
|
2027 asmstate.statement.regs |= /* mES| */ ALLREGS;
|
|
|
2028 asmstate.bReturnax = true;
|
|
|
2029
|
|
|
2030 return c;
|
|
|
2031 }
|
|
|
2032
|
|
|
2033 /**********************************
|
|
|
2034 * Parse and get integer expression.
|
|
|
2035 */
|
|
|
2036
|
|
|
2037 int asm_getnum()
|
|
|
2038 {
|
|
|
2039 int v;
|
|
|
2040 long i;
|
|
|
2041
|
|
|
2042 switch (tok_value)
|
|
|
2043 {
|
|
|
2044 case TOK.TOKint32v:
|
|
|
2045 v = asmtok.int32value;
|
|
|
2046 break;
|
|
|
2047
|
|
|
2048 case TOK.TOKuns32v:
|
|
|
2049 v = asmtok.uns32value;
|
|
|
2050 break;
|
|
|
2051
|
|
|
2052 case TOK.TOKidentifier:
|
|
|
2053 Expression e = new IdentifierExp(asmstate.loc, asmtok.ident);
|
|
|
2054 e = e.semantic(asmstate.sc);
|
|
|
2055 e = e.optimize(WANT.WANTvalue | WANT.WANTinterpret);
|
|
|
2056 i = e.toInteger();
|
|
|
2057 v = cast(int) i;
|
|
|
2058 if (v != i)
|
|
|
2059 asmerr(ASMERRMSGS.EM_num);
|
|
|
2060 break;
|
|
|
2061
|
|
|
2062 default:
|
|
|
2063 asmerr(ASMERRMSGS.EM_num);
|
|
|
2064 break;
|
|
|
2065 }
|
|
|
2066
|
|
|
2067 asm_token();
|
|
|
2068
|
|
|
2069 return v;
|
|
|
2070 }
|
|
|
2071
|
|
|
2072
|
|
|
2073 /*******************************
|
|
|
2074 */
|
|
|
2075
|
|
|
2076 OPND* asm_cond_exp()
|
|
|
2077 {
|
|
|
2078 OPND* o1;
|
|
|
2079 OPND* o2;
|
|
|
2080 OPND* o3;
|
|
|
2081
|
|
|
2082 //printf("asm_cond_exp()\n");
|
|
|
2083 o1 = asm_log_or_exp();
|
|
|
2084 if (tok_value == TOK.TOKquestion)
|
|
|
2085 {
|
|
|
2086 asm_token();
|
|
|
2087 o2 = asm_cond_exp();
|
|
|
2088 asm_token();
|
|
|
2089 asm_chktok(TOK.TOKcolon, ASMERRMSGS.EM_colon);
|
|
|
2090 o3 = asm_cond_exp();
|
|
|
2091 o1 = (o1.disp) ? o2 : o3;
|
|
|
2092 }
|
|
|
2093
|
|
|
2094 return o1;
|
|
|
2095 }
|
|
|
2096
|
|
|
2097 regm_t asm_modify_regs(PTRNTAB ptb, OPND* popnd1, OPND* popnd2)
|
|
|
2098 {
|
|
|
2099 regm_t usRet = 0;
|
|
|
2100
|
|
|
2101 switch (ptb.pptb0.usFlags & MOD_MASK) {
|
|
|
2102 case _modsi:
|
|
|
2103 usRet |= mSI;
|
|
|
2104 break;
|
|
|
2105 case _moddx:
|
|
|
2106 usRet |= mDX;
|
|
|
2107 break;
|
|
|
2108 case _mod2:
|
|
|
2109 if (popnd2)
|
|
|
2110 usRet |= asm_modify_regs(ptb, popnd2, null);
|
|
|
2111 break;
|
|
|
2112 case _modax:
|
|
|
2113 usRet |= mAX;
|
|
|
2114 break;
|
|
|
2115 case _modnot1:
|
|
|
2116 popnd1 = null;
|
|
|
2117 break;
|
|
|
2118 case _modaxdx:
|
|
|
2119 usRet |= (mAX | mDX);
|
|
|
2120 break;
|
|
|
2121 case _moddi:
|
|
|
2122 usRet |= mDI;
|
|
|
2123 break;
|
|
|
2124 case _modsidi:
|
|
|
2125 usRet |= (mSI | mDI);
|
|
|
2126 break;
|
|
|
2127 case _modcx:
|
|
|
2128 usRet |= mCX;
|
|
|
2129 break;
|
|
|
2130 case _modes:
|
|
|
2131 /*usRet |= mES;*/
|
|
|
2132 break;
|
|
|
2133 case _modall:
|
|
|
2134 asmstate.bReturnax = true;
|
|
|
2135 return /*mES |*/ ALLREGS;
|
|
|
2136 case _modsiax:
|
|
|
2137 usRet |= (mSI | mAX);
|
|
|
2138 break;
|
|
|
2139 case _modsinot1:
|
|
|
2140 usRet |= mSI;
|
|
|
2141 popnd1 = null;
|
|
|
2142 break;
|
|
|
2143 default:
|
|
|
2144 break; ///
|
|
|
2145 }
|
|
|
2146 if (popnd1 && ASM_GET_aopty(popnd1.usFlags) == ASM_OPERAND_TYPE._reg) {
|
|
|
2147 switch (ASM_GET_amod(popnd1.usFlags)) {
|
|
|
2148 default:
|
|
|
2149 if (ASM_GET_uSizemask(popnd1.usFlags) == _8) {
|
|
|
2150 switch(popnd1.base.val) {
|
|
|
2151 case _AL:
|
|
|
2152 case _AH:
|
|
|
2153 usRet |= mAX;
|
|
|
2154 break;
|
|
|
2155 case _BL:
|
|
|
2156 case _BH:
|
|
|
2157 usRet |= mBX;
|
|
|
2158 break;
|
|
|
2159 case _CL:
|
|
|
2160 case _CH:
|
|
|
2161 usRet |= mCX;
|
|
|
2162 break;
|
|
|
2163 case _DL:
|
|
|
2164 case _DH:
|
|
|
2165 usRet |= mDX;
|
|
|
2166 break;
|
|
|
2167 }
|
|
|
2168 }
|
|
|
2169 else {
|
|
|
2170 switch (popnd1.base.val) {
|
|
|
2171 case _AX:
|
|
|
2172 usRet |= mAX;
|
|
|
2173 break;
|
|
|
2174 case _BX:
|
|
|
2175 usRet |= mBX;
|
|
|
2176 break;
|
|
|
2177 case _CX:
|
|
|
2178 usRet |= mCX;
|
|
|
2179 break;
|
|
|
2180 case _DX:
|
|
|
2181 usRet |= mDX;
|
|
|
2182 break;
|
|
|
2183 case _SI:
|
|
|
2184 usRet |= mSI;
|
|
|
2185 break;
|
|
|
2186 case _DI:
|
|
|
2187 usRet |= mDI;
|
|
|
2188 break;
|
|
|
2189 default:
|
|
|
2190 break; ///
|
|
|
2191 }
|
|
|
2192 }
|
|
|
2193 break;
|
|
|
2194
|
|
|
2195 case ASM_MODIFIERS._rseg:
|
|
|
2196 //if (popnd1.base.val == _ES)
|
|
|
2197 //usRet |= mES;
|
|
|
2198 break;
|
|
|
2199
|
|
|
2200 case ASM_MODIFIERS._rspecial:
|
|
|
2201 break;
|
|
|
2202 }
|
|
|
2203 }
|
|
|
2204 if (usRet & mAX)
|
|
|
2205 asmstate.bReturnax = true;
|
|
|
2206
|
|
|
2207 return usRet;
|
|
|
2208 }
|
|
|
2209
|
|
|
2210
|
|
|
2211 /****************************
|
|
|
2212 * Fill in the modregrm and sib bytes of code.
|
|
|
2213 */
|
|
|
2214
|
|
|
2215 uint X(ubyte r1, ubyte r2) {
|
|
|
2216 return (((r1) * 16) + (r2));
|
|
|
2217 }
|
|
|
2218
|
|
|
2219 uint Y(ubyte r1) {
|
|
|
2220 return X(r1, 9);
|
|
|
2221 }
|
|
|
2222
|
|
|
2223 void asm_make_modrm_byte(
|
|
|
2224 ///debug {
|
|
|
2225 ubyte[] puchOpcode, uint* pusIdx,
|
|
|
2226 ///}
|
|
|
2227 code *pc,
|
|
|
2228 ushort usFlags,
|
|
|
2229 OPND *popnd, OPND *popnd2)
|
|
|
2230 {
|
|
|
2231 /// #undef modregrm
|
|
|
2232
|
|
|
2233 union MODRM_BYTE // mrmb
|
|
|
2234 {
|
|
|
2235 struct MODRM
|
|
|
2236 {
|
|
|
2237 mixin(bitfields!(
|
|
|
2238 uint, "rm", 3,
|
|
|
2239 uint, "reg", 3,
|
|
|
2240 uint, "mod", 2));
|
|
|
2241 }
|
|
|
2242
|
|
|
2243 ubyte uchOpcode;
|
|
|
2244 MODRM modregrm;
|
|
|
2245 }
|
|
|
2246
|
|
|
2247 union SIB_BYTE
|
|
|
2248 {
|
|
|
2249 struct SIB
|
|
|
2250 {
|
|
|
2251
|
|
|
2252 mixin(bitfields!(
|
|
|
2253 uint, "base", 3,
|
|
|
2254 uint, "index", 3,
|
|
|
2255 uint, "ss", 2));
|
|
|
2256 }
|
|
|
2257
|
|
|
2258 ubyte uchOpcode;
|
|
|
2259 SIB sib;
|
|
|
2260 }
|
|
|
2261
|
|
|
2262
|
|
|
2263 MODRM_BYTE mrmb;
|
|
|
2264 SIB_BYTE sib;
|
|
|
2265 char bSib = false;
|
|
|
2266 char bDisp = false;
|
|
|
2267 char b32bit = false;
|
|
|
2268 ubyte* puc;
|
|
|
2269 char bModset = false;
|
|
|
2270 Dsymbol s;
|
|
|
2271
|
|
|
2272 uint uSizemask = 0;
|
|
|
2273 ASM_OPERAND_TYPE aopty;
|
|
|
2274 ASM_MODIFIERS amod;
|
|
|
2275 ushort uRegmask;
|
|
|
2276 ubyte bOffsetsym = false;
|
|
|
2277
|
|
|
2278 static if (false) {
|
|
|
2279 printf("asm_make_modrm_byte(usFlags = x%x)\n", usFlags);
|
|
|
2280 printf("op1: ");
|
|
|
2281 asm_output_flags(popnd.usFlags);
|
|
|
2282 if (popnd2)
|
|
|
2283 {
|
|
|
2284 printf(" op2: ");
|
|
|
2285 asm_output_flags(popnd2.usFlags);
|
|
|
2286 }
|
|
|
2287 printf("\n");
|
|
|
2288 }
|
|
|
2289
|
|
|
2290 uSizemask = ASM_GET_uSizemask(popnd.usFlags);
|
|
|
2291 aopty = ASM_GET_aopty(popnd.usFlags);
|
|
|
2292 amod = ASM_GET_amod(popnd.usFlags);
|
|
|
2293 uRegmask = ASM_GET_uRegmask(popnd.usFlags);
|
|
|
2294 s = popnd.s;
|
|
|
2295 if (s)
|
|
|
2296 {
|
|
|
2297 Declaration d = s.isDeclaration();
|
|
|
2298
|
|
|
2299 if (amod == ASM_MODIFIERS._fn16 && aopty == ASM_OPERAND_TYPE._rel && popnd2)
|
|
|
2300 {
|
|
|
2301 aopty = ASM_OPERAND_TYPE._m;
|
|
|
2302 goto L1;
|
|
|
2303 }
|
|
|
2304
|
|
|
2305 if (amod == ASM_MODIFIERS._fn16 || amod == ASM_MODIFIERS._fn32)
|
|
|
2306 {
|
|
|
2307 pc.Iflags |= CF.CFoff;
|
|
|
2308 debug {
|
|
|
2309 puchOpcode[(*pusIdx)++] = 0;
|
|
|
2310 puchOpcode[(*pusIdx)++] = 0;
|
|
|
2311 }
|
|
|
2312 if (aopty == ASM_OPERAND_TYPE._m || aopty == ASM_OPERAND_TYPE._mnoi)
|
|
|
2313 {
|
|
|
2314 pc.IFL1 = FL.FLdata;
|
|
|
2315 pc.IEVdsym1() = d;
|
|
|
2316 pc.IEVoffset1() = 0;
|
|
|
2317 }
|
|
|
2318 else
|
|
|
2319 {
|
|
|
2320 if (aopty == ASM_OPERAND_TYPE._p)
|
|
|
2321 pc.Iflags |= CF.CFseg;
|
|
|
2322
|
|
|
2323 debug if (aopty == ASM_OPERAND_TYPE._p || aopty == ASM_OPERAND_TYPE._rel)
|
|
|
2324 {
|
|
|
2325 puchOpcode[(*pusIdx)++] = 0;
|
|
|
2326 puchOpcode[(*pusIdx)++] = 0;
|
|
|
2327 }
|
|
|
2328
|
|
|
2329 pc.IFL2 = FL.FLfunc;
|
|
|
2330 pc.IEVdsym2() = d;
|
|
|
2331 pc.IEVoffset2() = 0;
|
|
|
2332 //return;
|
|
|
2333 }
|
|
|
2334 }
|
|
|
2335 else
|
|
|
2336 {
|
|
|
2337 L1:
|
|
|
2338 LabelDsymbol label = s.isLabel();
|
|
|
2339 if (label)
|
|
|
2340 {
|
|
|
2341 if (s == asmstate.psDollar)
|
|
|
2342 {
|
|
|
2343 pc.IFL1 = FL.FLconst;
|
|
|
2344 if (uSizemask & (_8 | _16))
|
|
|
2345 pc.IEVint1() = popnd.disp;
|
|
|
2346 else if (uSizemask & _32)
|
|
|
2347 pc.IEVpointer1() = cast(targ_size_t) popnd.disp;
|
|
|
2348 }
|
|
|
2349 else
|
|
|
2350 {
|
|
|
2351 pc.IFL1 = FL.FLblockoff;
|
|
|
2352 pc.IEVlsym1() = label;
|
|
|
2353 }
|
|
|
2354 }
|
|
|
2355 else if (s == asmstate.psLocalsize)
|
|
|
2356 {
|
|
|
2357 pc.IFL1 = FL.FLlocalsize;
|
|
|
2358 pc.IEVdsym1() = null;
|
|
|
2359 pc.Iflags |= CF.CFoff;
|
|
|
2360 pc.IEVoffset1() = popnd.disp;
|
|
|
2361 }
|
|
|
2362 else if (s.isFuncDeclaration())
|
|
|
2363 {
|
|
|
2364 pc.IFL1 = FL.FLfunc;
|
|
|
2365 pc.IEVdsym1() = d;
|
|
|
2366 pc.IEVoffset1() = popnd.disp;
|
|
|
2367 }
|
|
|
2368 else
|
|
|
2369 {
|
|
|
2370 debug if (debuga)
|
|
|
2371 printf("Setting up symbol %s\n", d.ident.toChars());
|
|
|
2372
|
|
|
2373 pc.IFL1 = FL.FLdsymbol;
|
|
|
2374 pc.IEVdsym1() = d;
|
|
|
2375 pc.Iflags |= CF.CFoff;
|
|
|
2376 pc.IEVoffset1() = popnd.disp;
|
|
|
2377 }
|
|
|
2378 }
|
|
|
2379 }
|
|
|
2380
|
|
|
2381 mrmb.modregrm.reg = usFlags & NUM_MASK;
|
|
|
2382
|
|
|
2383 if (s && (aopty == ASM_OPERAND_TYPE._m || aopty == ASM_OPERAND_TYPE._mnoi) && !s.isLabel())
|
|
|
2384 {
|
|
|
2385 if (s == asmstate.psLocalsize)
|
|
|
2386 {
|
|
|
2387 DATA_REF:
|
|
|
2388 mrmb.modregrm.rm = BPRM;
|
|
|
2389 if (amod == ASM_MODIFIERS._addr16 || amod == ASM_MODIFIERS._addr32)
|
|
|
2390 mrmb.modregrm.mod = 0x2;
|
|
|
2391 else
|
|
|
2392 mrmb.modregrm.mod = 0x0;
|
|
|
2393 }
|
|
|
2394 else
|
|
|
2395 {
|
|
|
2396 Declaration d = s.isDeclaration();
|
|
|
2397 assert(d);
|
|
|
2398 if (d.isDataseg() || d.isCodeseg())
|
|
|
2399 {
|
|
|
2400 if (( I32 && amod == ASM_MODIFIERS._addr16) ||
|
|
|
2401 (!I32 && amod == ASM_MODIFIERS._addr32))
|
|
|
2402 asmerr(ASMERRMSGS.EM_bad_addr_mode); // illegal addressing mode
|
|
|
2403 goto DATA_REF;
|
|
|
2404 }
|
|
|
2405 mrmb.modregrm.rm = BPRM;
|
|
|
2406 mrmb.modregrm.mod = 0x2;
|
|
|
2407 }
|
|
|
2408 }
|
|
|
2409
|
|
|
2410 if (aopty == ASM_OPERAND_TYPE._reg || amod == ASM_MODIFIERS._rspecial) {
|
|
|
2411 mrmb.modregrm.mod = 0x3;
|
|
|
2412 mrmb.modregrm.rm = mrmb.modregrm.rm | popnd.base.val;
|
|
|
2413 }
|
|
|
2414 else if (amod == ASM_MODIFIERS._addr16 || (amod == ASM_MODIFIERS._flbl && !I32))
|
|
|
2415 {
|
|
|
2416 uint rm;
|
|
|
2417
|
|
|
2418 debug if (debuga)
|
|
|
2419 printf("This is an ADDR16\n");
|
|
|
2420
|
|
|
2421 if (!popnd.pregDisp1)
|
|
|
2422 { rm = 0x6;
|
|
|
2423 if (!s)
|
|
|
2424 bDisp = true;
|
|
|
2425 }
|
|
|
2426 else
|
|
|
2427 {
|
|
|
2428 uint r1r2;
|
|
|
2429
|
|
|
2430 if (popnd.pregDisp2)
|
|
|
2431 r1r2 = X(popnd.pregDisp1.val,popnd.pregDisp2.val);
|
|
|
2432 else
|
|
|
2433 r1r2 = Y(popnd.pregDisp1.val);
|
|
|
2434
|
|
|
2435 switch (r1r2)
|
|
|
2436 {
|
|
|
2437 case X(_BX,_SI): rm = 0; break;
|
|
|
2438 case X(_BX,_DI): rm = 1; break;
|
|
|
2439 case Y(_BX): rm = 7; break;
|
|
|
2440
|
|
|
2441 case X(_BP,_SI): rm = 2; break;
|
|
|
2442 case X(_BP,_DI): rm = 3; break;
|
|
|
2443 case Y(_BP): rm = 6; bDisp = true; break;
|
|
|
2444
|
|
|
2445 case X(_SI,_BX): rm = 0; break;
|
|
|
2446 case X(_SI,_BP): rm = 2; break;
|
|
|
2447 case Y(_SI): rm = 4; break;
|
|
|
2448
|
|
|
2449 case X(_DI,_BX): rm = 1; break;
|
|
|
2450 case X(_DI,_BP): rm = 3; break;
|
|
|
2451 case Y(_DI): rm = 5; break;
|
|
|
2452
|
|
|
2453 default:
|
|
|
2454 asmerr(ASMERRMSGS.EM_bad_addr_mode); // illegal addressing mode
|
|
|
2455 }
|
|
|
2456 }
|
|
|
2457 mrmb.modregrm.rm = rm;
|
|
|
2458
|
|
|
2459 debug if (debuga)
|
|
|
2460 printf("This is an mod = %d, popnd.s =%ld, popnd.disp = %ld\n",
|
|
|
2461 mrmb.modregrm.mod, s, popnd.disp);
|
|
|
2462
|
|
|
2463 if (!s || (!mrmb.modregrm.mod && popnd.disp))
|
|
|
2464 {
|
|
|
2465 if ((!popnd.disp && !bDisp) || !popnd.pregDisp1)
|
|
|
2466 mrmb.modregrm.mod = 0x0;
|
|
|
2467 else if (popnd.disp >= CHAR_MIN && popnd.disp <= SCHAR_MAX)
|
|
|
2468 mrmb.modregrm.mod = 0x1;
|
|
|
2469 else
|
|
|
2470 mrmb.modregrm.mod = 0X2;
|
|
|
2471 }
|
|
|
2472 else
|
|
|
2473 bOffsetsym = true;
|
|
|
2474
|
|
|
2475 }
|
|
|
2476 else if (amod == ASM_MODIFIERS._addr32 || (amod == ASM_MODIFIERS._flbl && I32))
|
|
|
2477 {
|
|
|
2478 debug if (debuga)
|
|
|
2479 printf("This is an ADDR32\n");
|
|
|
2480
|
|
|
2481 if (!popnd.pregDisp1)
|
|
|
2482 mrmb.modregrm.rm = 0x5;
|
|
|
2483 else if (popnd.pregDisp2 ||
|
|
|
2484 popnd.uchMultiplier ||
|
|
|
2485 popnd.pregDisp1.val == _ESP)
|
|
|
2486 {
|
|
|
2487 if (popnd.pregDisp2)
|
|
|
2488 {
|
|
|
2489 if (popnd.pregDisp2.val == _ESP)
|
|
|
2490 asmerr(ASMERRMSGS.EM_bad_addr_mode); // illegal addressing mode
|
|
|
2491 }
|
|
|
2492 else
|
|
|
2493 {
|
|
|
2494 if (popnd.uchMultiplier && popnd.pregDisp1.val ==_ESP)
|
|
|
2495 asmerr(ASMERRMSGS.EM_bad_addr_mode); // illegal addressing mode
|
|
|
2496 bDisp = true;
|
|
|
2497 }
|
|
|
2498
|
|
|
2499 mrmb.modregrm.rm = 0x4;
|
|
|
2500 bSib = true;
|
|
|
2501 if (bDisp)
|
|
|
2502 {
|
|
|
2503 if (!popnd.uchMultiplier &&
|
|
|
2504 popnd.pregDisp1.val==_ESP)
|
|
|
2505 {
|
|
|
2506 sib.sib.base = popnd.pregDisp1.val;
|
|
|
2507 sib.sib.index = 0x4;
|
|
|
2508 }
|
|
|
2509 else
|
|
|
2510 {
|
|
|
2511 debug if (debuga)
|
|
|
2512 printf("Resetting the mod to 0\n");
|
|
|
2513
|
|
|
2514 if (popnd.pregDisp2)
|
|
|
2515 {
|
|
|
2516 if (popnd.pregDisp2.val != _EBP)
|
|
|
2517 asmerr(ASMERRMSGS.EM_bad_addr_mode); // illegal addressing mode
|
|
|
2518 }
|
|
|
2519 else
|
|
|
2520 {
|
|
|
2521 mrmb.modregrm.mod = 0x0;
|
|
|
2522 bModset = true;
|
|
|
2523 }
|
|
|
2524
|
|
|
2525 sib.sib.base = 0x5;
|
|
|
2526 sib.sib.index = popnd.pregDisp1.val;
|
|
|
2527 }
|
|
|
2528 }
|
|
|
2529 else
|
|
|
2530 {
|
|
|
2531 sib.sib.base = popnd.pregDisp1.val;
|
|
|
2532 //
|
|
|
2533 // This is to handle the special case
|
|
|
2534 // of using the EBP register and no
|
|
|
2535 // displacement. You must put in an
|
|
|
2536 // 8 byte displacement in order to
|
|
|
2537 // get the correct opcodes.
|
|
|
2538 //
|
|
|
2539 if (popnd.pregDisp1.val == _EBP && (!popnd.disp && !s))
|
|
|
2540 {
|
|
|
2541 debug if (debuga)
|
|
|
2542 printf("Setting the mod to 1 in the _EBP case\n");
|
|
|
2543
|
|
|
2544 mrmb.modregrm.mod = 0x1;
|
|
|
2545 bDisp = true; // Need a
|
|
|
2546 // displacement
|
|
|
2547 bModset = true;
|
|
|
2548 }
|
|
|
2549
|
|
|
2550 sib.sib.index = popnd.pregDisp2.val;
|
|
|
2551 }
|
|
|
2552 switch (popnd.uchMultiplier)
|
|
|
2553 {
|
|
|
2554 case 0: sib.sib.ss = 0; break;
|
|
|
2555 case 1: sib.sib.ss = 0; break;
|
|
|
2556 case 2: sib.sib.ss = 1; break;
|
|
|
2557 case 4: sib.sib.ss = 2; break;
|
|
|
2558 case 8: sib.sib.ss = 3; break;
|
|
|
2559
|
|
|
2560 default:
|
|
|
2561 asmerr(ASMERRMSGS.EM_bad_addr_mode); // illegal addressing mode
|
|
|
2562 break;
|
|
|
2563 }
|
|
|
2564 if (bDisp && sib.sib.base == 0x5)
|
|
|
2565 b32bit = true;
|
|
|
2566 }
|
|
|
2567 else
|
|
|
2568 {
|
|
|
2569 uint rm;
|
|
|
2570
|
|
|
2571 if (popnd.uchMultiplier)
|
|
|
2572 asmerr(ASMERRMSGS.EM_bad_addr_mode); // illegal addressing mode
|
|
|
2573 switch (popnd.pregDisp1.val)
|
|
|
2574 {
|
|
|
2575 case _EAX: rm = 0; break;
|
|
|
2576 case _ECX: rm = 1; break;
|
|
|
2577 case _EDX: rm = 2; break;
|
|
|
2578 case _EBX: rm = 3; break;
|
|
|
2579 case _ESI: rm = 6; break;
|
|
|
2580 case _EDI: rm = 7; break;
|
|
|
2581
|
|
|
2582 case _EBP:
|
|
|
2583 if (!popnd.disp && !s)
|
|
|
2584 {
|
|
|
2585 mrmb.modregrm.mod = 0x1;
|
|
|
2586 bDisp = true; // Need a displacement
|
|
|
2587 bModset = true;
|
|
|
2588 }
|
|
|
2589 rm = 5;
|
|
|
2590 break;
|
|
|
2591
|
|
|
2592 default:
|
|
|
2593 asmerr(ASMERRMSGS.EM_bad_addr_mode); // illegal addressing mode
|
|
|
2594 break;
|
|
|
2595 }
|
|
|
2596 mrmb.modregrm.rm = rm;
|
|
|
2597 }
|
|
|
2598 if (!bModset && (!s || (!mrmb.modregrm.mod && popnd.disp)))
|
|
|
2599 {
|
|
|
2600 if ((!popnd.disp && !mrmb.modregrm.mod) ||
|
|
|
2601 (!popnd.pregDisp1 && !popnd.pregDisp2))
|
|
|
2602 {
|
|
|
2603 mrmb.modregrm.mod = 0x0;
|
|
|
2604 bDisp = true;
|
|
|
2605 }
|
|
|
2606 else if (popnd.disp >= CHAR_MIN && popnd.disp <= SCHAR_MAX)
|
|
|
2607 mrmb.modregrm.mod = 0x1;
|
|
|
2608 else
|
|
|
2609 mrmb.modregrm.mod = 0x2;
|
|
|
2610 }
|
|
|
2611 else
|
|
|
2612 bOffsetsym = true;
|
|
|
2613 }
|
|
|
2614 if (popnd2 && !mrmb.modregrm.reg &&
|
|
|
2615 asmstate.ucItype != IT.ITshift &&
|
|
|
2616 (ASM_GET_aopty(popnd2.usFlags) == ASM_OPERAND_TYPE._reg ||
|
|
|
2617 ASM_GET_amod(popnd2.usFlags) == ASM_MODIFIERS._rseg ||
|
|
|
2618 ASM_GET_amod(popnd2.usFlags) == ASM_MODIFIERS._rspecial))
|
|
|
2619 {
|
|
|
2620 mrmb.modregrm.reg = popnd2.base.val;
|
|
|
2621 }
|
|
|
2622 debug puchOpcode[ (*pusIdx)++ ] = mrmb.uchOpcode;
|
|
|
2623
|
|
|
2624 pc.Irm = mrmb.uchOpcode;
|
|
|
2625 //printf("Irm = %02x\n", pc.Irm);
|
|
|
2626 if (bSib)
|
|
|
2627 {
|
|
|
2628 debug puchOpcode[ (*pusIdx)++ ] = sib.uchOpcode;
|
|
|
2629 pc.Isib= sib.uchOpcode;
|
|
|
2630 }
|
|
|
2631 if ((!s || (popnd.pregDisp1 && !bOffsetsym)) &&
|
|
|
2632 aopty != ASM_OPERAND_TYPE._imm &&
|
|
|
2633 (popnd.disp || bDisp))
|
|
|
2634 {
|
|
|
2635 if (popnd.usFlags & _a16)
|
|
|
2636 {
|
|
|
2637 debug {
|
|
|
2638 puc = (cast(ubyte*) &(popnd.disp));
|
|
|
2639 puchOpcode[(*pusIdx)++] = puc[1];
|
|
|
2640 puchOpcode[(*pusIdx)++] = puc[0];
|
|
|
2641 }
|
|
|
2642 if (usFlags & (_modrm | NUM_MASK)) {
|
|
|
2643 debug if (debuga)
|
|
|
2644 printf("Setting up value %ld\n", popnd.disp);
|
|
|
2645
|
|
|
2646 pc.IEVint1() = popnd.disp;
|
|
|
2647 pc.IFL1 = FL.FLconst;
|
|
|
2648 }
|
|
|
2649 else {
|
|
|
2650 pc.IEVint2() = popnd.disp;
|
|
|
2651 pc.IFL2 = FL.FLconst;
|
|
|
2652 }
|
|
|
2653
|
|
|
2654 }
|
|
|
2655 else
|
|
|
2656 {
|
|
|
2657 debug {
|
|
|
2658 puc = (cast(ubyte*) &(popnd.disp));
|
|
|
2659 puchOpcode[(*pusIdx)++] = puc[3];
|
|
|
2660 puchOpcode[(*pusIdx)++] = puc[2];
|
|
|
2661 puchOpcode[(*pusIdx)++] = puc[1];
|
|
|
2662 puchOpcode[(*pusIdx)++] = puc[0];
|
|
|
2663 }
|
|
|
2664 if (usFlags & (_modrm | NUM_MASK)) {
|
|
|
2665 debug if (debuga)
|
|
|
2666 printf("Setting up value %ld\n", popnd.disp);
|
|
|
2667
|
|
|
2668 pc.IEVpointer1() = cast(targ_size_t) popnd.disp;
|
|
|
2669 pc.IFL1 = FL.FLconst;
|
|
|
2670 } else {
|
|
|
2671 pc.IEVpointer2() = cast(targ_size_t) popnd.disp;
|
|
|
2672 pc.IFL2 = FL.FLconst;
|
|
|
2673 }
|
|
|
2674 }
|
|
|
2675 }
|
|
|
2676 }
|
|
|
2677
|
|
|
2678 void asm_output_popnd(OPND* popnd)
|
|
|
2679 {
|
|
|
2680 if (popnd.segreg)
|
|
|
2681 printf("%s:", popnd.segreg.regstr);
|
|
|
2682
|
|
|
2683 if (popnd.s)
|
|
|
2684 writef("%s", popnd.s.ident.toChars());
|
|
|
2685
|
|
|
2686 if (popnd.base)
|
|
|
2687 printf("%s", popnd.base.regstr);
|
|
|
2688
|
|
|
2689 if (popnd.pregDisp1) {
|
|
|
2690 if (popnd.pregDisp2) {
|
|
|
2691 if (popnd.usFlags & _a32)
|
|
|
2692 if (popnd.uchMultiplier)
|
|
|
2693 printf("[%s][%s*%d]",
|
|
|
2694 popnd.pregDisp1.regstr,
|
|
|
2695 popnd.pregDisp2.regstr,
|
|
|
2696 popnd.uchMultiplier);
|
|
|
2697 else
|
|
|
2698 printf("[%s][%s]",
|
|
|
2699 popnd.pregDisp1.regstr,
|
|
|
2700 popnd.pregDisp2.regstr);
|
|
|
2701 else
|
|
|
2702 printf("[%s+%s]",
|
|
|
2703 popnd.pregDisp1.regstr,
|
|
|
2704 popnd.pregDisp2.regstr);
|
|
|
2705 }
|
|
|
2706 else {
|
|
|
2707 if (popnd.uchMultiplier)
|
|
|
2708 printf("[%s*%d]",
|
|
|
2709 popnd.pregDisp1.regstr,
|
|
|
2710 popnd.uchMultiplier);
|
|
|
2711 else
|
|
|
2712 printf("[%s]",
|
|
|
2713 popnd.pregDisp1.regstr);
|
|
|
2714 }
|
|
|
2715 }
|
|
|
2716 if (ASM_GET_aopty(popnd.usFlags) == ASM_OPERAND_TYPE._imm)
|
|
|
2717 printf("%lxh", popnd.disp);
|
|
|
2718 else if (popnd.disp)
|
|
|
2719 printf("+%lxh", popnd.disp);
|
|
|
2720 }
|
|
|
2721
|
|
|
2722 /*******************************
|
|
|
2723 * Prepend line number to c.
|
|
|
2724 */
|
|
|
2725
|
|
|
2726 code* asm_genloc(Loc loc, code* c)
|
|
|
2727 {
|
|
|
2728 if (global.params.symdebug)
|
|
|
2729 {
|
|
|
2730 code* pcLin;
|
|
|
2731 Srcpos srcpos;
|
|
|
2732
|
|
|
2733 srcpos.Slinnum = loc.linnum;
|
|
|
2734 srcpos.Sfilename = cast(char*)toStringz(loc.filename);
|
|
|
2735 pcLin = genlinnum(null, srcpos);
|
|
|
2736
|
|
|
2737 c = cat(pcLin, c);
|
|
|
2738 }
|
|
|
2739
|
|
|
2740 return c;
|
|
|
2741 }
|
|
|
2742
|
|
|
2743 opflag_t asm_determine_operand_flags(OPND* popnd)
|
|
|
2744 {
|
|
|
2745 Dsymbol ps;
|
|
|
2746 int ty;
|
|
|
2747 opflag_t us;
|
|
|
2748 opflag_t sz;
|
|
|
2749 ASM_OPERAND_TYPE opty;
|
|
|
2750 ASM_MODIFIERS amod;
|
|
|
2751
|
|
|
2752 // If specified 'offset' or 'segment' but no symbol
|
|
|
2753 if ((popnd.bOffset || popnd.bSeg) && !popnd.s)
|
|
|
2754 asmerr(ASMERRMSGS.EM_bad_addr_mode); // illegal addressing mode
|
|
|
2755
|
|
|
2756 if (asmstate.ucItype == IT.ITfloat)
|
|
|
2757 return asm_determine_float_flags(popnd);
|
|
|
2758
|
|
|
2759 // If just a register
|
|
|
2760 if (popnd.base && !popnd.s && !popnd.disp && !popnd.real_)
|
|
|
2761 return popnd.base.ty;
|
|
|
2762
|
|
|
2763 debug if (debuga)
|
|
|
2764 printf("popnd.base = %s\n, popnd.pregDisp1 = %ld\n", popnd.base ? popnd.base.regstr : "NONE", popnd.pregDisp1);
|
|
|
2765
|
|
|
2766 ps = popnd.s;
|
|
|
2767 Declaration ds = ps ? ps.isDeclaration() : null;
|
|
|
2768 if (ds && ds.storage_class & STC.STClazy)
|
|
|
2769 sz = _anysize;
|
|
|
2770 else
|
|
|
2771 sz = cast(ushort)asm_type_size((ds && ds.storage_class & (STC.STCout | STC.STCref)) ? popnd.ptype.pointerTo() : popnd.ptype);
|
|
|
2772 if (popnd.pregDisp1 && !popnd.base)
|
|
|
2773 {
|
|
|
2774 if (ps && ps.isLabel() && sz == _anysize)
|
|
|
2775 sz = I32 ? _32 : _16;
|
|
|
2776 return (popnd.pregDisp1.ty & _r32)
|
|
|
2777 ? CONSTRUCT_FLAGS(sz, ASM_OPERAND_TYPE._m, ASM_MODIFIERS._addr32, 0)
|
|
|
2778 : CONSTRUCT_FLAGS(sz, ASM_OPERAND_TYPE._m, ASM_MODIFIERS._addr16, 0);
|
|
|
2779 }
|
|
|
2780 else if (ps)
|
|
|
2781 {
|
|
|
2782 if (popnd.bOffset || popnd.bSeg || ps == asmstate.psLocalsize)
|
|
|
2783 return I32
|
|
|
2784 ? CONSTRUCT_FLAGS(_32, ASM_OPERAND_TYPE._imm, ASM_MODIFIERS._normal, 0)
|
|
|
2785 : CONSTRUCT_FLAGS(_16, ASM_OPERAND_TYPE._imm, ASM_MODIFIERS._normal, 0);
|
|
|
2786
|
|
|
2787 if (ps.isLabel())
|
|
|
2788 {
|
|
|
2789 switch (popnd.ajt)
|
|
|
2790 {
|
|
|
2791 case ASM_JUMPTYPE.ASM_JUMPTYPE_UNSPECIFIED:
|
|
|
2792 if (ps == asmstate.psDollar)
|
|
|
2793 {
|
|
|
2794 if (popnd.disp >= CHAR_MIN &&
|
|
|
2795 popnd.disp <= CHAR_MAX)
|
|
|
2796 us = CONSTRUCT_FLAGS(_8, _rel, ASM_MODIFIERS._flbl,0);
|
|
|
2797 else
|
|
|
2798 if (popnd.disp >= SHRT_MIN &&
|
|
|
2799 popnd.disp <= SHRT_MIN)
|
|
|
2800 us = CONSTRUCT_FLAGS(_16, _rel, ASM_MODIFIERS._flbl,0);
|
|
|
2801 else
|
|
|
2802 us = CONSTRUCT_FLAGS(_32, _rel, ASM_MODIFIERS._flbl,0);
|
|
|
2803 }
|
|
|
2804 else if (asmstate.ucItype != ITjump)
|
|
|
2805 {
|
|
|
2806 if (sz == _8)
|
|
|
2807 { us = CONSTRUCT_FLAGS(_8,ASM_OPERAND_TYPE._rel,ASM_MODIFIERS._flbl,0);
|
|
|
2808 break;
|
|
|
2809 }
|
|
|
2810 goto case_near;
|
|
|
2811 }
|
|
|
2812 else
|
|
|
2813 us = I32
|
|
|
2814 ? CONSTRUCT_FLAGS(_8|_32, ASM_OPERAND_TYPE._rel, ASM_MODIFIERS._flbl, 0)
|
|
|
2815 : CONSTRUCT_FLAGS(_8|_16, ASM_OPERAND_TYPE._rel, ASM_MODIFIERS._flbl, 0);
|
|
|
2816 break;
|
|
|
2817
|
|
|
2818 case ASM_JUMPTYPE.ASM_JUMPTYPE_NEAR:
|
|
|
2819 case_near:
|
|
|
2820 us = I32
|
|
|
2821 ? CONSTRUCT_FLAGS(_32, _rel, _flbl, 0)
|
|
|
2822 : CONSTRUCT_FLAGS(_16, _rel, _flbl, 0);
|
|
|
2823 break;
|
|
|
2824 case ASM_JUMPTYPE.ASM_JUMPTYPE_SHORT:
|
|
|
2825 us = CONSTRUCT_FLAGS(_8, _rel, _flbl, 0);
|
|
|
2826 break;
|
|
|
2827 case ASM_JUMPTYPE.ASM_JUMPTYPE_FAR:
|
|
|
2828 us = I32
|
|
|
2829 ? CONSTRUCT_FLAGS(_48, _rel, _flbl, 0)
|
|
|
2830 : CONSTRUCT_FLAGS(_32, _rel, _flbl, 0);
|
|
|
2831 break;
|
|
|
2832 default:
|
|
|
2833 assert(0);
|
|
|
2834 }
|
|
|
2835 return us;
|
|
|
2836 }
|
|
|
2837 if (!popnd.ptype)
|
|
|
2838 return CONSTRUCT_FLAGS(sz, _m, _normal, 0);
|
|
|
2839 ty = popnd.ptype.ty;
|
|
|
2840 if (ty == Tpointer && popnd.ptype.nextOf().ty == Tfunction &&
|
|
|
2841 !ps.isVarDeclaration())
|
|
|
2842 {
|
|
|
2843 static if (true) {
|
|
|
2844 return CONSTRUCT_FLAGS(_32, _m, _fn16, 0);
|
|
|
2845 } else {
|
|
|
2846 ty = popnd.ptype.Tnext.Tty;
|
|
|
2847 if (tyfarfunc(tybasic(ty))) {
|
|
|
2848 return I32
|
|
|
2849 ? CONSTRUCT_FLAGS(_48, _mnoi, _fn32, 0)
|
|
|
2850 : CONSTRUCT_FLAGS(_32, _mnoi, _fn32, 0);
|
|
|
2851 }
|
|
|
2852 else {
|
|
|
2853 return I32
|
|
|
2854 ? CONSTRUCT_FLAGS(_32, _m, _fn16, 0)
|
|
|
2855 : CONSTRUCT_FLAGS(_16, _m, _fn16, 0);
|
|
|
2856 }
|
|
|
2857 }
|
|
|
2858 }
|
|
|
2859 else if (ty == TY.Tfunction)
|
|
|
2860 {
|
|
|
2861 static if (true) {
|
|
|
2862 return CONSTRUCT_FLAGS(_32, _rel, _fn16, 0);
|
|
|
2863 } else {
|
|
|
2864 if (tyfarfunc(tybasic(ty)))
|
|
|
2865 return I32
|
|
|
2866 ? CONSTRUCT_FLAGS(_48, _p, _fn32, 0)
|
|
|
2867 : CONSTRUCT_FLAGS(_32, _p, _fn32, 0);
|
|
|
2868 else
|
|
|
2869 return I32
|
|
|
2870 ? CONSTRUCT_FLAGS(_32, _rel, _fn16, 0)
|
|
|
2871 : CONSTRUCT_FLAGS(_16, _rel, _fn16, 0);
|
|
|
2872 }
|
|
|
2873 }
|
|
|
2874 else if (asmstate.ucItype == IT.ITjump)
|
|
|
2875 {
|
|
|
2876 amod = _normal;
|
|
|
2877 goto L1;
|
|
|
2878 }
|
|
|
2879 else
|
|
|
2880 return CONSTRUCT_FLAGS(sz, _m, _normal, 0);
|
|
|
2881 }
|
|
|
2882 if (popnd.segreg /*|| popnd.bPtr*/)
|
|
|
2883 {
|
|
|
2884 amod = I32 ? _addr32 : _addr16;
|
|
|
2885 if (asmstate.ucItype == ITjump)
|
|
|
2886 {
|
|
|
2887 L1:
|
|
|
2888 opty = _m;
|
|
|
2889 if (I32)
|
|
|
2890 { if (sz == _48)
|
|
|
2891 opty = _mnoi;
|
|
|
2892 }
|
|
|
2893 else
|
|
|
2894 {
|
|
|
2895 if (sz == _32)
|
|
|
2896 opty = _mnoi;
|
|
|
2897 }
|
|
|
2898 us = CONSTRUCT_FLAGS(sz,opty,amod,0);
|
|
|
2899 }
|
|
|
2900 else
|
|
|
2901 us = CONSTRUCT_FLAGS(sz,
|
|
|
2902 // _rel, amod, 0);
|
|
|
2903 _m, amod, 0);
|
|
|
2904 }
|
|
|
2905
|
|
|
2906 else if (popnd.ptype)
|
|
|
2907 us = CONSTRUCT_FLAGS(sz, _imm, _normal, 0);
|
|
|
2908
|
|
|
2909 else if (popnd.disp >= CHAR_MIN && popnd.disp <= UCHAR_MAX)
|
|
|
2910 us = CONSTRUCT_FLAGS(_8 | _16 | _32, _imm, _normal, 0);
|
|
|
2911 else if (popnd.disp >= SHRT_MIN && popnd.disp <= USHRT_MAX)
|
|
|
2912 us = CONSTRUCT_FLAGS(_16 | _32, _imm, _normal, 0);
|
|
|
2913 else
|
|
|
2914 us = CONSTRUCT_FLAGS(_32, _imm, _normal, 0);
|
|
|
2915 return us;
|
|
|
2916 }
|
|
|
2917
|
|
|
2918 /*******************************
|
|
|
2919 * Match flags in operand against flags in opcode table.
|
|
|
2920 * Returns:
|
|
|
2921 * !=0 if match
|
|
|
2922 */
|
|
|
2923
|
|
|
2924 ubyte asm_match_flags(opflag_t usOp, opflag_t usTable)
|
|
|
2925 {
|
|
|
2926 ASM_OPERAND_TYPE aoptyTable;
|
|
|
2927 ASM_OPERAND_TYPE aoptyOp;
|
|
|
2928 ASM_MODIFIERS amodTable;
|
|
|
2929 ASM_MODIFIERS amodOp;
|
|
|
2930 uint uRegmaskTable;
|
|
|
2931 uint uRegmaskOp;
|
|
|
2932 ubyte bRegmatch;
|
|
|
2933 ubyte bRetval = false;
|
|
|
2934 uint uSizemaskOp;
|
|
|
2935 uint uSizemaskTable;
|
|
|
2936 ubyte bSizematch;
|
|
|
2937
|
|
|
2938 //printf("asm_match_flags(usOp = x%x, usTable = x%x)\n", usOp, usTable);
|
|
|
2939 if (asmstate.ucItype == IT.ITfloat)
|
|
|
2940 {
|
|
|
2941 bRetval = asm_match_float_flags(usOp, usTable);
|
|
|
2942 goto EXIT;
|
|
|
2943 }
|
|
|
2944
|
|
|
2945 uSizemaskOp = ASM_GET_uSizemask(usOp);
|
|
|
2946 uSizemaskTable = ASM_GET_uSizemask(usTable);
|
|
|
2947
|
|
|
2948 // Check #1, if the sizes do not match, NO match
|
|
|
2949 bSizematch = (uSizemaskOp & uSizemaskTable) != 0;
|
|
|
2950
|
|
|
2951 amodOp = ASM_GET_amod(usOp);
|
|
|
2952
|
|
|
2953 aoptyTable = ASM_GET_aopty(usTable);
|
|
|
2954 aoptyOp = ASM_GET_aopty(usOp);
|
|
|
2955
|
|
|
2956 // _mmm64 matches with a 64 bit mem or an MMX register
|
|
|
2957 if (usTable == _mmm64)
|
|
|
2958 {
|
|
|
2959 if (usOp == _mm)
|
|
|
2960 goto Lmatch;
|
|
|
2961 if (aoptyOp == _m && (bSizematch || uSizemaskOp == _anysize))
|
|
|
2962 goto Lmatch;
|
|
|
2963 goto EXIT;
|
|
|
2964 }
|
|
|
2965
|
|
|
2966 // _xmm_m32, _xmm_m64, _xmm_m128 match with XMM register or memory
|
|
|
2967 if (usTable == _xmm_m32 ||
|
|
|
2968 usTable == _xmm_m64 ||
|
|
|
2969 usTable == _xmm_m128)
|
|
|
2970 {
|
|
|
2971 if (usOp == _xmm)
|
|
|
2972 goto Lmatch;
|
|
|
2973 if (aoptyOp == _m && (bSizematch || uSizemaskOp == _anysize))
|
|
|
2974 goto Lmatch;
|
|
|
2975 }
|
|
|
2976
|
|
|
2977 if (!bSizematch && uSizemaskTable)
|
|
|
2978 {
|
|
|
2979 //printf("no size match\n");
|
|
|
2980 goto EXIT;
|
|
|
2981 }
|
|
|
2982
|
|
|
2983
|
|
|
2984 //
|
|
|
2985 // The operand types must match, otherwise return false.
|
|
|
2986 // There is one exception for the _rm which is a table entry which matches
|
|
|
2987 // _reg or _m
|
|
|
2988 //
|
|
|
2989 if (aoptyTable != aoptyOp)
|
|
|
2990 {
|
|
|
2991 if (aoptyTable == _rm && (aoptyOp == _reg ||
|
|
|
2992 aoptyOp == _m ||
|
|
|
2993 aoptyOp == _rel))
|
|
|
2994 goto Lok;
|
|
|
2995
|
|
|
2996 if (aoptyTable == _mnoi && aoptyOp == _m &&
|
|
|
2997 (uSizemaskOp == _32 && amodOp == _addr16 ||
|
|
|
2998 uSizemaskOp == _48 && amodOp == _addr32 ||
|
|
|
2999 uSizemaskOp == _48 && amodOp == _normal)
|
|
|
3000 )
|
|
|
3001 goto Lok;
|
|
|
3002 goto EXIT;
|
|
|
3003 }
|
|
|
3004 Lok:
|
|
|
3005
|
|
|
3006 //
|
|
|
3007 // Looks like a match so far, check to see if anything special is going on
|
|
|
3008 //
|
|
|
3009 amodTable = ASM_GET_amod(usTable);
|
|
|
3010 uRegmaskOp = ASM_GET_uRegmask(usOp);
|
|
|
3011 uRegmaskTable = ASM_GET_uRegmask(usTable);
|
|
|
3012 bRegmatch = ((!uRegmaskTable && !uRegmaskOp) ||
|
|
|
3013 (uRegmaskTable & uRegmaskOp));
|
|
|
3014
|
|
|
3015 switch (amodTable)
|
|
|
3016 {
|
|
|
3017 case _normal: // Normal's match with normals
|
|
|
3018 switch(amodOp) {
|
|
|
3019 case _normal:
|
|
|
3020 case _addr16:
|
|
|
3021 case _addr32:
|
|
|
3022 case _fn16:
|
|
|
3023 case _fn32:
|
|
|
3024 case _flbl:
|
|
|
3025 bRetval = (bSizematch || bRegmatch);
|
|
|
3026 goto EXIT;
|
|
|
3027 default:
|
|
|
3028 goto EXIT;
|
|
|
3029 }
|
|
|
3030 case _rseg:
|
|
|
3031 case _rspecial:
|
|
|
3032 bRetval = (amodOp == amodTable && bRegmatch);
|
|
|
3033 goto EXIT;
|
|
|
3034 }
|
|
|
3035 EXIT:
|
|
|
3036 static if (false) {
|
|
|
3037 printf("OP : ");
|
|
|
3038 asm_output_flags(usOp);
|
|
|
3039 printf("\nTBL: ");
|
|
|
3040 asm_output_flags(usTable);
|
|
|
3041 writef(": %s\n", bRetval ? "MATCH" : "NOMATCH");
|
|
|
3042 }
|
|
|
3043 return bRetval;
|
|
|
3044
|
|
|
3045 Lmatch:
|
|
|
3046 //printf("match\n");
|
|
|
3047 return 1;
|
|
|
3048 }
|
|
|
3049
|
|
|
3050 void asm_output_flags(opflag_t usFlags)
|
|
|
3051 {
|
|
|
3052 ASM_OPERAND_TYPE aopty = ASM_GET_aopty(usFlags);
|
|
|
3053 ASM_MODIFIERS amod = ASM_GET_amod(usFlags);
|
|
|
3054 uint uRegmask = ASM_GET_uRegmask(usFlags);
|
|
|
3055 uint uSizemask = ASM_GET_uSizemask(usFlags);
|
|
|
3056
|
|
|
3057 if (uSizemask == _anysize)
|
|
|
3058 printf("_anysize ");
|
|
|
3059 else if (uSizemask == 0)
|
|
|
3060 printf("0 ");
|
|
|
3061 else
|
|
|
3062 {
|
|
|
3063 if (uSizemask & _8)
|
|
|
3064 printf("_8 ");
|
|
|
3065 if (uSizemask & _16)
|
|
|
3066 printf("_16 ");
|
|
|
3067 if (uSizemask & _32)
|
|
|
3068 printf("_32 ");
|
|
|
3069 if (uSizemask & _48)
|
|
|
3070 printf("_48 ");
|
|
|
3071 }
|
|
|
3072
|
|
|
3073 printf("_");
|
|
|
3074 switch (aopty) {
|
|
|
3075 case ASM_OPERAND_TYPE._reg:
|
|
|
3076 printf("reg ");
|
|
|
3077 break;
|
|
|
3078 case ASM_OPERAND_TYPE._m:
|
|
|
3079 printf("m ");
|
|
|
3080 break;
|
|
|
3081 case ASM_OPERAND_TYPE._imm:
|
|
|
3082 printf("imm ");
|
|
|
3083 break;
|
|
|
3084 case ASM_OPERAND_TYPE._rel:
|
|
|
3085 printf("rel ");
|
|
|
3086 break;
|
|
|
3087 case ASM_OPERAND_TYPE._mnoi:
|
|
|
3088 printf("mnoi ");
|
|
|
3089 break;
|
|
|
3090 case ASM_OPERAND_TYPE._p:
|
|
|
3091 printf("p ");
|
|
|
3092 break;
|
|
|
3093 case ASM_OPERAND_TYPE._rm:
|
|
|
3094 printf("rm ");
|
|
|
3095 break;
|
|
|
3096 case ASM_OPERAND_TYPE._float:
|
|
|
3097 printf("float ");
|
|
|
3098 break;
|
|
|
3099 default:
|
|
|
3100 printf(" UNKNOWN ");
|
|
|
3101 }
|
|
|
3102
|
|
|
3103 printf("_");
|
|
|
3104 switch (amod) {
|
|
|
3105 case ASM_MODIFIERS._normal:
|
|
|
3106 printf("normal ");
|
|
|
3107 if (uRegmask & 1) printf("_al ");
|
|
|
3108 if (uRegmask & 2) printf("_ax ");
|
|
|
3109 if (uRegmask & 4) printf("_eax ");
|
|
|
3110 if (uRegmask & 8) printf("_dx ");
|
|
|
3111 if (uRegmask & 0x10) printf("_cl ");
|
|
|
3112 return;
|
|
|
3113 case ASM_MODIFIERS._rseg:
|
|
|
3114 printf("rseg ");
|
|
|
3115 break;
|
|
|
3116 case ASM_MODIFIERS._rspecial:
|
|
|
3117 printf("rspecial ");
|
|
|
3118 break;
|
|
|
3119 case ASM_MODIFIERS._addr16:
|
|
|
3120 printf("addr16 ");
|
|
|
3121 break;
|
|
|
3122 case ASM_MODIFIERS._addr32:
|
|
|
3123 printf("addr32 ");
|
|
|
3124 break;
|
|
|
3125 case ASM_MODIFIERS._fn16:
|
|
|
3126 printf("fn16 ");
|
|
|
3127 break;
|
|
|
3128 case ASM_MODIFIERS._fn32:
|
|
|
3129 printf("fn32 ");
|
|
|
3130 break;
|
|
|
3131 case ASM_MODIFIERS._flbl:
|
|
|
3132 printf("flbl ");
|
|
|
3133 break;
|
|
|
3134 default:
|
|
|
3135 printf("UNKNOWN ");
|
|
|
3136 break;
|
|
|
3137 }
|
|
|
3138
|
|
|
3139 printf("uRegmask=x%02x", uRegmask);
|
|
|
3140 }
|
|
|
3141
|
|
|
3142 OPND* asm_log_or_exp()
|
|
|
3143 {
|
|
|
3144 OPND* o1 = asm_log_and_exp();
|
|
|
3145 OPND* o2;
|
|
|
3146
|
|
|
3147 while (tok_value == TOK.TOKoror)
|
|
|
3148 {
|
|
|
3149 asm_token();
|
|
|
3150 o2 = asm_log_and_exp();
|
|
|
3151 if (asm_isint(o1) && asm_isint(o2))
|
|
|
3152 o1.disp = o1.disp || o2.disp;
|
|
|
3153 else
|
|
|
3154 asmerr(ASMERRMSGS.EM_bad_integral_operand); // illegal operand
|
|
|
3155 o2.disp = 0;
|
|
|
3156 o1 = asm_merge_opnds(o1, o2);
|
|
|
3157 }
|
|
|
3158 return o1;
|
|
|
3159 }
|
|
|
3160
|
|
|
3161 void asm_chktok(TOK toknum, uint errnum)
|
|
|
3162 {
|
|
|
3163 if (tok_value == toknum)
|
|
|
3164 asm_token(); // scan past token
|
|
|
3165 else
|
|
|
3166 /* When we run out of tokens, asmtok is null.
|
|
|
3167 * But when this happens when a ';' was hit.
|
|
|
3168 */
|
|
|
3169 asmerr(errnum, asmtok ? asmtok.toChars() : ";");
|
|
|
3170 }
|
|
|
3171
|
|
|
3172 opflag_t asm_determine_float_flags(OPND* popnd)
|
|
|
3173 {
|
|
|
3174 //printf("asm_determine_float_flags()\n");
|
|
|
3175
|
|
|
3176 opflag_t us;
|
|
|
3177 opflag_t usFloat;
|
|
|
3178
|
|
|
3179 // Insure that if it is a register, that it is not a normal processor
|
|
|
3180 // register.
|
|
|
3181
|
|
|
3182 if (popnd.base &&
|
|
|
3183 !popnd.s && !popnd.disp && !popnd.real_
|
|
|
3184 && !(popnd.base.ty & (_r8 | _r16 | _r32)))
|
|
|
3185 {
|
|
|
3186 return popnd.base.ty;
|
|
|
3187 }
|
|
|
3188 if (popnd.pregDisp1 && !popnd.base)
|
|
|
3189 {
|
|
|
3190 us = asm_float_type_size(popnd.ptype, &usFloat);
|
|
|
3191 //printf("us = x%x, usFloat = x%x\n", us, usFloat);
|
|
|
3192 if (popnd.pregDisp1.ty & _r32)
|
|
|
3193 return(CONSTRUCT_FLAGS(us, _m, _addr32, usFloat));
|
|
|
3194 else if (popnd.pregDisp1.ty & _r16)
|
|
|
3195 return(CONSTRUCT_FLAGS(us, _m, _addr16, usFloat));
|
|
|
3196 }
|
|
|
3197 else if (popnd.s !is null)
|
|
|
3198 {
|
|
|
3199 us = asm_float_type_size(popnd.ptype, &usFloat);
|
|
|
3200 return CONSTRUCT_FLAGS(us, _m, _normal, usFloat);
|
|
|
3201 }
|
|
|
3202
|
|
|
3203 if (popnd.segreg)
|
|
|
3204 {
|
|
|
3205 us = asm_float_type_size(popnd.ptype, &usFloat);
|
|
|
3206 if (I32)
|
|
|
3207 return(CONSTRUCT_FLAGS(us, _m, _addr32, usFloat));
|
|
|
3208 else
|
|
|
3209 return(CONSTRUCT_FLAGS(us, _m, _addr16, usFloat));
|
|
|
3210 }
|
|
|
3211
|
|
|
3212 static if (false) {
|
|
|
3213 if (popnd.real_)
|
|
|
3214 {
|
|
|
3215 switch (popnd.ptype.ty)
|
|
|
3216 {
|
|
|
3217 case TY.Tfloat32:
|
|
|
3218 popnd.s = fconst(popnd.real_);
|
|
|
3219 return(CONSTRUCT_FLAGS(_32, _m, _normal, 0));
|
|
|
3220
|
|
|
3221 case TY.Tfloat64:
|
|
|
3222 popnd.s = dconst(popnd.real_);
|
|
|
3223 return(CONSTRUCT_FLAGS(0, _m, _normal, _64));
|
|
|
3224
|
|
|
3225 case TY.Tfloat80:
|
|
|
3226 popnd.s = ldconst(popnd.real_);
|
|
|
3227 return(CONSTRUCT_FLAGS(0, _m, _normal, _80));
|
|
|
3228 }
|
|
|
3229 }
|
|
|
3230 }
|
|
|
3231
|
|
|
3232 asmerr(ASMERRMSGS.EM_bad_float_op); // unknown operand for floating point instruction
|
|
|
3233 return 0;
|
|
|
3234 }
|
|
|
3235
|
|
|
3236 uint asm_type_size(Type ptype)
|
|
|
3237 {
|
|
|
3238 //if (ptype) printf("asm_type_size('%s') = %d\n", ptype.toChars(), (int)ptype.size());
|
|
|
3239 uint u = _anysize;
|
|
|
3240 if (ptype && ptype.ty != TY.Tfunction /*&& ptype.isscalar()*/)
|
|
|
3241 {
|
|
|
3242 switch (cast(int)ptype.size())
|
|
|
3243 {
|
|
|
3244 case 0: asmerr(ASMERRMSGS.EM_bad_op, "0 size"); break;
|
|
|
3245 case 1: u = _8; break;
|
|
|
3246 case 2: u = _16; break;
|
|
|
3247 case 4: u = _32; break;
|
|
|
3248 case 6: u = _48; break;
|
|
|
3249 default:
|
|
|
3250 break; ///
|
|
|
3251 }
|
|
|
3252 }
|
|
|
3253 return u;
|
|
|
3254 }
|
|
|
3255
|
|
|
3256 bool asm_match_float_flags(opflag_t usOp, opflag_t usTable)
|
|
|
3257 {
|
|
|
3258 ASM_OPERAND_TYPE aoptyTable;
|
|
|
3259 ASM_OPERAND_TYPE aoptyOp;
|
|
|
3260 ASM_MODIFIERS amodTable;
|
|
|
3261 ASM_MODIFIERS amodOp;
|
|
|
3262 uint uRegmaskTable;
|
|
|
3263 uint uRegmaskOp;
|
|
|
3264 ubyte bRegmatch;
|
|
|
3265
|
|
|
3266
|
|
|
3267 //
|
|
|
3268 // Check #1, if the sizes do not match, NO match
|
|
|
3269 //
|
|
|
3270 uRegmaskOp = ASM_GET_uRegmask(usOp);
|
|
|
3271 uRegmaskTable = ASM_GET_uRegmask(usTable);
|
|
|
3272 bRegmatch = (uRegmaskTable & uRegmaskOp) != 0;
|
|
|
3273
|
|
|
3274 if (!(ASM_GET_uSizemask(usTable) & ASM_GET_uSizemask(usOp) || bRegmatch))
|
|
|
3275 return false;
|
|
|
3276
|
|
|
3277 aoptyTable = ASM_GET_aopty(usTable);
|
|
|
3278 aoptyOp = ASM_GET_aopty(usOp);
|
|
|
3279 //
|
|
|
3280 // The operand types must match, otherwise return false.
|
|
|
3281 // There is one exception for the _rm which is a table entry which matches
|
|
|
3282 // _reg or _m
|
|
|
3283 //
|
|
|
3284 if (aoptyTable != aoptyOp)
|
|
|
3285 {
|
|
|
3286 if (aoptyOp != _float)
|
|
|
3287 return false;
|
|
|
3288 }
|
|
|
3289
|
|
|
3290 //
|
|
|
3291 // Looks like a match so far, check to see if anything special is going on
|
|
|
3292 //
|
|
|
3293 amodOp = ASM_GET_amod(usOp);
|
|
|
3294 amodTable = ASM_GET_amod(usTable);
|
|
|
3295 switch (amodTable)
|
|
|
3296 {
|
|
|
3297 // Normal's match with normals
|
|
|
3298 case _normal:
|
|
|
3299 switch(amodOp)
|
|
|
3300 {
|
|
|
3301 case _normal:
|
|
|
3302 case _addr16:
|
|
|
3303 case _addr32:
|
|
|
3304 case _fn16:
|
|
|
3305 case _fn32:
|
|
|
3306 case _flbl:
|
|
|
3307 return true;
|
|
|
3308
|
|
|
3309 default:
|
|
|
3310 return false;
|
|
|
3311 }
|
|
|
3312
|
|
|
3313 case _rseg:
|
|
|
3314 case _rspecial:
|
|
|
3315 return false;
|
|
|
3316 default:
|
|
|
3317 assert(0);
|
|
|
3318 }
|
|
|
3319 }
|
|
|
3320
|
|
|
3321 OPND* asm_log_and_exp()
|
|
|
3322 {
|
|
|
3323 OPND* o1 = asm_inc_or_exp();
|
|
|
3324 OPND* o2;
|
|
|
3325
|
|
|
3326 while (tok_value == TOKandand)
|
|
|
3327 {
|
|
|
3328 asm_token();
|
|
|
3329 o2 = asm_inc_or_exp();
|
|
|
3330 if (asm_isint(o1) && asm_isint(o2))
|
|
|
3331 o1.disp = o1.disp && o2.disp;
|
|
|
3332 else {
|
|
|
3333 asmerr(EM_bad_integral_operand); // illegal operand
|
|
|
3334 }
|
|
|
3335 o2.disp = 0;
|
|
|
3336 o1 = asm_merge_opnds(o1, o2);
|
|
|
3337 }
|
|
|
3338 return o1;
|
|
|
3339 }
|
|
|
3340
|
|
|
3341 bool asm_isint(OPND *o)
|
|
|
3342 {
|
|
|
3343 if (!o || o.base || o.s)
|
|
|
3344 return false;
|
|
|
3345
|
|
|
3346 //return o.disp != 0;
|
|
|
3347 return true;
|
|
|
3348 }
|
|
|
3349
|
|
|
3350 /*******************************
|
|
|
3351 * Merge operands o1 and o2 into a single operand.
|
|
|
3352 */
|
|
|
3353
|
|
|
3354 OPND* asm_merge_opnds(OPND* o1, OPND* o2)
|
|
|
3355 {
|
|
|
3356 debug immutable(char)* psz;
|
|
|
3357 debug if (debuga)
|
|
|
3358 {
|
|
|
3359 printf("asm_merge_opnds(o1 = ");
|
|
|
3360 if (o1) asm_output_popnd(o1);
|
|
|
3361 printf(", o2 = ");
|
|
|
3362 if (o2) asm_output_popnd(o2);
|
|
|
3363 printf(")\n");
|
|
|
3364 }
|
|
|
3365
|
|
|
3366 if (!o1)
|
|
|
3367 return o2;
|
|
|
3368 if (!o2)
|
|
|
3369 return o1;
|
|
|
3370 version (EXTRA_DEBUG) {
|
|
|
3371 printf("Combining Operands: mult1 = %d, mult2 = %d",
|
|
|
3372 o1.uchMultiplier, o2.uchMultiplier);
|
|
|
3373 }
|
|
|
3374 /* combine the OPND's disp field */
|
|
|
3375 if (o2.segreg) {
|
|
|
3376 if (o1.segreg) {
|
|
|
3377 debug psz = "o1.segment && o2.segreg".ptr;
|
|
|
3378 goto ILLEGAL_ADDRESS_ERROR;
|
|
|
3379 }
|
|
|
3380 else
|
|
|
3381 o1.segreg = o2.segreg;
|
|
|
3382 }
|
|
|
3383
|
|
|
3384 // combine the OPND's symbol field
|
|
|
3385 if (o1.s && o2.s)
|
|
|
3386 {
|
|
|
3387 debug psz = "o1.s && os.s";
|
|
|
3388 ILLEGAL_ADDRESS_ERROR:
|
|
|
3389 debug printf("Invalid addr because /%s/\n", psz);
|
|
|
3390
|
|
|
3391 asmerr(EM_bad_addr_mode); // illegal addressing mode
|
|
|
3392 }
|
|
|
3393 else if (o2.s)
|
|
|
3394 o1.s = o2.s;
|
|
|
3395 else if (o1.s && o1.s.isTupleDeclaration())
|
|
|
3396 {
|
|
|
3397 TupleDeclaration tup = o1.s.isTupleDeclaration();
|
|
|
3398
|
|
|
3399 size_t index = o2.disp;
|
|
|
3400 if (index >= tup.objects.dim)
|
|
|
3401 error(asmstate.loc, "tuple index %u exceeds %u", index, tup.objects.dim);
|
|
|
3402 else
|
|
|
3403 {
|
|
|
3404 Object o = cast(Object)tup.objects.data[index];
|
|
|
3405 if (auto d = cast(Dsymbol)o)
|
|
|
3406 {
|
|
|
3407 o1.s = d;
|
|
|
3408 return o1;
|
|
|
3409 }
|
|
|
3410 else if (auto e = cast(Expression)o)
|
|
|
3411 {
|
|
|
3412 if (e.op == TOKvar)
|
|
|
3413 {
|
|
|
3414 o1.s = (cast(VarExp)e).var;
|
|
|
3415 return o1;
|
|
|
3416 }
|
|
|
3417 else if (e.op == TOKfunction)
|
|
|
3418 {
|
|
|
3419 o1.s = (cast(FuncExp)e).fd;
|
|
|
3420 return o1;
|
|
|
3421 }
|
|
|
3422 }
|
|
|
3423 error(asmstate.loc, "invalid asm operand %s", o1.s.toChars());
|
|
|
3424 }
|
|
|
3425 }
|
|
|
3426
|
|
|
3427 if (o1.disp && o2.disp)
|
|
|
3428 o1.disp += o2.disp;
|
|
|
3429 else if (o2.disp)
|
|
|
3430 o1.disp = o2.disp;
|
|
|
3431
|
|
|
3432 /* combine the OPND's base field */
|
|
|
3433 if (o1.base !is null && o2.base !is null) {
|
|
|
3434 debug psz = "o1.base != null && o2.base != null".ptr;
|
|
|
3435 goto ILLEGAL_ADDRESS_ERROR;
|
|
|
3436 }
|
|
|
3437 else if (o2.base)
|
|
|
3438 o1.base = o2.base;
|
|
|
3439
|
|
|
3440 /* Combine the displacement register fields */
|
|
|
3441 if (o2.pregDisp1)
|
|
|
3442 {
|
|
|
3443 if (o1.pregDisp2)
|
|
|
3444 {
|
|
|
3445 debug psz = "o2.pregDisp1 && o1.pregDisp2";
|
|
|
3446 goto ILLEGAL_ADDRESS_ERROR;
|
|
|
3447 }
|
|
|
3448 else if (o1.pregDisp1)
|
|
|
3449 {
|
|
|
3450 if (o1.uchMultiplier ||
|
|
|
3451 (o2.pregDisp1.val == _ESP &&
|
|
|
3452 (o2.pregDisp1.ty & _r32) &&
|
|
|
3453 !o2.uchMultiplier))
|
|
|
3454 {
|
|
|
3455 o1.pregDisp2 = o1.pregDisp1;
|
|
|
3456 o1.pregDisp1 = o2.pregDisp1;
|
|
|
3457 }
|
|
|
3458 else
|
|
|
3459 o1.pregDisp2 = o2.pregDisp1;
|
|
|
3460 }
|
|
|
3461 else
|
|
|
3462 o1.pregDisp1 = o2.pregDisp1;
|
|
|
3463 }
|
|
|
3464 if (o2.pregDisp2) {
|
|
|
3465 if (o1.pregDisp2) {
|
|
|
3466 debug psz = "o1.pregDisp2 && o2.pregDisp2";
|
|
|
3467 goto ILLEGAL_ADDRESS_ERROR;
|
|
|
3468 }
|
|
|
3469 else
|
|
|
3470 o1.pregDisp2 = o2.pregDisp2;
|
|
|
3471 }
|
|
|
3472 if (o2.uchMultiplier)
|
|
|
3473 {
|
|
|
3474 if (o1.uchMultiplier)
|
|
|
3475 {
|
|
|
3476 debug psz = "o1.uchMultiplier && o2.uchMultiplier";
|
|
|
3477 goto ILLEGAL_ADDRESS_ERROR;
|
|
|
3478 }
|
|
|
3479 else
|
|
|
3480 o1.uchMultiplier = o2.uchMultiplier;
|
|
|
3481 }
|
|
|
3482 if (o2.ptype && !o1.ptype)
|
|
|
3483 o1.ptype = o2.ptype;
|
|
|
3484 if (o2.bOffset)
|
|
|
3485 o1.bOffset = o2.bOffset;
|
|
|
3486 if (o2.bSeg)
|
|
|
3487 o1.bSeg = o2.bSeg;
|
|
|
3488
|
|
|
3489 if (o2.ajt && !o1.ajt)
|
|
|
3490 o1.ajt = o2.ajt;
|
|
|
3491
|
|
|
3492 opnd_free(o2);
|
|
|
3493 version (EXTRA_DEBUG) {
|
|
|
3494 printf("Result = %d\n", o1.uchMultiplier);
|
|
|
3495 }
|
|
|
3496 debug if (debuga)
|
|
|
3497 { printf("Merged result = /");
|
|
|
3498 asm_output_popnd(o1);
|
|
|
3499 printf("/\n");
|
|
|
3500 }
|
|
|
3501
|
|
|
3502 return o1;
|
|
|
3503 }
|
|
|
3504
|
|
|
3505 opflag_t asm_float_type_size(Type ptype, opflag_t* pusFloat)
|
|
|
3506 {
|
|
|
3507 *pusFloat = 0;
|
|
|
3508
|
|
|
3509 //printf("asm_float_type_size('%s')\n", ptype.toChars());
|
|
|
3510 if (ptype && ptype.isscalar())
|
|
|
3511 {
|
|
|
3512 int sz = cast(int)ptype.size();
|
|
|
3513 if (sz == REALSIZE)
|
|
|
3514 {
|
|
|
3515 *pusFloat = _80;
|
|
|
3516 return 0;
|
|
|
3517 }
|
|
|
3518 switch (sz)
|
|
|
3519 {
|
|
|
3520 case 2:
|
|
|
3521 return _16;
|
|
|
3522 case 4:
|
|
|
3523 return _32;
|
|
|
3524 case 8:
|
|
|
3525 *pusFloat = _64;
|
|
|
3526 return 0;
|
|
|
3527 default:
|
|
|
3528 break;
|
|
|
3529 }
|
|
|
3530 }
|
|
|
3531
|
|
|
3532 *pusFloat = _fanysize;
|
|
|
3533 return _anysize;
|
|
|
3534 }
|
|
|
3535
|
|
|
3536 OPND* asm_inc_or_exp()
|
|
|
3537 {
|
|
|
3538 OPND* o1 = asm_xor_exp();
|
|
|
3539 OPND* o2;
|
|
|
3540
|
|
|
3541 while (tok_value == TOKor)
|
|
|
3542 {
|
|
|
3543 asm_token();
|
|
|
3544 o2 = asm_xor_exp();
|
|
|
3545 if (asm_isint(o1) && asm_isint(o2))
|
|
|
3546 o1.disp |= o2.disp;
|
|
|
3547 else {
|
|
|
3548 asmerr(EM_bad_integral_operand); // illegal operand
|
|
|
3549 }
|
|
|
3550 o2.disp = 0;
|
|
|
3551 o1 = asm_merge_opnds(o1, o2);
|
|
|
3552 }
|
|
|
3553 return o1;
|
|
|
3554 }
|
|
|
3555
|
|
|
3556 OPND* asm_xor_exp()
|
|
|
3557 {
|
|
|
3558 OPND* o1 = asm_and_exp();
|
|
|
3559 OPND* o2;
|
|
|
3560
|
|
|
3561 while (tok_value == TOKxor)
|
|
|
3562 {
|
|
|
3563 asm_token();
|
|
|
3564 o2 = asm_and_exp();
|
|
|
3565 if (asm_isint(o1) && asm_isint(o2))
|
|
|
3566 o1.disp ^= o2.disp;
|
|
|
3567 else {
|
|
|
3568 asmerr(EM_bad_integral_operand); // illegal operand
|
|
|
3569 }
|
|
|
3570 o2.disp = 0;
|
|
|
3571 o1 = asm_merge_opnds(o1, o2);
|
|
|
3572 }
|
|
|
3573 return o1;
|
|
|
3574 }
|
|
|
3575
|
|
|
3576 OPND* asm_and_exp()
|
|
|
3577 {
|
|
|
3578 OPND* o1 = asm_equal_exp();
|
|
|
3579 OPND* o2;
|
|
|
3580
|
|
|
3581 while (tok_value == TOKand)
|
|
|
3582 {
|
|
|
3583 asm_token();
|
|
|
3584 o2 = asm_equal_exp();
|
|
|
3585 if (asm_isint(o1) && asm_isint(o2))
|
|
|
3586 o1.disp &= o2.disp;
|
|
|
3587 else {
|
|
|
3588 asmerr(EM_bad_integral_operand); // illegal operand
|
|
|
3589 }
|
|
|
3590 o2.disp = 0;
|
|
|
3591 o1 = asm_merge_opnds(o1, o2);
|
|
|
3592 }
|
|
|
3593 return o1;
|
|
|
3594 }
|
|
|
3595
|
|
|
3596 OPND* asm_equal_exp()
|
|
|
3597 {
|
|
|
3598 OPND* o1 = asm_rel_exp();
|
|
|
3599 OPND* o2;
|
|
|
3600
|
|
|
3601 while (1)
|
|
|
3602 {
|
|
|
3603 switch (tok_value)
|
|
|
3604 {
|
|
|
3605 case TOKequal:
|
|
|
3606 asm_token();
|
|
|
3607 o2 = asm_rel_exp();
|
|
|
3608 if (asm_isint(o1) && asm_isint(o2))
|
|
|
3609 o1.disp = o1.disp == o2.disp;
|
|
|
3610 else {
|
|
|
3611 asmerr(EM_bad_integral_operand); // illegal operand
|
|
|
3612 }
|
|
|
3613 o2.disp = 0;
|
|
|
3614 o1 = asm_merge_opnds(o1, o2);
|
|
|
3615 break;
|
|
|
3616
|
|
|
3617 case TOKnotequal:
|
|
|
3618 asm_token();
|
|
|
3619 o2 = asm_rel_exp();
|
|
|
3620 if (asm_isint(o1) && asm_isint(o2))
|
|
|
3621 o1.disp = o1.disp != o2.disp;
|
|
|
3622 else {
|
|
|
3623 asmerr(EM_bad_integral_operand);
|
|
|
3624 }
|
|
|
3625 o2.disp = 0;
|
|
|
3626 o1 = asm_merge_opnds(o1, o2);
|
|
|
3627 break;
|
|
|
3628
|
|
|
3629 default:
|
|
|
3630 return o1;
|
|
|
3631 }
|
|
|
3632 }
|
|
|
3633
|
|
|
3634 assert(false);
|
|
|
3635 }
|
|
|
3636
|
|
|
3637 OPND* asm_rel_exp()
|
|
|
3638 {
|
|
|
3639 OPND* o1 = asm_shift_exp();
|
|
|
3640 OPND* o2;
|
|
|
3641
|
|
|
3642 TOK tok_save;
|
|
|
3643
|
|
|
3644 while (1)
|
|
|
3645 {
|
|
|
3646 switch (tok_value)
|
|
|
3647 {
|
|
|
3648 case TOKgt:
|
|
|
3649 case TOKge:
|
|
|
3650 case TOKlt:
|
|
|
3651 case TOKle:
|
|
|
3652 tok_save = tok_value;
|
|
|
3653 asm_token();
|
|
|
3654 o2 = asm_shift_exp();
|
|
|
3655 if (asm_isint(o1) && asm_isint(o2))
|
|
|
3656 {
|
|
|
3657 switch (tok_save)
|
|
|
3658 {
|
|
|
3659 case TOKgt:
|
|
|
3660 o1.disp = o1.disp > o2.disp;
|
|
|
3661 break;
|
|
|
3662 case TOKge:
|
|
|
3663 o1.disp = o1.disp >= o2.disp;
|
|
|
3664 break;
|
|
|
3665 case TOKlt:
|
|
|
3666 o1.disp = o1.disp < o2.disp;
|
|
|
3667 break;
|
|
|
3668 case TOKle:
|
|
|
3669 o1.disp = o1.disp <= o2.disp;
|
|
|
3670 break;
|
|
|
3671 }
|
|
|
3672 }
|
|
|
3673 else
|
|
|
3674 asmerr(EM_bad_integral_operand);
|
|
|
3675 o2.disp = 0;
|
|
|
3676 o1 = asm_merge_opnds(o1, o2);
|
|
|
3677 break;
|
|
|
3678
|
|
|
3679 default:
|
|
|
3680 return o1;
|
|
|
3681 }
|
|
|
3682 }
|
|
|
3683
|
|
|
3684 assert(false);
|
|
|
3685 }
|
|
|
3686
|
|
|
3687 OPND* asm_shift_exp()
|
|
|
3688 {
|
|
|
3689 OPND* o1 = asm_add_exp();
|
|
|
3690 OPND* o2;
|
|
|
3691
|
|
|
3692 int op;
|
|
|
3693 TOK tk;
|
|
|
3694
|
|
|
3695 while (tok_value == TOKshl || tok_value == TOKshr || tok_value == TOKushr)
|
|
|
3696 {
|
|
|
3697 tk = tok_value;
|
|
|
3698 asm_token();
|
|
|
3699 o2 = asm_add_exp();
|
|
|
3700 if (asm_isint(o1) && asm_isint(o2))
|
|
|
3701 { if (tk == TOKshl)
|
|
|
3702 o1.disp <<= o2.disp;
|
|
|
3703 else if (tk == TOKushr)
|
|
|
3704 o1.disp = cast(uint)o1.disp >> o2.disp;
|
|
|
3705 else
|
|
|
3706 o1.disp >>= o2.disp;
|
|
|
3707 }
|
|
|
3708 else
|
|
|
3709 asmerr(EM_bad_integral_operand);
|
|
|
3710 o2.disp = 0;
|
|
|
3711 o1 = asm_merge_opnds(o1, o2);
|
|
|
3712 }
|
|
|
3713 return o1;
|
|
|
3714 }
|
|
|
3715
|
|
|
3716 /*******************************
|
|
|
3717 */
|
|
|
3718
|
|
|
3719 OPND* asm_add_exp()
|
|
|
3720 {
|
|
|
3721 OPND* o1 = asm_mul_exp();
|
|
|
3722 OPND* o2;
|
|
|
3723
|
|
|
3724 while (1)
|
|
|
3725 {
|
|
|
3726 switch (tok_value)
|
|
|
3727 {
|
|
|
3728 case TOKadd:
|
|
|
3729 asm_token();
|
|
|
3730 o2 = asm_mul_exp();
|
|
|
3731 o1 = asm_merge_opnds(o1, o2);
|
|
|
3732 break;
|
|
|
3733
|
|
|
3734 case TOKmin:
|
|
|
3735 asm_token();
|
|
|
3736 o2 = asm_mul_exp();
|
|
|
3737 if (asm_isint(o1) && asm_isint(o2))
|
|
|
3738 {
|
|
|
3739 o1.disp -= o2.disp;
|
|
|
3740 o2.disp = 0;
|
|
|
3741 }
|
|
|
3742 else
|
|
|
3743 o2.disp = - o2.disp;
|
|
|
3744 o1 = asm_merge_opnds(o1, o2);
|
|
|
3745 break;
|
|
|
3746
|
|
|
3747 default:
|
|
|
3748 return o1;
|
|
|
3749 }
|
|
|
3750 }
|
|
|
3751
|
|
|
3752 assert(false);
|
|
|
3753 }
|
|
|
3754
|
|
|
3755 /*******************************
|
|
|
3756 */
|
|
|
3757
|
|
|
3758 OPND* asm_mul_exp()
|
|
|
3759 {
|
|
|
3760 OPND* o1;
|
|
|
3761 OPND* o2;
|
|
|
3762 OPND* popndTmp;
|
|
|
3763
|
|
|
3764 //printf("+asm_mul_exp()\n");
|
|
|
3765 o1 = asm_br_exp();
|
|
|
3766 while (1)
|
|
|
3767 {
|
|
|
3768 switch (tok_value)
|
|
|
3769 {
|
|
|
3770 case TOKmul:
|
|
|
3771 asm_token();
|
|
|
3772 o2 = asm_br_exp();
|
|
|
3773 version (EXTRA_DEBUG) {
|
|
|
3774 printf("Star o1.isint=%d, o2.isint=%d, lbra_seen=%d\n",
|
|
|
3775 asm_isint(o1), asm_isint(o2), asm_TKlbra_seen );
|
|
|
3776 }
|
|
|
3777 if (asm_isNonZeroInt(o1) && asm_isNonZeroInt(o2))
|
|
|
3778 o1.disp *= o2.disp;
|
|
|
3779 else if (asm_TKlbra_seen && o1.pregDisp1 && asm_isNonZeroInt(o2))
|
|
|
3780 {
|
|
|
3781 o1.uchMultiplier = o2.disp;
|
|
|
3782 version (EXTRA_DEBUG) {
|
|
|
3783 printf("Multiplier: %d\n", o1.uchMultiplier);
|
|
|
3784 }
|
|
|
3785 }
|
|
|
3786 else if (asm_TKlbra_seen && o2.pregDisp1 && asm_isNonZeroInt(o1))
|
|
|
3787 {
|
|
|
3788 popndTmp = o2;
|
|
|
3789 o2 = o1;
|
|
|
3790 o1 = popndTmp;
|
|
|
3791 o1.uchMultiplier = o2.disp;
|
|
|
3792 version (EXTRA_DEBUG) {
|
|
|
3793 printf("Multiplier: %d\n",
|
|
|
3794 o1.uchMultiplier);
|
|
|
3795 }
|
|
|
3796 }
|
|
|
3797 else if (asm_isint(o1) && asm_isint(o2))
|
|
|
3798 o1.disp *= o2.disp;
|
|
|
3799 else
|
|
|
3800 asmerr(EM_bad_operand);
|
|
|
3801 o2.disp = 0;
|
|
|
3802 o1 = asm_merge_opnds(o1, o2);
|
|
|
3803 break;
|
|
|
3804
|
|
|
3805 case TOKdiv:
|
|
|
3806 asm_token();
|
|
|
3807 o2 = asm_br_exp();
|
|
|
3808 if (asm_isint(o1) && asm_isint(o2))
|
|
|
3809 o1.disp /= o2.disp;
|
|
|
3810 else
|
|
|
3811 asmerr(EM_bad_integral_operand);
|
|
|
3812 o2.disp = 0;
|
|
|
3813 o1 = asm_merge_opnds(o1, o2);
|
|
|
3814 break;
|
|
|
3815
|
|
|
3816 case TOKmod:
|
|
|
3817 asm_token();
|
|
|
3818 o2 = asm_br_exp();
|
|
|
3819 if (asm_isint(o1) && asm_isint(o2))
|
|
|
3820 o1.disp %= o2.disp;
|
|
|
3821 else
|
|
|
3822 asmerr(EM_bad_integral_operand);
|
|
|
3823 o2.disp = 0;
|
|
|
3824 o1 = asm_merge_opnds(o1, o2);
|
|
|
3825 break;
|
|
|
3826
|
|
|
3827 default:
|
|
|
3828 return o1;
|
|
|
3829 }
|
|
|
3830 }
|
|
|
3831
|
|
|
3832 return o1;
|
|
|
3833 }
|
|
|
3834
|
|
|
3835 OPND* asm_br_exp()
|
|
|
3836 {
|
|
|
3837 //printf("asm_br_exp()\n");
|
|
|
3838
|
|
|
3839 OPND* o1 = asm_una_exp();
|
|
|
3840 OPND* o2;
|
|
|
3841 Declaration s;
|
|
|
3842
|
|
|
3843 while (1)
|
|
|
3844 {
|
|
|
3845 switch (tok_value)
|
|
|
3846 {
|
|
|
3847 case TOKlbracket:
|
|
|
3848 {
|
|
|
3849 version (EXTRA_DEBUG) {
|
|
|
3850 printf("Saw a left bracket\n");
|
|
|
3851 }
|
|
|
3852 asm_token();
|
|
|
3853 asm_TKlbra_seen++;
|
|
|
3854 o2 = asm_cond_exp();
|
|
|
3855 asm_TKlbra_seen--;
|
|
|
3856 asm_chktok(TOKrbracket,EM_rbra);
|
|
|
3857 version (EXTRA_DEBUG) {
|
|
|
3858 printf("Saw a right bracket\n");
|
|
|
3859 }
|
|
|
3860 o1 = asm_merge_opnds(o1, o2);
|
|
|
3861 if (tok_value == TOKidentifier)
|
|
|
3862 { o2 = asm_una_exp();
|
|
|
3863 o1 = asm_merge_opnds(o1, o2);
|
|
|
3864 }
|
|
|
3865 break;
|
|
|
3866 }
|
|
|
3867 default:
|
|
|
3868 return o1;
|
|
|
3869 }
|
|
|
3870 }
|
|
|
3871
|
|
|
3872 assert(false);
|
|
|
3873 }
|
|
|
3874
|
|
|
3875 /*******************************
|
|
|
3876 */
|
|
|
3877
|
|
|
3878 OPND* asm_una_exp()
|
|
|
3879 {
|
|
|
3880 OPND* o1;
|
|
|
3881 int op;
|
|
|
3882 Type ptype;
|
|
|
3883 Type ptypeSpec;
|
|
|
3884 ASM_JUMPTYPE ajt = ASM_JUMPTYPE_UNSPECIFIED;
|
|
|
3885 char bPtr = 0;
|
|
|
3886
|
|
|
3887 switch (cast(int)tok_value)
|
|
|
3888 {
|
|
|
3889 static if (false) {
|
|
|
3890 case TOKand:
|
|
|
3891 asm_token();
|
|
|
3892 o1 = asm_una_exp();
|
|
|
3893 break;
|
|
|
3894
|
|
|
3895 case TOKmul:
|
|
|
3896 asm_token();
|
|
|
3897 o1 = asm_una_exp();
|
|
|
3898 ++o1.indirect;
|
|
|
3899 break;
|
|
|
3900 }
|
|
|
3901 case TOKadd:
|
|
|
3902 asm_token();
|
|
|
3903 o1 = asm_una_exp();
|
|
|
3904 break;
|
|
|
3905
|
|
|
3906 case TOKmin:
|
|
|
3907 asm_token();
|
|
|
3908 o1 = asm_una_exp();
|
|
|
3909 if (asm_isint(o1))
|
|
|
3910 o1.disp = -o1.disp;
|
|
|
3911 break;
|
|
|
3912
|
|
|
3913 case TOKnot:
|
|
|
3914 asm_token();
|
|
|
3915 o1 = asm_una_exp();
|
|
|
3916 if (asm_isint(o1))
|
|
|
3917 o1.disp = !o1.disp;
|
|
|
3918 break;
|
|
|
3919
|
|
|
3920 case TOKtilde:
|
|
|
3921 asm_token();
|
|
|
3922 o1 = asm_una_exp();
|
|
|
3923 if (asm_isint(o1))
|
|
|
3924 o1.disp = ~o1.disp;
|
|
|
3925 break;
|
|
|
3926
|
|
|
3927 static if (false) {
|
|
|
3928 case TOKlparen:
|
|
|
3929 // stoken() is called directly here because we really
|
|
|
3930 // want the INT token to be an INT.
|
|
|
3931 stoken();
|
|
|
3932 if (type_specifier(&ptypeSpec)) /* if type_name */
|
|
|
3933 {
|
|
|
3934 ptype = declar_abstract(ptypeSpec);
|
|
|
3935 /* read abstract_declarator */
|
|
|
3936 fixdeclar(ptype);/* fix declarator */
|
|
|
3937 type_free(ptypeSpec);/* the declar() function
|
|
|
3938 allocates the typespec again */
|
|
|
3939 chktok(TOKrparen,EM_rpar);
|
|
|
3940 ptype.Tcount--;
|
|
|
3941 goto CAST_REF;
|
|
|
3942 }
|
|
|
3943 else
|
|
|
3944 {
|
|
|
3945 type_free(ptypeSpec);
|
|
|
3946 o1 = asm_cond_exp();
|
|
|
3947 chktok(TOKrparen, EM_rpar);
|
|
|
3948 }
|
|
|
3949 break;
|
|
|
3950 }
|
|
|
3951
|
|
|
3952 case TOKidentifier:
|
|
|
3953 // Check for offset keyword
|
|
|
3954 if (asmtok.ident == Id.offset)
|
|
|
3955 {
|
|
|
3956 if (!global.params.useDeprecated)
|
|
|
3957 error(asmstate.loc, "offset deprecated, use offsetof");
|
|
|
3958 goto Loffset;
|
|
|
3959 }
|
|
|
3960 if (asmtok.ident == Id.offsetof)
|
|
|
3961 {
|
|
|
3962 Loffset:
|
|
|
3963 asm_token();
|
|
|
3964 o1 = asm_cond_exp();
|
|
|
3965 if (!o1)
|
|
|
3966 o1 = opnd_calloc();
|
|
|
3967 o1.bOffset= true;
|
|
|
3968 }
|
|
|
3969 else
|
|
|
3970 o1 = asm_primary_exp();
|
|
|
3971 break;
|
|
|
3972
|
|
|
3973 case ASMTK.ASMTKseg:
|
|
|
3974 asm_token();
|
|
|
3975 o1 = asm_cond_exp();
|
|
|
3976 if (!o1)
|
|
|
3977 o1 = opnd_calloc();
|
|
|
3978 o1.bSeg= true;
|
|
|
3979 break;
|
|
|
3980
|
|
|
3981 case TOKint16:
|
|
|
3982 if (asmstate.ucItype != ITjump)
|
|
|
3983 {
|
|
|
3984 ptype = Type.tint16;
|
|
|
3985 goto TYPE_REF;
|
|
|
3986 }
|
|
|
3987 ajt = ASM_JUMPTYPE_SHORT;
|
|
|
3988 asm_token();
|
|
|
3989 goto JUMP_REF2;
|
|
|
3990
|
|
|
3991 case ASMTKnear:
|
|
|
3992 ajt = ASM_JUMPTYPE_NEAR;
|
|
|
3993 goto JUMP_REF;
|
|
|
3994
|
|
|
3995 case ASMTKfar:
|
|
|
3996 ajt = ASM_JUMPTYPE_FAR;
|
|
|
3997 JUMP_REF:
|
|
|
3998 asm_token();
|
|
|
3999 asm_chktok(cast(TOK) ASMTKptr, EM_ptr_exp);
|
|
|
4000 JUMP_REF2:
|
|
|
4001 o1 = asm_cond_exp();
|
|
|
4002 if (!o1)
|
|
|
4003 o1 = opnd_calloc();
|
|
|
4004 o1.ajt= ajt;
|
|
|
4005 break;
|
|
|
4006
|
|
|
4007 case TOKint8:
|
|
|
4008 ptype = Type.tint8;
|
|
|
4009 goto TYPE_REF;
|
|
|
4010 case TOKint32:
|
|
|
4011 case ASMTKdword:
|
|
|
4012 ptype = Type.tint32;
|
|
|
4013 goto TYPE_REF;
|
|
|
4014 case TOKfloat32:
|
|
|
4015 ptype = Type.tfloat32;
|
|
|
4016 goto TYPE_REF;
|
|
|
4017 case ASMTKqword:
|
|
|
4018 case TOKfloat64:
|
|
|
4019 ptype = Type.tfloat64;
|
|
|
4020 goto TYPE_REF;
|
|
|
4021 case TOKfloat80:
|
|
|
4022 ptype = Type.tfloat80;
|
|
|
4023 goto TYPE_REF;
|
|
|
4024 case ASMTKword:
|
|
|
4025 ptype = Type.tint16;
|
|
|
4026 TYPE_REF:
|
|
|
4027 bPtr = 1;
|
|
|
4028 asm_token();
|
|
|
4029 asm_chktok(cast(TOK) ASMTKptr, EM_ptr_exp);
|
|
|
4030 CAST_REF:
|
|
|
4031 o1 = asm_cond_exp();
|
|
|
4032 if (!o1)
|
|
|
4033 o1 = opnd_calloc();
|
|
|
4034 o1.ptype = ptype;
|
|
|
4035 o1.bPtr = bPtr;
|
|
|
4036 break;
|
|
|
4037
|
|
|
4038 default:
|
|
|
4039 o1 = asm_primary_exp();
|
|
|
4040 break;
|
|
|
4041 }
|
|
|
4042 return o1;
|
|
|
4043 }
|
|
|
4044
|
|
|
4045 bool asm_isNonZeroInt(OPND* o)
|
|
|
4046 {
|
|
|
4047 if (!o || o.base || o.s)
|
|
|
4048 return false;
|
|
|
4049
|
|
|
4050 return o.disp != 0;
|
|
|
4051 }
|
|
|
4052
|
|
|
4053 OPND* asm_primary_exp()
|
|
|
4054 {
|
|
|
4055 OPND* o1 = null;
|
|
|
4056 OPND* o2 = null;
|
|
|
4057 Type ptype;
|
|
|
4058 Dsymbol s;
|
|
|
4059 Dsymbol scopesym;
|
|
|
4060
|
|
|
4061 TOK tkOld;
|
|
|
4062 int global;
|
|
|
4063 REG* regp;
|
|
|
4064
|
|
|
4065 global = 0;
|
|
|
4066 switch (cast(int)tok_value)
|
|
|
4067 {
|
|
|
4068 case TOKdollar:
|
|
|
4069 o1 = opnd_calloc();
|
|
|
4070 o1.s = asmstate.psDollar;
|
|
|
4071 asm_token();
|
|
|
4072 break;
|
|
|
4073
|
|
|
4074 static if (false) {
|
|
|
4075 case TOKthis:
|
|
|
4076 strcpy(tok.TKid,cpp_name_this);
|
|
|
4077 }
|
|
|
4078 case TOKidentifier:
|
|
|
4079 case_ident:
|
|
|
4080 o1 = opnd_calloc();
|
|
|
4081 regp = asm_reg_lookup(asmtok.ident.toChars());
|
|
|
4082 if (regp !is null)
|
|
|
4083 {
|
|
|
4084 asm_token();
|
|
|
4085 // see if it is segment override (like SS:)
|
|
|
4086 if (!asm_TKlbra_seen &&
|
|
|
4087 (regp.ty & _seg) &&
|
|
|
4088 tok_value == TOKcolon)
|
|
|
4089 {
|
|
|
4090 o1.segreg = regp;
|
|
|
4091 asm_token();
|
|
|
4092 o2 = asm_cond_exp();
|
|
|
4093 o1 = asm_merge_opnds(o1, o2);
|
|
|
4094 }
|
|
|
4095 else if (asm_TKlbra_seen)
|
|
|
4096 { // should be a register
|
|
|
4097 if (o1.pregDisp1)
|
|
|
4098 asmerr(EM_bad_operand);
|
|
|
4099 else
|
|
|
4100 o1.pregDisp1 = regp;
|
|
|
4101 }
|
|
|
4102 else
|
|
|
4103 { if (o1.base == null)
|
|
|
4104 o1.base = regp;
|
|
|
4105 else
|
|
|
4106 asmerr(EM_bad_operand);
|
|
|
4107 }
|
|
|
4108 break;
|
|
|
4109 }
|
|
|
4110 // If floating point instruction and id is a floating register
|
|
|
4111 else if (asmstate.ucItype == ITfloat &&
|
|
|
4112 asm_is_fpreg(asmtok.ident.toChars()))
|
|
|
4113 {
|
|
|
4114 asm_token();
|
|
|
4115 if (tok_value == TOKlparen)
|
|
|
4116 {
|
|
|
4117 uint n;
|
|
|
4118
|
|
|
4119 asm_token();
|
|
|
4120 asm_chktok(TOKint32v, EM_num);
|
|
|
4121 n = cast(uint)asmtok.uns64value;
|
|
|
4122 if (n > 7)
|
|
|
4123 asmerr(EM_bad_operand);
|
|
|
4124 o1.base = &(aregFp[n]);
|
|
|
4125 asm_chktok(TOKrparen, EM_rpar);
|
|
|
4126 }
|
|
|
4127 else
|
|
|
4128 o1.base = ®Fp;
|
|
|
4129 }
|
|
|
4130 else
|
|
|
4131 {
|
|
|
4132 if (asmstate.ucItype == ITjump)
|
|
|
4133 {
|
|
|
4134 s = null;
|
|
|
4135 if (asmstate.sc.func.labtab)
|
|
|
4136 s = asmstate.sc.func.labtab.lookup(asmtok.ident);
|
|
|
4137 if (!s)
|
|
|
4138 s = asmstate.sc.search(Loc(0), asmtok.ident, &scopesym);
|
|
|
4139 if (!s)
|
|
|
4140 { // Assume it is a label, and define that label
|
|
|
4141 s = asmstate.sc.func.searchLabel(asmtok.ident);
|
|
|
4142 }
|
|
|
4143 }
|
|
|
4144 else
|
|
|
4145 s = asmstate.sc.search(Loc(0), asmtok.ident, &scopesym);
|
|
|
4146
|
|
|
4147 if (!s)
|
|
|
4148 asmerr(EM_undefined, asmtok.toChars());
|
|
|
4149
|
|
|
4150 Identifier id = asmtok.ident;
|
|
|
4151 asm_token();
|
|
|
4152 if (tok_value == TOKdot)
|
|
|
4153 {
|
|
|
4154 Expression e;
|
|
|
4155 VarExp v;
|
|
|
4156
|
|
|
4157 e = new IdentifierExp(asmstate.loc, id);
|
|
|
4158 while (1)
|
|
|
4159 {
|
|
|
4160 asm_token();
|
|
|
4161 if (tok_value == TOKidentifier)
|
|
|
4162 {
|
|
|
4163 e = new DotIdExp(asmstate.loc, e, asmtok.ident);
|
|
|
4164 asm_token();
|
|
|
4165 if (tok_value != TOKdot)
|
|
|
4166 break;
|
|
|
4167 }
|
|
|
4168 else
|
|
|
4169 {
|
|
|
4170 asmerr(EM_ident_exp);
|
|
|
4171 break;
|
|
|
4172 }
|
|
|
4173 }
|
|
|
4174 e = e.semantic(asmstate.sc);
|
|
|
4175 e = e.optimize(WANTvalue | WANTinterpret);
|
|
|
4176 if (e.isConst())
|
|
|
4177 {
|
|
|
4178 if (e.type.isintegral())
|
|
|
4179 {
|
|
|
4180 o1.disp = cast(int)e.toInteger();
|
|
|
4181 goto Lpost;
|
|
|
4182 }
|
|
|
4183 else if (e.type.isreal())
|
|
|
4184 {
|
|
|
4185 o1.real_ = e.toReal();
|
|
|
4186 o1.ptype = e.type;
|
|
|
4187 goto Lpost;
|
|
|
4188 }
|
|
|
4189 else
|
|
|
4190 {
|
|
|
4191 asmerr(EM_bad_op, e.toChars());
|
|
|
4192 }
|
|
|
4193 }
|
|
|
4194 else if (e.op == TOKvar)
|
|
|
4195 {
|
|
|
4196 v = cast(VarExp)e;
|
|
|
4197 s = v.var;
|
|
|
4198 }
|
|
|
4199 else
|
|
|
4200 {
|
|
|
4201 asmerr(EM_bad_op, e.toChars());
|
|
|
4202 }
|
|
|
4203 }
|
|
|
4204
|
|
|
4205 asm_merge_symbol(o1,s);
|
|
|
4206
|
|
|
4207 /* This attempts to answer the question: is
|
|
|
4208 * char[8] foo;
|
|
|
4209 * of size 1 or size 8? Presume it is 8 if foo
|
|
|
4210 * is the last token of the operand.
|
|
|
4211 */
|
|
|
4212 if (o1.ptype && tok_value != TOKcomma && tok_value != TOKeof)
|
|
|
4213 {
|
|
|
4214 for (;
|
|
|
4215 o1.ptype.ty == Tsarray;
|
|
|
4216 o1.ptype = o1.ptype.nextOf())
|
|
|
4217 {
|
|
|
4218 ;
|
|
|
4219 }
|
|
|
4220 }
|
|
|
4221
|
|
|
4222 Lpost:
|
|
|
4223 static if (false) {
|
|
|
4224 // for []
|
|
|
4225 if (tok_value == TOKlbracket)
|
|
|
4226 o1 = asm_prim_post(o1);
|
|
|
4227 }
|
|
|
4228 goto Lret;
|
|
|
4229 }
|
|
|
4230 break;
|
|
|
4231
|
|
|
4232 case TOKint32v:
|
|
|
4233 case TOKuns32v:
|
|
|
4234 o1 = opnd_calloc();
|
|
|
4235 o1.disp = asmtok.int32value;
|
|
|
4236 asm_token();
|
|
|
4237 break;
|
|
|
4238
|
|
|
4239 case TOKfloat32v:
|
|
|
4240 o1 = opnd_calloc();
|
|
|
4241 o1.real_ = asmtok.float80value;
|
|
|
4242 o1.ptype = Type.tfloat32;
|
|
|
4243 asm_token();
|
|
|
4244 break;
|
|
|
4245
|
|
|
4246 case TOKfloat64v:
|
|
|
4247 o1 = opnd_calloc();
|
|
|
4248 o1.real_ = asmtok.float80value;
|
|
|
4249 o1.ptype = Type.tfloat64;
|
|
|
4250 asm_token();
|
|
|
4251 break;
|
|
|
4252
|
|
|
4253 case TOKfloat80v:
|
|
|
4254 o1 = opnd_calloc();
|
|
|
4255 o1.real_ = asmtok.float80value;
|
|
|
4256 o1.ptype = Type.tfloat80;
|
|
|
4257 asm_token();
|
|
|
4258 break;
|
|
|
4259
|
|
|
4260 case ASMTKlocalsize:
|
|
|
4261 o1 = opnd_calloc();
|
|
|
4262 o1.s = asmstate.psLocalsize;
|
|
|
4263 o1.ptype = Type.tint32;
|
|
|
4264 asm_token();
|
|
|
4265 break;
|
|
|
4266
|
|
|
4267 default:
|
|
|
4268 break; ///
|
|
|
4269 }
|
|
|
4270 Lret:
|
|
|
4271 return o1;
|
|
|
4272 }
|
|
|
4273
|
|
|
4274 void asm_merge_symbol(OPND* o1, Dsymbol s)
|
|
|
4275 {
|
|
|
4276 Type ptype;
|
|
|
4277 VarDeclaration v;
|
|
|
4278 EnumMember em;
|
|
|
4279
|
|
|
4280 //printf("asm_merge_symbol(s = %s %s)\n", s.kind(), s.toChars());
|
|
|
4281 s = s.toAlias();
|
|
|
4282 //printf("s = %s %s\n", s.kind(), s.toChars());
|
|
|
4283 if (s.isLabel())
|
|
|
4284 {
|
|
|
4285 o1.s = s;
|
|
|
4286 return;
|
|
|
4287 }
|
|
|
4288
|
|
|
4289 v = s.isVarDeclaration();
|
|
|
4290 if (v)
|
|
|
4291 {
|
|
|
4292 if (v.isParameter())
|
|
|
4293 asmstate.statement.refparam = true;
|
|
|
4294
|
|
|
4295 v.checkNestedReference(asmstate.sc, asmstate.loc);
|
|
|
4296 static if (false) {
|
|
|
4297 if (!v.isDataseg() && v.parent != asmstate.sc.parent && v.parent)
|
|
|
4298 {
|
|
|
4299 asmerr(EM_uplevel, v.toChars());
|
|
|
4300 }
|
|
|
4301 }
|
|
|
4302 if (v.storage_class & STCfield)
|
|
|
4303 {
|
|
|
4304 o1.disp += v.offset;
|
|
|
4305 goto L2;
|
|
|
4306 }
|
|
|
4307 if ((v.isConst()
|
|
|
4308 ///version (DMDV2) {
|
|
|
4309 || v.isInvariant() || v.storage_class & STCmanifest
|
|
|
4310 ///}
|
|
|
4311 ) && !v.type.isfloating() && v.init)
|
|
|
4312 {
|
|
|
4313 ExpInitializer ei = v.init.isExpInitializer();
|
|
|
4314
|
|
|
4315 if (ei)
|
|
|
4316 {
|
|
|
4317 o1.disp = cast(int)ei.exp.toInteger();
|
|
|
4318 return;
|
|
|
4319 }
|
|
|
4320 }
|
|
|
4321 }
|
|
|
4322 em = s.isEnumMember();
|
|
|
4323 if (em)
|
|
|
4324 {
|
|
|
4325 o1.disp = cast(int)em.value.toInteger();
|
|
|
4326 return;
|
|
|
4327 }
|
|
|
4328 o1.s = s; // a C identifier
|
|
|
4329 L2:
|
|
|
4330 Declaration d = s.isDeclaration();
|
|
|
4331 if (!d)
|
|
|
4332 {
|
|
|
4333 asmerr("%s %s is not a declaration", s.kind(), s.toChars());
|
|
|
4334 }
|
|
|
4335 else if (d.getType())
|
|
|
4336 asmerr(EM_type_as_operand, d.getType().toChars());
|
|
|
4337 else if (d.isTupleDeclaration()) {
|
|
|
4338 ;
|
|
|
4339 } else
|
|
|
4340 o1.ptype = d.type.toBasetype();
|
|
|
4341 }
|
|
|
4342
|
|
|
4343 REG[63] regtab =
|
|
|
4344 [
|
|
|
4345 {"AL", _AL, _r8 | _al,},
|
|
|
4346 {"AH", _AH, _r8,},
|
|
|
4347 {"AX", _AX, _r16 | _ax,},
|
|
|
4348 {"EAX", _EAX, _r32 | _eax,},
|
|
|
4349 {"BL", _BL, _r8,},
|
|
|
4350 {"BH", _BH, _r8,},
|
|
|
4351 {"BX", _BX, _r16,},
|
|
|
4352 {"EBX", _EBX, _r32,},
|
|
|
4353 {"CL", _CL, _r8 | _cl,},
|
|
|
4354 {"CH", _CH, _r8,},
|
|
|
4355 {"CX", _CX, _r16,},
|
|
|
4356 {"ECX", _ECX, _r32,},
|
|
|
4357 {"DL", _DL, _r8,},
|
|
|
4358 {"DH", _DH, _r8,},
|
|
|
4359 {"DX", _DX, _r16 | _dx,},
|
|
|
4360 {"EDX", _EDX, _r32,},
|
|
|
4361 {"BP", _BP, _r16,},
|
|
|
4362 {"EBP", _EBP, _r32,},
|
|
|
4363 {"SP", _SP, _r16,},
|
|
|
4364 {"ESP", _ESP, _r32,},
|
|
|
4365 {"DI", _DI, _r16,},
|
|
|
4366 {"EDI", _EDI, _r32,},
|
|
|
4367 {"SI", _SI, _r16,},
|
|
|
4368 {"ESI", _ESI, _r32,},
|
|
|
4369 {"ES", _ES, _seg | _es,},
|
|
|
4370 {"CS", _CS, _seg | _cs,},
|
|
|
4371 {"SS", _SS, _seg | _ss,},
|
|
|
4372 {"DS", _DS, _seg | _ds,},
|
|
|
4373 {"GS", _GS, _seg | _gs,},
|
|
|
4374 {"FS", _FS, _seg | _fs,},
|
|
|
4375 {"CR0", 0, _special | _crn,},
|
|
|
4376 {"CR2", 2, _special | _crn,},
|
|
|
4377 {"CR3", 3, _special | _crn,},
|
|
|
4378 {"CR4", 4, _special | _crn,},
|
|
|
4379 {"DR0", 0, _special | _drn,},
|
|
|
4380 {"DR1", 1, _special | _drn,},
|
|
|
4381 {"DR2", 2, _special | _drn,},
|
|
|
4382 {"DR3", 3, _special | _drn,},
|
|
|
4383 {"DR4", 4, _special | _drn,},
|
|
|
4384 {"DR5", 5, _special | _drn,},
|
|
|
4385 {"DR6", 6, _special | _drn,},
|
|
|
4386 {"DR7", 7, _special | _drn,},
|
|
|
4387 {"TR3", 3, _special | _trn,},
|
|
|
4388 {"TR4", 4, _special | _trn,},
|
|
|
4389 {"TR5", 5, _special | _trn,},
|
|
|
4390 {"TR6", 6, _special | _trn,},
|
|
|
4391 {"TR7", 7, _special | _trn,},
|
|
|
4392 {"MM0", 0, _mm,},
|
|
|
4393 {"MM1", 1, _mm,},
|
|
|
4394 {"MM2", 2, _mm,},
|
|
|
4395 {"MM3", 3, _mm,},
|
|
|
4396 {"MM4", 4, _mm,},
|
|
|
4397 {"MM5", 5, _mm,},
|
|
|
4398 {"MM6", 6, _mm,},
|
|
|
4399 {"MM7", 7, _mm,},
|
|
|
4400 {"XMM0", 0, _xmm,},
|
|
|
4401 {"XMM1", 1, _xmm,},
|
|
|
4402 {"XMM2", 2, _xmm,},
|
|
|
4403 {"XMM3", 3, _xmm,},
|
|
|
4404 {"XMM4", 4, _xmm,},
|
|
|
4405 {"XMM5", 5, _xmm,},
|
|
|
4406 {"XMM6", 6, _xmm,},
|
|
|
4407 {"XMM7", 7, _xmm,},
|
|
|
4408 ];
|
|
|
4409
|
|
|
4410 REG* asm_reg_lookup(string s)
|
|
|
4411 {
|
|
|
4412 //dbg_printf("asm_reg_lookup('%s')\n",s);
|
|
|
4413
|
|
|
4414 for (int i = 0; i < regtab.length; i++)
|
|
|
4415 {
|
|
|
4416 if (regtab[i].regstr[0..min(s.length, $)] == s)
|
|
|
4417 {
|
|
|
4418 return ®tab[i];
|
|
|
4419 }
|
|
|
4420 }
|
|
|
4421
|
|
|
4422 return null;
|
|
|
4423 }
|
|
|
4424
|
|
|
4425 int asm_is_fpreg(string szReg)
|
|
|
4426 {
|
|
|
4427 static if (true) {
|
|
|
4428 return(szReg.length == 2 && szReg[0] == 'S' &&
|
|
|
4429 szReg[1] == 'T');
|
|
|
4430 } else {
|
|
|
4431 return(szReg.length == 2 && (szReg[0] == 's' || szReg[0] == 'S') &&
|
|
|
4432 (szReg[1] == 't' || szReg[1] == 'T'));
|
|
|
4433 }
|
|
|
4434 } |
