mirrors/dmd
1
0
Fork 0
mirror of https://github.com/dlang/dmd.git synced 2025-04-26 13:10:12 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions 5

Use selective imports when importing from core.stdc in rt (#20742)

Browse source
This commit is contained in:
Jonas Meeuws 2025-01-20 21:12:30 +01:00 • committed by GitHub
parent 5a02544ea3
commit 2ecfa63ce7
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
21 changed files with 171 additions and 195 deletions
Download patch file Download diff file Expand all files Collapse all files

7
druntime/src/rt/adi.d
View file

@ -11,12 +11,9 @@
module rt.adi;
//debug=adi; // uncomment to turn on debugging printf's
// debug = adi; // uncomment to turn on debugging printf's
private
{
debug(adi) import core.stdc.stdio;
}
debug (adi) import core.stdc.stdio : printf;
/***************************************
* Support for array equality test.

12
druntime/src/rt/arraycat.d
View file

@ -10,12 +10,12 @@
module rt.arraycat;
private
{
import core.stdc.string;
import core.internal.util.array;
debug(PRINTF) import core.stdc.stdio;
}
// debug = PRINTF;
import core.internal.util.array;
import core.stdc.string : memcpy;
debug(PRINTF) import core.stdc.stdio : printf;
extern (C) @trusted nothrow:

4
druntime/src/rt/cmath2.d
View file

@ -14,7 +14,9 @@
*/
module rt.cmath2;
import core.stdc.math;
import core.stdc.math : fabs;
debug import core.stdc.stdio : printf;
extern (C):

50
druntime/src/rt/cover.d
View file

@ -11,25 +11,29 @@
module rt.cover;
import core.internal.utf;
import core.internal.util.math : max, min;
import core.stdc.stdio : EOF, fclose, fgetc, FILE, fileno, fprintf, fread, fseek, ftell, printf, SEEK_END, SEEK_SET,
stderr;
import core.stdc.stdlib : exit, EXIT_FAILURE;
version (Windows)
{
import core.stdc.stdio : _fdopen, _get_osfhandle, _O_BINARY, _O_CREAT, _O_RDWR, _S_IREAD, _S_IWRITE, _wopen;
import core.sys.windows.basetsd;
import core.sys.windows.winbase;
}
else version (Posix)
{
import core.stdc.stdio : fopen;
import core.sys.posix.fcntl : O_CREAT, O_RDWR, open, S_IRGRP, S_IROTH, S_IRUSR, S_IWGRP, S_IWOTH, S_IWUSR;
import core.sys.posix.unistd : F_LOCK, ftruncate, lockf;
}
else
static assert(0, "Unsupported platform");
private
{
version (Windows)
{
import core.sys.windows.basetsd /+: HANDLE+/;
import core.sys.windows.winbase /+: LOCKFILE_EXCLUSIVE_LOCK, LockFileEx, OVERLAPPED, SetEndOfFile+/;
}
else version (Posix)
{
import core.sys.posix.fcntl : O_CREAT, O_RDWR, open, S_IRGRP, S_IROTH, S_IRUSR, S_IWGRP, S_IWOTH, S_IWUSR;
import core.sys.posix.unistd : F_LOCK, ftruncate, lockf;
}
import core.internal.utf;
import core.stdc.config : c_long;
import core.stdc.stdio;
import core.stdc.stdlib;
struct BitArray
{
size_t len;
@ -321,14 +325,14 @@ shared static ~this()
version (Windows)
SetEndOfFile(handle(fileno(flst)));
else
else version (Posix)
ftruncate(fileno(flst), ftell(flst));
}
}
uint digits(uint number)
{
import core.stdc.math;
import core.stdc.math : floor, log10;
return number ? cast(uint)floor(log10(number)) + 1 : 1;
}
@ -457,16 +461,14 @@ string chomp( string str, string delim = null )
// open/create file for read/write, pointer at beginning
FILE* openOrCreateFile(string name)
{
import core.internal.utf : toUTF16z;
version (Windows)
immutable fd = _wopen(toUTF16z(name), _O_RDWR | _O_CREAT | _O_BINARY, _S_IREAD | _S_IWRITE);
else
else version (Posix)
immutable fd = open((name ~ '\0').ptr, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP |
S_IROTH | S_IWOTH);
version (CRuntime_Microsoft)
alias fdopen = _fdopen;
version (Posix)
else version (Posix)
import core.sys.posix.stdio : fdopen;
return fdopen(fd, "r+b");
}
@ -492,8 +494,6 @@ void lockFile(int fd)
// exclusively lock first byte
LockFileEx(handle(fd), LOCKFILE_EXCLUSIVE_LOCK, 0, 1, 0, &off);
}
else
static assert(0, "unimplemented");
}
bool readFile(FILE* file, ref char[] buf)
@ -520,11 +520,9 @@ version (Windows) extern (C) nothrow @nogc FILE* _wfopen(scope const wchar* file
bool readFile(string name, ref char[] buf)
{
import core.internal.utf : toUTF16z;
version (Windows)
auto file = _wfopen(toUTF16z(name), "rb"w.ptr);
else
else version (Posix)
auto file = fopen((name ~ '\0').ptr, "rb".ptr);
if (file is null) return false;
scope(exit) fclose(file);

3
druntime/src/rt/deh_win32.d
View file

@ -17,7 +17,8 @@ import core.sys.windows.basetsd /+: ULONG_PTR+/;
import core.sys.windows.windef /+: BOOL, BYTE, DWORD+/;
import core.sys.windows.winnt /+: PVOID+/;
import rt.monitor_;
//import core.stdc.stdio;
debug import core.stdc.stdio : printf;
version (D_InlineAsm_X86)
{

36
druntime/src/rt/dmain2.d
View file

@ -11,22 +11,24 @@
module rt.dmain2;
import core.atomic;
import core.internal.parseoptions : rt_parseOption;
import core.stdc.errno : errno;
import core.stdc.stdio : fflush, fprintf, fwrite, stderr, stdout;
import core.stdc.stdlib : alloca, EXIT_FAILURE, EXIT_SUCCESS, free, malloc, realloc;
import core.stdc.string : strerror;
import rt.config : rt_cmdline_enabled, rt_configOption;
import rt.memory;
import rt.sections;
import core.atomic;
import core.stdc.stddef;
import core.stdc.stdlib;
import core.stdc.string;
import core.stdc.stdio; // for printf()
import core.stdc.errno : errno;
version (Windows)
{
import core.stdc.wchar_;
import core.stdc.stdio : fileno;
import core.stdc.wchar_ : wcslen;
import core.sys.windows.basetsd : HANDLE;
import core.sys.windows.shellapi : CommandLineToArgvW;
import core.sys.windows.winbase : FreeLibrary, GetCommandLineW, GetProcAddress,
IsDebuggerPresent, LoadLibraryW, LocalFree, WriteFile;
import core.sys.windows.winbase : FreeLibrary, GetCommandLineW, GetProcAddress, IsDebuggerPresent, LoadLibraryW,
LocalFree, WriteFile;
import core.sys.windows.wincon : CONSOLE_SCREEN_BUFFER_INFO, GetConsoleOutputCP,
GetConsoleScreenBufferInfo;
import core.sys.windows.winnls : CP_UTF8, MultiByteToWideChar, WideCharToMultiByte;
@ -34,19 +36,12 @@ version (Windows)
import core.sys.windows.winuser : MB_ICONERROR, MessageBoxW;
pragma(lib, "shell32.lib"); // needed for CommandLineToArgvW
}
version (FreeBSD)
{
import core.stdc.fenv;
import core.stdc.stdio : _get_osfhandle;
}
version (NetBSD)
else version (Posix)
{
import core.stdc.fenv;
}
version (DragonFlyBSD)
{
import core.stdc.fenv;
import core.stdc.string : strlen;
}
// not sure why we can't define this in one place, but this is to keep this
@ -444,7 +439,6 @@ private extern (C) int _d_run_main2(char[][] args, size_t totalArgsLength, MainF
char[][] argsCopy = buff[0 .. args.length];
auto argBuff = cast(char*) (buff + args.length);
size_t j = 0;
import rt.config : rt_cmdline_enabled;
bool parseOpts = rt_cmdline_enabled!();
foreach (arg; args)
{
@ -587,8 +581,6 @@ private void formatThrowable(Throwable t, scope void delegate(in char[] s) nothr
private auto parseExceptionOptions()
{
import rt.config : rt_configOption;
import core.internal.parseoptions : rt_parseOption;
const optName = "trapExceptions";
auto option = rt_configOption(optName);
auto trap = rt_trapExceptions;

17
druntime/src/rt/dwarfeh.d
View file

@ -11,14 +11,14 @@
module rt.dwarfeh;
// debug = EH_personality;
version (Posix):
import rt.dmain2: _d_print_throwable;
// debug = EH_personality;
import core.internal.backtrace.unwind;
import core.stdc.stdio;
import core.stdc.stdlib;
import core.stdc.stdio : fprintf, printf, stderr;
import core.stdc.stdlib : abort, calloc, free;
import rt.dmain2 : _d_print_throwable;
/* These are the register numbers for _Unwind_SetGR().
* Hints for these can be found by looking at the EH_RETURN_DATA_REGNO macro in
@ -125,7 +125,8 @@ debug (EH_personality)
{
private void writeln(in char* format, ...) @nogc nothrow
{
import core.stdc.stdarg;
import core.stdc.stdarg : va_list, va_start;
import core.stdc.stdio : fflush, stdout, vfprintf;
va_list args;
va_start(args, format);
@ -181,7 +182,7 @@ struct ExceptionHeader
auto eh = &ehstorage;
if (eh.object) // if in use
{
eh = cast(ExceptionHeader*)core.stdc.stdlib.calloc(1, ExceptionHeader.sizeof);
eh = cast(ExceptionHeader*).calloc(1, ExceptionHeader.sizeof);
if (!eh)
terminate(__LINE__); // out of memory while throwing - not much else can be done
}
@ -204,7 +205,7 @@ struct ExceptionHeader
*/
*eh = ExceptionHeader.init;
if (eh != &ehstorage)
core.stdc.stdlib.free(eh);
.free(eh);
}
/*************************

5
druntime/src/rt/ehalloc.d
View file

@ -13,10 +13,7 @@ module rt.ehalloc;
//debug = PRINTF;
debug(PRINTF)
{
import core.stdc.stdio;
}
debug (PRINTF) import core.stdc.stdio : printf;
/********************************************

41
druntime/src/rt/lifetime.d
View file

@ -13,11 +13,17 @@
module rt.lifetime;
import core.attribute : weak;
import core.memory;
import core.checkedint : mulu;
import core.exception : onFinalizeError, onOutOfMemoryError, onUnicodeError;
import core.internal.gc.blockmeta : PAGESIZE;
debug(PRINTF) import core.stdc.stdio;
import core.memory;
import core.stdc.stdlib : malloc;
import core.stdc.string : memcpy, memset;
static import rt.tlsgc;
debug (PRINTF) import core.stdc.stdio : printf;
debug (VALGRIND) import etc.valgrind.valgrind;
alias BlkInfo = GC.BlkInfo;
alias BlkAttr = GC.BlkAttr;
@ -81,8 +87,6 @@ Returns: newly created object
*/
extern (C) Object _d_newclass(const ClassInfo ci) @weak
{
import core.stdc.stdlib;
import core.exception : onOutOfMemoryError;
void* p;
auto init = ci.initializer;
@ -268,7 +272,6 @@ extern(C) void _d_arrayshrinkfit(const TypeInfo ti, void[] arr) nothrow
}
catch (Exception e)
{
import core.exception : onFinalizeError;
onFinalizeError(sti, e);
}
}
@ -336,9 +339,6 @@ in
}
do
{
import core.stdc.string;
import core.exception : onOutOfMemoryError;
auto isshared = typeid(ti) is typeid(TypeInfo_Shared);
auto tinext = unqualify(ti.next);
auto size = tinext.tsize;
@ -368,8 +368,6 @@ do
}
else
{
import core.checkedint : mulu;
bool overflow = false;
size_t reqsize = mulu(size, newcapacity, overflow);
if (!overflow)
@ -444,8 +442,6 @@ Returns: newly allocated array
*/
extern (C) void[] _d_newarrayU(const scope TypeInfo ti, size_t length) pure nothrow @weak
{
import core.exception : onOutOfMemoryError;
auto tinext = unqualify(ti.next);
auto size = tinext.tsize;
@ -475,8 +471,6 @@ extern (C) void[] _d_newarrayU(const scope TypeInfo ti, size_t length) pure noth
}
else
{
import core.checkedint : mulu;
bool overflow = false;
size = mulu(size, length, overflow);
if (!overflow)
@ -497,8 +491,6 @@ Lcontinue:
/// ditto
extern (C) void[] _d_newarrayT(const TypeInfo ti, size_t length) pure nothrow @weak
{
import core.stdc.string;
void[] result = _d_newarrayU(ti, length);
auto tinext = unqualify(ti.next);
auto size = tinext.tsize;
@ -533,7 +525,6 @@ extern (C) void[] _d_newarrayiT(const TypeInfo ti, size_t length) pure nothrow @
default:
{
import core.stdc.string;
immutable sz = init.length;
for (size_t u = 0; u < size * length; u += sz)
memcpy(result.ptr + u, init.ptr, sz);
@ -650,8 +641,6 @@ extern (C) int rt_hasFinalizerInSegment(void* p, size_t size, uint attr, scope c
return false;
}
debug (VALGRIND) import etc.valgrind.valgrind;
void finalize_array(void* p, size_t size, const TypeInfo_Struct si)
{
// Due to the fact that the delete operator calls destructors
@ -676,7 +665,6 @@ void finalize_struct(void* p, TypeInfo_Struct ti) nothrow
}
catch (Exception e)
{
import core.exception : onFinalizeError;
onFinalizeError(ti, e);
}
}
@ -717,7 +705,6 @@ extern (C) void rt_finalize2(void* p, bool det = true, bool resetMemory = true)
}
catch (Exception e)
{
import core.exception : onFinalizeError;
onFinalizeError(*pc, e);
}
finally
@ -760,7 +747,6 @@ extern (C) void rt_finalizeFromGC(void* p, size_t size, uint attr) nothrow
}
catch (Exception e)
{
import core.exception : onFinalizeError;
onFinalizeError(si, e);
}
}
@ -801,9 +787,6 @@ in
}
do
{
import core.stdc.string;
import core.exception : onOutOfMemoryError;
debug(PRINTF)
{
//printf("_d_arraysetlengthT(p = %p, sizeelem = %d, newlength = %d)\n", p, sizeelem, newlength);
@ -848,7 +831,6 @@ do
}
else
{
import core.checkedint : mulu;
const size_t newsize = mulu(sizeelem, newlength, overflow);
}
if (overflow)
@ -911,9 +893,6 @@ in
}
do
{
import core.stdc.string;
import core.exception : onOutOfMemoryError;
debug(PRINTF)
{
//printf("_d_arraysetlengthT(p = %p, sizeelem = %d, newlength = %d)\n", p, sizeelem, newlength);
@ -958,7 +937,6 @@ do
}
else
{
import core.checkedint : mulu;
const size_t newsize = mulu(sizeelem, newlength, overflow);
}
if (overflow)
@ -1111,8 +1089,6 @@ Returns: `px` after being appended to
extern (C)
byte[] _d_arrayappendcTX(const TypeInfo ti, return scope ref byte[] px, size_t n) @weak
{
import core.stdc.string;
import core.exception : onOutOfMemoryError;
// This is a cut&paste job from _d_arrayappendT(). Should be refactored.
// Short circuit if no data is being appended.
@ -1218,7 +1194,6 @@ extern (C) void[] _d_arrayappendcd(ref byte[] x, dchar c) @weak
}
else
{
import core.exception : onUnicodeError;
onUnicodeError("Invalid UTF-8 sequence", 0); // invalid utf character
}

12
druntime/src/rt/minfo.d
View file

@ -12,10 +12,13 @@
module rt.minfo;
import core.stdc.stdlib; // alloca
import core.stdc.string; // memcpy
import core.stdc.stdio : fprintf, stderr;
import core.stdc.stdlib : free, malloc, realloc;
import core.stdc.string : memcpy, memset;
import rt.sections;
debug (printModuleDependencies) import core.stdc.stdio : printf;
enum
{
MIctorstart = 0x1, // we've started constructing it
@ -179,7 +182,6 @@ struct ModuleGroup
switch (cycleHandling) with(OnCycle)
{
case "deprecate":
import core.stdc.stdio : fprintf, stderr;
// Option deprecated in 2.101, remove in 2.111
fprintf(stderr, "`--DRT-oncycle=deprecate` is no longer supported, using `abort` instead\n");
break;
@ -202,8 +204,6 @@ struct ModuleGroup
debug (printModuleDependencies)
{
import core.stdc.stdio : printf;
foreach (_m; _modules)
{
printf("%s%s%s:", _m.name.ptr, (_m.flags & MIstandalone)
@ -375,7 +375,6 @@ struct ModuleGroup
case print:
// print the message
buildCycleMessage(idx, midx, (string x) {
import core.stdc.stdio : fprintf, stderr;
fprintf(stderr, "%.*s", cast(int) x.length, x.ptr);
});
// continue on as if this is correct.
@ -518,7 +517,6 @@ struct ModuleGroup
!doSort(MItlsctor | MItlsdtor, _tlsctors))
{
// print a warning
import core.stdc.stdio : fprintf, stderr;
fprintf(stderr, "Deprecation 16211 warning:\n"
~ "A cycle has been detected in your program that was undetected prior to DMD\n"
~ "2.072. This program will continue, but will not operate when using DMD 2.074\n"

37
druntime/src/rt/monitor_.d
View file

@ -8,7 +8,26 @@
*/
module rt.monitor_;
import core.atomic, core.stdc.stdlib, core.stdc.string;
import core.atomic;
import core.stdc.stdlib : calloc, free, realloc;
import core.stdc.string : memmove;
version (Windows)
{
import core.sys.windows.winbase /+: CRITICAL_SECTION, DeleteCriticalSection,
EnterCriticalSection, InitializeCriticalSection, LeaveCriticalSection+/;
}
else version (Posix)
{
import core.sys.posix.pthread : pthread_mutex_destroy, pthread_mutex_init, pthread_mutex_lock,
PTHREAD_MUTEX_RECURSIVE, pthread_mutex_unlock, pthread_mutexattr_destroy, pthread_mutexattr_init,
pthread_mutexattr_settype;
import core.sys.posix.sys.types : pthread_mutex_t, pthread_mutexattr_t;
}
else
{
static assert(0, "Unsupported platform");
}
// NOTE: The dtor callback feature is only supported for monitors that are not
// supplied by the user. The assumption is that any object with a user-
@ -173,9 +192,6 @@ alias DEvent = void delegate(Object);
version (Windows)
{
import core.sys.windows.winbase /+: CRITICAL_SECTION, DeleteCriticalSection,
EnterCriticalSection, InitializeCriticalSection, LeaveCriticalSection+/;
alias Mutex = CRITICAL_SECTION;
alias initMutex = InitializeCriticalSection;
@ -185,11 +201,6 @@ version (Windows)
}
else version (Posix)
{
import core.sys.posix.pthread : pthread_mutex_destroy, pthread_mutex_init, pthread_mutex_lock,
PTHREAD_MUTEX_RECURSIVE, pthread_mutex_unlock, pthread_mutexattr_destroy, pthread_mutexattr_init,
pthread_mutexattr_settype;
import core.sys.posix.sys.types : pthread_mutex_t, pthread_mutexattr_t;
@nogc:
alias Mutex = pthread_mutex_t;
__gshared pthread_mutexattr_t gattr;
@ -214,10 +225,6 @@ else version (Posix)
pthread_mutex_unlock(mtx) && assert(0);
}
}
else
{
static assert(0, "Unsupported platform");
}
struct Monitor
{
@ -229,6 +236,8 @@ struct Monitor
private:
__gshared Mutex gmtx;
@property ref shared(Monitor*) monitor(return scope Object h) pure nothrow @nogc
{
return *cast(shared Monitor**)&h.__monitor;
@ -244,8 +253,6 @@ void setMonitor(Object h, shared(Monitor)* m) pure @nogc
atomicStore!(MemoryOrder.rel)(h.monitor, m);
}
__gshared Mutex gmtx;
shared(Monitor)* ensureMonitor(Object h)
{
if (auto m = getMonitor(h))

8
druntime/src/rt/msvc_math.d
View file

@ -15,7 +15,7 @@ module rt.msvc_math;
version (CRuntime_Microsoft):
version (X86):
import core.stdc.math;
import cmath = core.stdc.math;
extern(C):
@trusted:
@ -24,11 +24,11 @@ nothrow:
mixin template AltImpl(string baseName)
{
mixin("float _msvc_"~baseName~"f(float x) { return cast(float) "~baseName~"(x); }");
mixin("float _msvc_"~baseName~"f(float x) { return cast(float) cmath."~baseName~"(x); }");
}
mixin template AltImpl2(string baseName)
{
mixin("float _msvc_"~baseName~"f(float x, float y) { return cast(float) "~baseName~"(x, y); }");
mixin("float _msvc_"~baseName~"f(float x, float y) { return cast(float) cmath."~baseName~"(x, y); }");
}
mixin AltImpl!"acos";
@ -53,7 +53,7 @@ mixin AltImpl2!"fmod";
float _msvc_modff(float value, float* iptr)
{
double di;
const result = cast(float) modf(value, &di);
const result = cast(float) cmath.modf(value, &di);
*iptr = cast(float) di;
return result;
}

7
druntime/src/rt/profilegc.d
View file

@ -15,10 +15,9 @@ module rt.profilegc;
private:
import core.stdc.errno;
import core.stdc.stdio;
import core.stdc.stdlib;
import core.stdc.string;
import core.stdc.errno : errno;
import core.stdc.stdio : fclose, FILE, fopen, fprintf, snprintf, stderr, stdout;
import core.stdc.stdlib : free, malloc, qsort, realloc;
import core.exception : onOutOfMemoryError;
import core.internal.container.hashtab;

30
druntime/src/rt/sections_elf_shared.d
View file

@ -20,18 +20,26 @@ else version (CRuntime_UClibc) enum SharedELF = true;
else enum SharedELF = false;
static if (SharedELF):
// debug = PRINTF;
version (MIPS32) version = MIPS_Any;
version (MIPS64) version = MIPS_Any;
version (RISCV32) version = RISCV_Any;
version (RISCV64) version = RISCV_Any;
// debug = PRINTF;
import core.internal.container.array;
import core.internal.container.hashtab;
import core.internal.elf.dl;
import core.memory;
import core.stdc.config;
import core.stdc.stdio;
import core.stdc.stdlib : calloc, exit, EXIT_FAILURE, free, malloc;
import core.stdc.string : strlen;
import core.stdc.config : c_ulong;
import core.stdc.stdlib : calloc, free;
import core.sys.posix.pthread : pthread_mutex_destroy, pthread_mutex_init, pthread_mutex_lock, pthread_mutex_unlock;
import core.sys.posix.sys.types : pthread_mutex_t;
import rt.deh;
import rt.dmain2;
import rt.minfo;
import rt.util.utility : safeAssert;
version (linux)
{
import core.sys.linux.dlfcn : Dl_info, dladdr, dlclose, dlinfo, dlopen, RTLD_DI_LINKMAP, RTLD_LAZY, RTLD_NOLOAD;
@ -60,14 +68,8 @@ else
{
static assert(0, "unimplemented");
}
import core.internal.container.array;
import core.internal.container.hashtab;
import core.sys.posix.pthread : pthread_mutex_destroy, pthread_mutex_init, pthread_mutex_lock, pthread_mutex_unlock;
import core.sys.posix.sys.types : pthread_mutex_t;
import rt.deh;
import rt.dmain2;
import rt.minfo;
import rt.util.utility : safeAssert;
debug (PRINTF) import core.stdc.stdio : printf;
alias DSO SectionGroup;
struct DSO
@ -203,7 +205,7 @@ version (Shared)
// interface for core.thread to inherit loaded libraries
void* pinLoadedLibraries() nothrow @nogc
{
auto res = cast(Array!(ThreadDSO)*)calloc(1, Array!(ThreadDSO).sizeof);
auto res = cast(Array!(ThreadDSO)*).calloc(1, Array!(ThreadDSO).sizeof);
res.length = _loadedDSOs.length;
foreach (i, ref tdso; _loadedDSOs)
{

10
druntime/src/rt/sections_osx_x86.d
View file

@ -24,11 +24,12 @@ version (Darwin):
version (X86):
// debug = PRINTF;
import core.internal.container.array;
import core.stdc.stdint : intptr_t;
import core.stdc.stdio;
import core.stdc.stdlib;
import core.stdc.string;
import core.stdc.stdio : fprintf, perror, stderr;
import core.stdc.stdlib : calloc, free, malloc;
import core.stdc.string : memcpy;
import core.sys.darwin.mach.dyld : _dyld_register_func_for_add_image;
import core.sys.darwin.mach.getsect : getsectbynamefromheader;
import core.sys.darwin.mach.loader : mach_header, MH_MAGIC, SECT_BSS, SECT_COMMON, SECT_DATA, SEG_DATA;
@ -37,6 +38,8 @@ import core.sys.posix.pthread : pthread_getspecific, pthread_key_create, pthread
import rt.deh;
import rt.minfo;
debug (PRINTF) import core.stdc.stdio : printf;
struct SectionGroup
{
static int opApply(scope int delegate(ref SectionGroup) dg)
@ -169,7 +172,6 @@ ref void[] getTLSBlock() nothrow @nogc
pary = cast(void[]*).calloc(1, (void[]).sizeof);
if (pthread_setspecific(_tlsKey, pary) != 0)
{
import core.stdc.stdio;
perror("pthread_setspecific failed with");
assert(0);
}

12
druntime/src/rt/sections_osx_x86_64.d
View file

@ -24,19 +24,19 @@ version (Darwin):
version (X86_64):
// debug = PRINTF;
import core.stdc.stdio;
import core.stdc.stdlib;
import core.stdc.string;
import core.stdc.stdint : intptr_t;
import core.sys.darwin.mach.dyld : _dyld_register_func_for_add_image;
import core.sys.darwin.mach.getsect : mach_header;
import core.internal.container.array;
import core.stdc.stdint : intptr_t;
import core.stdc.stdio : fprintf, stderr;
import core.sys.darwin.mach.dyld : _dyld_register_func_for_add_image;
import core.sys.darwin.mach.getsect : mach_header;
import rt.deh;
import rt.minfo;
import rt.sections_darwin_64;
import rt.util.utility : safeAssert;
debug (PRINTF) import core.stdc.stdio : printf;
struct SectionGroup
{
static int opApply(scope int delegate(ref SectionGroup) dg)

12
druntime/src/rt/sections_solaris.d
View file

@ -15,20 +15,18 @@
module rt.sections_solaris;
version (Solaris)
{
version = SolarisOrOpenBSD;
}
else version (OpenBSD)
{
version = SolarisOrOpenBSD;
}
version (SolarisOrOpenBSD):
// debug = PRINTF;
debug(PRINTF) import core.stdc.stdio;
import core.stdc.stdlib : malloc, free;
import rt.deh, rt.minfo;
import rt.deh;
import rt.minfo;
debug (PRINTF) import core.stdc.stdio : printf;
struct SectionGroup
{

34
druntime/src/rt/sections_win64.d
View file

@ -14,22 +14,22 @@ module rt.sections_win64;
version (CRuntime_Microsoft):
// debug = PRINTF;
debug(PRINTF) import core.stdc.stdio;
import core.memory;
import core.stdc.stdlib : calloc, malloc, free;
import core.sys.windows.winbase : FreeLibrary, GetCurrentThreadId, GetModuleHandleExW,
GetProcAddress, LoadLibraryA, LoadLibraryW,
GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT;
import core.sys.windows.winnt : WCHAR, IMAGE_DOS_HEADER, IMAGE_DOS_SIGNATURE, IMAGE_FILE_HEADER,
IMAGE_NT_HEADERS, IMAGE_SECTION_HEADER, IMAGE_TLS_DIRECTORY, IMAGE_DIRECTORY_ENTRY_TLS;
import core.sys.windows.threadaux;
import core.thread;
import rt.deh, rt.minfo;
import core.internal.container.array;
version (DigitalMars) version (Win64) version = hasEHTables;
// debug = PRINTF;
import core.internal.container.array;
import core.memory;
import core.stdc.stdlib : calloc, free, malloc;
import core.sys.windows.threadaux;
import core.sys.windows.winbase : FreeLibrary, GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, GetModuleHandleExW, GetProcAddress, LoadLibraryA, LoadLibraryW;
import core.sys.windows.winnt : IMAGE_DIRECTORY_ENTRY_TLS, IMAGE_DOS_HEADER, IMAGE_DOS_SIGNATURE, IMAGE_NT_HEADERS, IMAGE_SECTION_HEADER, IMAGE_TLS_DIRECTORY, WCHAR;
import core.thread;
import rt.deh;
import rt.minfo;
debug (PRINTF) import core.stdc.stdio : printf;
struct SectionGroup
{
static int opApply(scope int delegate(ref SectionGroup) dg)
@ -93,7 +93,7 @@ void initSections() nothrow @nogc
void initSections(void* handle) nothrow @nogc
{
auto sectionGroup = cast(SectionGroup*)calloc(1, SectionGroup.sizeof);
auto sectionGroup = cast(SectionGroup*).calloc(1, SectionGroup.sizeof);
sectionGroup._moduleGroup = ModuleGroup(getModuleInfos(handle));
sectionGroup._handle = handle;
version (hasEHTables)
@ -124,7 +124,7 @@ void initSections(void* handle) nothrow @nogc
if (conservative)
{
sectionGroup._gcRanges = (cast(void[]*) malloc((void[]).sizeof))[0..1];
sectionGroup._gcRanges = (cast(void[]*).malloc((void[]).sizeof))[0..1];
sectionGroup._gcRanges[0] = dataSection;
}
else
@ -134,7 +134,7 @@ void initSections(void* handle) nothrow @nogc
debug(PRINTF) printf("found .dp section: [%p,+%llx]\n", dpSection.ptr,
cast(ulong)dpSection.length);
auto dp = cast(uint[]) dpSection;
auto ranges = cast(void[]*) malloc(dp.length * (void[]).sizeof);
auto ranges = cast(void[]*).malloc(dp.length * (void[]).sizeof);
size_t r = 0;
void* prev = null;
foreach (off; dp)

9
druntime/src/rt/tlsgc.d
View file

@ -13,9 +13,9 @@
*/
module rt.tlsgc;
import core.stdc.stdlib;
static import rt.lifetime, rt.sections;
import core.exception : onOutOfMemoryError;
import core.stdc.stdlib : free, malloc;
static import rt.sections;
/**
* Per thread record to store thread associated data for garbage collection.
@ -32,8 +32,7 @@ struct Data
void* init() nothrow @nogc
{
auto data = cast(Data*).malloc(Data.sizeof);
import core.exception;
if ( data is null ) core.exception.onOutOfMemoryError();
if ( data is null ) onOutOfMemoryError();
*data = Data.init;
// do module specific initialization

18
druntime/src/rt/trace.d
View file

@ -12,13 +12,21 @@
module rt.trace;
import core.demangle;
import core.stdc.ctype;
import core.stdc.stdio;
import core.stdc.stdlib;
import core.stdc.string;
import core.stdc.ctype : isalpha, isgraph, isspace;
import core.stdc.stdio : EOF, fclose, fgetc, FILE, fopen, fprintf, stderr, stdout;
import core.stdc.stdlib : exit, EXIT_FAILURE, free, malloc, qsort, realloc, strtoul;
import core.stdc.string : memcmp, memset, strdup, strlen;
debug import core.stdc.stdio : printf;
version (CRuntime_Microsoft)
private alias core.stdc.stdlib._strtoui64 strtoull;
{
import core.stdc.stdlib : strtoull = _strtoui64;
}
else
{
import core.stdc.stdlib : strtoull;
}
shared static this ()
{

2
druntime/src/rt/tracegc.d
View file

@ -71,7 +71,7 @@ enum accumulator = q{
version (tracegc)
{
import core.stdc.stdio;
import core.stdc.stdio : printf;
printf("%s file = '%.*s' line = %d function = '%.*s' type = %.*s\n",
__FUNCTION__.ptr,