dmsc.d at 0c86139 ⋅ dlang/dmd

/**
 * Configures and initializes the backend.
 *
 * Copyright:   Copyright (C) 1999-2020 by The D Language Foundation, All Rights Reserved
 * Authors:     $(LINK2 http://www.digitalmars.com, Walter Bright)
 * License:     $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
 * Source:      $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/dmsc.d, _dmsc.d)
 * Documentation:  https://dlang.org/phobos/dmd_dmsc.html
 * Coverage:    https://codecov.io/gh/dlang/dmd/src/master/src/dmd/dmsc.d
 */

module dmd.dmsc;

import core.stdc.stdio;
import core.stdc.string;
import core.stdc.stddef;

extern (C++):

import dmd.globals;
import dmd.dclass;
import dmd.dmodule;
import dmd.mtype;

import dmd.root.filename;

import dmd.backend.cc;
import dmd.backend.cdef;
import dmd.backend.global;
import dmd.backend.ty;
import dmd.backend.type;

extern (C) void out_config_init(
        int model,      // 32: 32 bit code
                        // 64: 64 bit code
                        // Windows: bit 0 set to generate MS-COFF instead of OMF
        bool exe,       // true: exe file
                        // false: dll or shared library (generate PIC code)
        bool trace,     // add profiling code
        bool nofloat,   // do not pull in floating point code
        bool verbose,   // verbose compile
        bool optimize,  // optimize code
        int symdebug,   // add symbolic debug information
                        // 1: D
                        // 2: fake it with C symbolic debug info
        bool alwaysframe,       // always create standard function frame
        bool stackstomp,        // add stack stomping code
        ubyte avx,              // use AVX instruction set (0, 1, 2)
        PIC pic,                // kind of position independent code
        bool useModuleInfo,     // implement ModuleInfo
        bool useTypeInfo,       // implement TypeInfo
        bool useExceptions,     // implement exception handling
        string _version         // Compiler version
        );

void out_config_debug(
        bool debugb,
        bool debugc,
        bool debugf,
        bool debugr,
        bool debugw,
        bool debugx,
        bool debugy
    );

/**************************************
 * Initialize config variables.
 */

void backend_init()
{
    //printf("out_config_init()\n");
    Param *params = &global.params;

    bool exe;
    if (params.dll || params.pic != PIC.fixed)
    {
    }
    else if (params.run)
        exe = true;         // EXE file only optimizations
    else if (params.link && !params.deffile)
        exe = true;         // EXE file only optimizations
    else if (params.exefile.length &&
             params.exefile.length >= 4 &&
             FileName.equals(FileName.ext(params.exefile), "exe"))
        exe = true;         // if writing out EXE file

    out_config_init(
        (params.is64bit ? 64 : 32) | (params.mscoff ? 1 : 0),
        exe,
        false, //params.trace,
        params.nofloat,
        params.verbose,
        params.optimize,
        params.symdebug,
        params.alwaysframe,
        params.stackstomp,
        params.cpu >= CPU.avx2 ? 2 : params.cpu >= CPU.avx ? 1 : 0,
        params.pic,
        params.useModuleInfo && Module.moduleinfo,
        params.useTypeInfo && Type.dtypeinfo,
        params.useExceptions && ClassDeclaration.throwable,
        global._version
    );

    debug
    {
        out_config_debug(
            params.debugb,
            params.debugc,
            params.debugf,
            params.debugr,
            false,
            params.debugx,
            params.debugy
        );
    }
}


/***********************************
 * Return aligned 'offset' if it is of size 'size'.
 */

targ_size_t _align(targ_size_t size, targ_size_t offset)
{
    switch (size)
    {
        case 1:
            break;
        case 2:
        case 4:
        case 8:
        case 16:
        case 32:
        case 64:
            offset = (offset + size - 1) & ~(size - 1);
            break;
        default:
            if (size >= 16)
                offset = (offset + 15) & ~15;
            else
                offset = (offset + _tysize[TYnptr] - 1) & ~(_tysize[TYnptr] - 1);
            break;
    }
    return offset;
}


/*******************************
 * Get size of ty
 */

targ_size_t size(tym_t ty)
{
    int sz = (tybasic(ty) == TYvoid) ? 1 : tysize(ty);
    debug
    {
        if (sz == -1)
            WRTYxx(ty);
    }
    assert(sz!= -1);
    return sz;
}

/****************************
 * Generate symbol of type ty at DATA:offset
 */

Symbol *symboldata(targ_size_t offset,tym_t ty)
{
    Symbol *s = symbol_generate(SClocstat, type_fake(ty));
    s.Sfl = FLdata;
    s.Soffset = offset;
    s.Stype.Tmangle = mTYman_sys; // writes symbol unmodified in Obj::mangle
    symbol_keep(s);               // keep around
    return s;
}

/**************************************
 */

void backend_term()
{
}

Read our documentation on viewing source code .

1		/**
2		* Configures and initializes the backend.
3		*
4		* Copyright: Copyright (C) 1999-2020 by The D Language Foundation, All Rights Reserved
5		* Authors: $(LINK2 http://www.digitalmars.com, Walter Bright)
6		* License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
7		* Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/dmsc.d, _dmsc.d)
8		* Documentation: https://dlang.org/phobos/dmd_dmsc.html
9		* Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/dmsc.d
10		*/
11
12		module dmd.dmsc;
13
14		import core.stdc.stdio;
15		import core.stdc.string;
16		import core.stdc.stddef;
17
18		extern (C++):
19
20		import dmd.globals;
21		import dmd.dclass;
22		import dmd.dmodule;
23		import dmd.mtype;
24
25		import dmd.root.filename;
26
27		import dmd.backend.cc;
28		import dmd.backend.cdef;
29		import dmd.backend.global;
30		import dmd.backend.ty;
31		import dmd.backend.type;
32
33		extern (C) void out_config_init(
34		int model, // 32: 32 bit code
35		// 64: 64 bit code
36		// Windows: bit 0 set to generate MS-COFF instead of OMF
37		bool exe, // true: exe file
38		// false: dll or shared library (generate PIC code)
39		bool trace, // add profiling code
40		bool nofloat, // do not pull in floating point code
41		bool verbose, // verbose compile
42		bool optimize, // optimize code
43		int symdebug, // add symbolic debug information
44		// 1: D
45		// 2: fake it with C symbolic debug info
46		bool alwaysframe, // always create standard function frame
47		bool stackstomp, // add stack stomping code
48		ubyte avx, // use AVX instruction set (0, 1, 2)
49		PIC pic, // kind of position independent code
50		bool useModuleInfo, // implement ModuleInfo
51		bool useTypeInfo, // implement TypeInfo
52		bool useExceptions, // implement exception handling
53		string _version // Compiler version
54		);
55
56		void out_config_debug(
57		bool debugb,
58		bool debugc,
59		bool debugf,
60		bool debugr,
61		bool debugw,
62		bool debugx,
63		bool debugy
64		);
65
66		/**************************************
67		* Initialize config variables.
68		*/
69
70		void backend_init()
71		{
72		//printf("out_config_init()\n");
73	1	Param *params = &global.params;
74
75	1	bool exe;
76	1	if (params.dll \|\| params.pic != PIC.fixed)
77		{
78		}
79	1	else if (params.run)
80	0	exe = true; // EXE file only optimizations
81	1	else if (params.link && !params.deffile)
82	1	exe = true; // EXE file only optimizations
83	0	else if (params.exefile.length &&
84	0	params.exefile.length >= 4 &&
85	0	FileName.equals(FileName.ext(params.exefile), "exe"))
86	0	exe = true; // if writing out EXE file
87
88	1	out_config_init(
89	1	(params.is64bit ? 64 : 32) \| (params.mscoff ? 1 : 0),
90		exe,
91		false, //params.trace,
92		params.nofloat,
93		params.verbose,
94		params.optimize,
95		params.symdebug,
96		params.alwaysframe,
97		params.stackstomp,
98	1	params.cpu >= CPU.avx2 ? 2 : params.cpu >= CPU.avx ? 1 : 0,
99		params.pic,
100	1	params.useModuleInfo && Module.moduleinfo,
101	1	params.useTypeInfo && Type.dtypeinfo,
102	1	params.useExceptions && ClassDeclaration.throwable,
103		global._version
104		);
105
106		debug
107		{
108	1	out_config_debug(
109		params.debugb,
110		params.debugc,
111		params.debugf,
112		params.debugr,
113		false,
114		params.debugx,
115		params.debugy
116		);
117		}
118		}
119
120
121		/***********************************
122		* Return aligned 'offset' if it is of size 'size'.
123		*/
124
125		targ_size_t _align(targ_size_t size, targ_size_t offset)
126		{
127	1	switch (size)
128		{
129	1	case 1:
130	1	break;
131	1	case 2:
132	1	case 4:
133	1	case 8:
134	1	case 16:
135	1	case 32:
136	1	case 64:
137	1	offset = (offset + size - 1) & ~(size - 1);
138	1	break;
139	1	default:
140	1	if (size >= 16)
141	1	offset = (offset + 15) & ~15;
142		else
143	1	offset = (offset + _tysize[TYnptr] - 1) & ~(_tysize[TYnptr] - 1);
144	1	break;
145		}
146	1	return offset;
147		}
148
149
150		/*******************************
151		* Get size of ty
152		*/
153
154		targ_size_t size(tym_t ty)
155		{
156	1	int sz = (tybasic(ty) == TYvoid) ? 1 : tysize(ty);
157		debug
158		{
159	1	if (sz == -1)
160	0	WRTYxx(ty);
161		}
162	1	assert(sz!= -1);
163	1	return sz;
164		}
165
166		/****************************
167		* Generate symbol of type ty at DATA:offset
168		*/
169
170		Symbol *symboldata(targ_size_t offset,tym_t ty)
171		{
172	1	Symbol *s = symbol_generate(SClocstat, type_fake(ty));
173	1	s.Sfl = FLdata;
174	1	s.Soffset = offset;
175	1	s.Stype.Tmangle = mTYman_sys; // writes symbol unmodified in Obj::mangle
176	1	symbol_keep(s); // keep around
177	1	return s;
178		}
179
180		/**************************************
181		*/
182
183		void backend_term()
184		{
185		}

Navigation	Overlay
`t` Navigate files	`h` Toggle hits
`y` Change url to tip of branch	`m` Toggle misses
`b / v` Jump to prev/next hit line	`p` Toggle partial
`z / x` Jump to prev/next missed or partial line	`1..9` Toggle flags
`shift + o` Open current page in GitHub	`a` Toggle all on
`/ or ?` Show keyboard shortcuts dialog	`c` Toggle context lines or commits