dmd.backend.codebuilder source code

1 /**
2  * Compiler implementation of the
3  * $(LINK2 http://www.dlang.org, D programming language).
4  *
5  * Copyright:   Copyright (C) 1985-1998 by Symantec
6  *              Copyright (C) 2000-2020 by The D Language Foundation, All Rights Reserved
7  * Authors:     $(LINK2 http://www.digitalmars.com, Walter Bright)
8  * License:     $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
9  * Source:      $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/backend/codebuilder.d, backend/_codebuilder.d)
10  * Documentation: https://dlang.org/phobos/dmd_backend_codebuilder.html
11  */
12 
13 module dmd.backend.codebuilder;
14 
15 import core.stdc.stdio;
16 import core.stdc.string;
17 
18 import dmd.backend.cc;
19 import dmd.backend.cdef;
20 import dmd.backend.code;
21 import dmd.backend.code_x86;
22 import dmd.backend.mem;
23 import dmd.backend.outbuf;
24 import dmd.backend.ty;
25 import dmd.backend.type;
26 
27 extern (C++) struct CodeBuilder
28 {
29   private:
30 
31     code *head;
32     code **pTail;
33 
34   nothrow:
35   public:
36     //this() { pTail = &head; }
37     //this(code *c);
38 
39     void ctor()
40     {
41         pTail = &head;
42     }
43 
44     void ctor(code* c)
45     {
46         head = c;
47         pTail = c ? &code_last(c).next : &head;
48     }
49 
50     code *finish()
51     {
52         return head;
53     }
54 
55     code *peek() { return head; }       // non-destructively look at the list
56 
57     void reset() { head = null; pTail = &head; }
58 
59     void append(ref CodeBuilder cdb)
60     {
61         if (cdb.head)
62         {
63             *pTail = cdb.head;
64             pTail = cdb.pTail;
65         }
66     }
67 
68     void append(ref CodeBuilder cdb1, ref CodeBuilder cdb2)
69     {
70         append(cdb1);
71         append(cdb2);
72     }
73 
74     void append(ref CodeBuilder cdb1, ref CodeBuilder cdb2, ref CodeBuilder cdb3)
75     {
76         append(cdb1);
77         append(cdb2);
78         append(cdb3);
79     }
80 
81     void append(ref CodeBuilder cdb1, ref CodeBuilder cdb2, ref CodeBuilder cdb3, ref CodeBuilder cdb4)
82     {
83         append(cdb1);
84         append(cdb2);
85         append(cdb3);
86         append(cdb4);
87     }
88 
89     void append(ref CodeBuilder cdb1, ref CodeBuilder cdb2, ref CodeBuilder cdb3, ref CodeBuilder cdb4, ref CodeBuilder cdb5)
90     {
91         append(cdb1);
92         append(cdb2);
93         append(cdb3);
94         append(cdb4);
95         append(cdb5);
96     }
97 
98     void append(code *c)
99     {
100         if (c)
101         {
102             CodeBuilder cdb = void;
103             cdb.ctor(c);
104             append(cdb);
105         }
106     }
107 
108     void gen(code *cs)
109     {
110         /* this is a high usage routine */
111         debug assert(cs);
112         assert(I64 || cs.Irex == 0);
113         code* ce = code_malloc();
114         *ce = *cs;
115         //printf("ce = %p %02x\n", ce, ce.Iop);
116         //code_print(ce);
117         ccheck(ce);
118         simplify_code(ce);
119         ce.next = null;
120 
121         *pTail = ce;
122         pTail = &ce.next;
123     }
124 
125     void gen1(opcode_t op)
126     {
127         code *ce = code_calloc();
128         ce.Iop = op;
129         ccheck(ce);
130         assert(op != LEA);
131 
132         *pTail = ce;
133         pTail = &ce.next;
134     }
135 
136     void gen2(opcode_t op, uint rm)
137     {
138         code *ce = code_calloc();
139         ce.Iop = op;
140         ce.Iea = rm;
141         ccheck(ce);
142 
143         *pTail = ce;
144         pTail = &ce.next;
145     }
146 
147     /***************************************
148      * Generate floating point instruction.
149      */
150     void genf2(opcode_t op, uint rm)
151     {
152         genfwait(this);
153         gen2(op, rm);
154     }
155 
156     void gen2sib(opcode_t op, uint rm, uint sib)
157     {
158         code *ce = code_calloc();
159         ce.Iop = op;
160         ce.Irm = cast(ubyte)rm;
161         ce.Isib = cast(ubyte)sib;
162         ce.Irex = cast(ubyte)((rm | (sib & (REX_B << 16))) >> 16);
163         if (sib & (REX_R << 16))
164             ce.Irex |= REX_X;
165         ccheck(ce);
166 
167         *pTail = ce;
168         pTail = &ce.next;
169     }
170 
171     /********************************
172      * Generate an ASM sequence.
173      */
174     void genasm(char *s, uint slen)
175     {
176         code *ce = code_calloc();
177         ce.Iop = ASM;
178         ce.IFL1 = FLasm;
179         ce.IEV1.len = slen;
180         ce.IEV1.bytes = cast(char *) mem_malloc(slen);
181         memcpy(ce.IEV1.bytes,s,slen);
182 
183         *pTail = ce;
184         pTail = &ce.next;
185     }
186 
187 version (MARS)
188 {
189     void genasm(_LabelDsymbol *label)
190     {
191         code *ce = code_calloc();
192         ce.Iop = ASM;
193         ce.Iflags = CFaddrsize;
194         ce.IFL1 = FLblockoff;
195         ce.IEV1.Vsym = cast(Symbol*)label;
196 
197         *pTail = ce;
198         pTail = &ce.next;
199     }
200 }
201 
202     void genasm(block *label)
203     {
204         code *ce = code_calloc();
205         ce.Iop = ASM;
206         ce.Iflags = CFaddrsize;
207         ce.IFL1 = FLblockoff;
208         ce.IEV1.Vblock = label;
209         label.Bflags |= BFLlabel;
210 
211         *pTail = ce;
212         pTail = &ce.next;
213     }
214 
215     void gencs(opcode_t op, uint ea, uint FL2, Symbol *s)
216     {
217         code cs;
218         cs.Iop = op;
219         cs.Iflags = 0;
220         cs.Iea = ea;
221         ccheck(&cs);
222         cs.IFL2 = cast(ubyte)FL2;
223         cs.IEV2.Vsym = s;
224         cs.IEV2.Voffset = 0;
225 
226         gen(&cs);
227     }
228 
229     void genc2(opcode_t op, uint ea, targ_size_t EV2)
230     {
231         code cs;
232         cs.Iop = op;
233         cs.Iflags = 0;
234         cs.Iea = ea;
235         ccheck(&cs);
236         cs.Iflags = CFoff;
237         cs.IFL2 = FLconst;
238         cs.IEV2.Vsize_t = EV2;
239 
240         gen(&cs);
241     }
242 
243     void genc1(opcode_t op, uint ea, uint FL1, targ_size_t EV1)
244     {
245         code cs;
246         assert(FL1 < FLMAX);
247         cs.Iop = op;
248         cs.Iflags = CFoff;
249         cs.Iea = ea;
250         ccheck(&cs);
251         cs.IFL1 = cast(ubyte)FL1;
252         cs.IEV1.Vsize_t = EV1;
253 
254         gen(&cs);
255     }
256 
257     void genc(opcode_t op, uint ea, uint FL1, targ_size_t EV1, uint FL2, targ_size_t EV2)
258     {
259         code cs;
260         assert(FL1 < FLMAX);
261         cs.Iop = op;
262         cs.Iea = ea;
263         ccheck(&cs);
264         cs.Iflags = CFoff;
265         cs.IFL1 = cast(ubyte)FL1;
266         cs.IEV1.Vsize_t = EV1;
267         assert(FL2 < FLMAX);
268         cs.IFL2 = cast(ubyte)FL2;
269         cs.IEV2.Vsize_t = EV2;
270 
271         gen(&cs);
272     }
273 
274     /********************************
275      * Generate 'instruction' which is actually a line number.
276      */
277     void genlinnum(Srcpos srcpos)
278     {
279         code cs;
280         //srcpos.print("genlinnum");
281         cs.Iop = ESCAPE | ESClinnum;
282         cs.Iflags = 0;
283         cs.Iea = 0;
284         cs.IEV1.Vsrcpos = srcpos;
285         gen(&cs);
286     }
287 
288     /********************************
289      * Generate 'instruction' which tells the address resolver that the stack has
290      * changed.
291      */
292     void genadjesp(int offset)
293     {
294         if (!I16 && offset)
295         {
296             code cs;
297             cs.Iop = ESCAPE | ESCadjesp;
298             cs.Iflags = 0;
299             cs.Iea = 0;
300             cs.IEV1.Vint = offset;
301             gen(&cs);
302         }
303     }
304 
305     /********************************
306      * Generate 'instruction' which tells the scheduler that the fpu stack has
307      * changed.
308      */
309     void genadjfpu(int offset)
310     {
311         if (!I16 && offset)
312         {
313             code cs;
314             cs.Iop = ESCAPE | ESCadjfpu;
315             cs.Iflags = 0;
316             cs.Iea = 0;
317             cs.IEV1.Vint = offset;
318             gen(&cs);
319         }
320     }
321 
322     void gennop()
323     {
324         gen1(NOP);
325     }
326 
327     /**************************
328      * Generate code to deal with floatreg.
329      */
330     void genfltreg(opcode_t opcode,uint reg,targ_size_t offset)
331     {
332         floatreg = true;
333         reflocal = true;
334         if ((opcode & ~7) == 0xD8)
335             genfwait(this);
336         genc1(opcode,modregxrm(2,reg,BPRM),FLfltreg,offset);
337     }
338 
339     void genxmmreg(opcode_t opcode,reg_t xreg,targ_size_t offset, tym_t tym)
340     {
341         assert(isXMMreg(xreg));
342         floatreg = true;
343         reflocal = true;
344         genc1(opcode,modregxrm(2,xreg - XMM0,BPRM),FLfltreg,offset);
345         checkSetVex(last(), tym);
346     }
347 
348     /*****************
349      * Returns:
350      *  code that pTail points to
351      */
352     code *last()
353     {
354         // g++ and clang++ complain about offsetof() because of the code::code() constructor.
355         // return (code *)((char *)pTail - offsetof(code, next));
356         // So do our own.
357         return cast(code *)(cast(void *)pTail - (cast(void*)&(*pTail).next - cast(void*)*pTail));
358     }
359 
360     /*************************************
361      * Handy function to answer the question: who the heck is generating this piece of code?
362      */
363     static void ccheck(code *cs)
364     {
365     //    if (cs.Iop == LEA && (cs.Irm & 0x3F) == 0x34 && cs.Isib == 7) *(char*)0=0;
366     //    if (cs.Iop == 0x31) *(char*)0=0;
367     //    if (cs.Irm == 0x3D) *(char*)0=0;
368     //    if (cs.Iop == LEA && cs.Irm == 0xCB) *(char*)0=0;
369     }
370 }