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