GraphViz .dot file

Jump to D main()

src.object_.d.168.__unittest_fail.FiZv

Uses:

• _d_unittestm

src.object_.d.168.__array

Uses:

• _d_array_bounds

src.object_.d.168.__assert.FiZv

Uses:

• _d_assertm

src.object_.d.207.__unittest_fail.FiZv

Uses:

• _d_unittestm

src.object_.d.207.__array

Uses:

• _d_array_bounds

src.object_.d.207.__assert.FiZv

Uses:

• _d_assertm

std.traits.d.1741.__unittest_fail.FiZv

Uses:

• _d_unittestm

std.traits.d.1741.__array

Uses:

• _d_array_bounds

std.traits.d.1741.__assert.FiZv

Uses:

• _d_assertm

src.core.atomic.d.211.__unittest_fail.FiZv

Uses:

• _d_unittestm

src.core.atomic.d.211.__array

Uses:

• _d_array_bounds

src.core.atomic.d.211.__assert.FiZv

Uses:

• _d_assertm

src.core.atomic.d.212.__unittest_fail.FiZv

Uses:

• _d_unittestm

src.core.atomic.d.212.__array

Uses:

• _d_array_bounds

src.core.atomic.d.212.__assert.FiZv

Uses:

• _d_assertm

src.core.atomic.d.214.__unittest_fail.FiZv

Uses:

• _d_unittestm

src.core.atomic.d.214.__array

Uses:

• _d_array_bounds

src.core.atomic.d.214.__assert.FiZv

Uses:

• _d_assertm

src.core.atomic.d.215.__unittest_fail.FiZv

Uses:

• _d_unittestm

src.core.atomic.d.215.__array

Uses:

• _d_array_bounds

src.core.atomic.d.215.__assert.FiZv

Uses:

• _d_assertm

src.rt.typeinfo.ti_Ag.d.1410.__unittest_fail.FiZv

Uses:

• _d_unittestm

src.rt.typeinfo.ti_Ag.d.1410.__array

Uses:

• _d_array_bounds

src.rt.typeinfo.ti_Ag.d.1410.__assert.FiZv

Uses:

• _d_assertm

void gc.gc.__unittest_fail(int)

Uses:

• _d_unittestm

gc.gcx.GC gc.gc._gc

Used by:

• gc_qalloc
• gc_clrAttr
• gc_reserve
• gc_query
• gc_enable
• gc_extend
• gc_malloc
• gc_sizeOf
• gc_calloc
• gc_disable
• gc_isCollecting
• gc_setAttr
• gc_free
• gc_realloc
• gc_addrOf
• gc_removeRange
• gc_init
• gc_collect
• gc_minimize
• gc_term
• gc_getAttr
• gc_removeRoot
• gc_addRoot
• gc_addRange

gc.gc.Proxy* gc.gc.proxy

Used by:

• gc_qalloc
• gc_clrAttr
• gc_reserve
• gc_query
• gc_enable
• gc_extend
• gc_sizeOf
• gc_malloc
• gc_calloc
• gc_disable
• gc_isCollecting
• gc_setAttr
• gc_free
• gc_realloc
• gc_addrOf
• gc_removeRange
• gc_collect
• gc_minimize
• gc_getAttr
• gc_removeRoot
• gc_addRoot
• gc_addRange

gc.gc.Proxy gc.gc.pthis

Used by:

• gc_init

gc.gc.__array

Uses:

• _d_array_bounds

void gc.gc.__assert(int)

Uses:

• _d_assertm

void gc.gcx.__unittest_fail(int)

Uses:

• _d_unittestm

void gc.gcx.GC.freeNoSync(void*)

Used by:

• void* gc.gcx.GC.reallocNoSync(void*, ulong, uint, ulong*)
• void gc.gcx.GC.free(void*)

Uses:

• gc.gcx.Pool* gc.gcx.Gcx.findPool(void*)
• onInvalidMemoryOperationError
• void gc.gcx.Pool.freePages(ulong, ulong)

void gc.gcx.GC.initialize()

Uses:

• onOutOfMemoryError
• TypeInfo_Class gc.gcx.GC.gcLock
• calloc@plt
• rt_stackBottom
• void gc.gcx.GC.setStackBottom(void*)

void gc.gcx.GC.removeRoot(void*)

Uses:

• _d_monitorenter
• thread_needLock
• TypeInfo_Class gc.gcx.GC.gcLock
• _d_monitorexit
• void gc.gcx.Gcx.removeRoot(void*)

void gc.gcx.GC.__invariant()

ulong gc.gcx.GC.fullCollect()

Uses:

• _d_monitorenter
• ulong gc.gcx.Gcx.fullcollectshell()
• TypeInfo_Class gc.gcx.GC.gcLock
• _d_monitorexit

gc.gcx.BlkInfo gc.gcx.GC.queryNoSync(void*)

Uses:

• gc.gcx.BlkInfo gc.gcx.Gcx.getInfo(void*)

void gc.gcx.GC.removeRange(void*)

Uses:

• _d_monitorenter
• void gc.gcx.Gcx.removeRange(void*)
• thread_needLock
• TypeInfo_Class gc.gcx.GC.gcLock
• _d_monitorexit

void* gc.gcx.GC.addrOfNoSync(void*)

Uses:

• void* gc.gcx.Gcx.findBase(void*)

ulong gc.gcx.GC.extendNoSync(void*, ulong, ulong)

Used by:

• ulong gc.gcx.GC.extend(void*, ulong, ulong)

Uses:

• ulong gc.gcx.Gcx.findSize(void*)
• gc.gcx.Pool* gc.gcx.Gcx.findPool(void*)
• ulong gc.gcx.Pool.extendPagesUpTo(ulong)
• memset@plt
• void gc.gcx.Pool.updateOffsets(ulong)
• onInvalidMemoryOperationError

bool gc.gcx.GC.isCollecting(void*)

Uses:

• bool gc.gcx.Gcx.isCollecting(void*)

void* gc.gcx.GC.mallocNoSync(ulong, uint, ulong*)

Used by:

• void* gc.gcx.GC.calloc(ulong, uint, ulong*)
• void* gc.gcx.GC.malloc(ulong, uint, ulong*)
• void* gc.gcx.GC.reallocNoSync(void*, ulong, uint, ulong*)

Uses:

• int gc.gcx.Gcx.allocPage(ubyte)
• gc.gcx.Pool* gc.gcx.Gcx.newPool(ulong, bool)
• ulong gc.gcx.Gcx.fullcollectshell()
• onOutOfMemoryError
• memset@plt
• void* gc.gcx.Gcx.bigAlloc(ulong, gc.gcx.Pool**, ulong*)
• onInvalidMemoryOperationError
• ubyte gc.gcx.Gcx.findBin(ulong)
• void gc.gcx.Gcx.setBits(gc.gcx.Pool*, ulong, uint)

ulong gc.gcx.GC.sizeOfNoSync(void*)

Used by:

• ulong gc.gcx.GC.sizeOf(void*)

Uses:

• ulong gc.gcx.Gcx.findSize(void*)

void* gc.gcx.GC.reallocNoSync(void*, ulong, uint, ulong*)

Used by:

• void* gc.gcx.GC.realloc(void*, ulong, uint, ulong*)

Uses:

• _d_monitorenter
• ulong gc.gcx.Gcx.findSize(void*)
• gc.gcx.Pool* gc.gcx.Gcx.findPool(void*)
• void gc.gcx.Pool.updateOffsets(ulong)
• memset@plt
• onInvalidMemoryOperationError
• void gc.gcx.GC.freeNoSync(void*)
• TypeInfo_Class gc.gcx.GC.gcLock
• void gc.gcx.Pool.freePages(ulong, ulong)
• _d_monitorexit
• void* gc.gcx.GC.mallocNoSync(ulong, uint, ulong*)
• ulong gc.gcx.Pool.extendPages(ulong)
• void gc.gcx.Gcx.setBits(gc.gcx.Pool*, ulong, uint)
• memcpy@plt

void gc.gcx.GC.getStatsNoSync(out gc.gcstats.GCStats)

Used by:

• void gc.gcx.GC.getStats(out gc.gcstats.GCStats)

Uses:

• memset@plt

void gc.gcx.GC.setStackBottom(void*)

Used by:

• void gc.gcx.GC.initialize()

void gc.gcx.GC.fullCollectNoStack()

Uses:

• _d_monitorenter
• ulong gc.gcx.Gcx.fullcollectshell()
• TypeInfo_Class gc.gcx.GC.gcLock
• _d_monitorexit

void gc.gcx.GC.Dtor()

Uses:

• free@plt
• void gc.gcx.Gcx.Dtor()

void gc.gcx.GC.free(void*)

Uses:

• _d_monitorenter
• thread_needLock
• void gc.gcx.GC.freeNoSync(void*)
• TypeInfo_Class gc.gcx.GC.gcLock
• _d_monitorexit

void gc.gcx.GC.check(void*)

Uses:

• _d_monitorenter
• thread_needLock
• TypeInfo_Class gc.gcx.GC.gcLock
• _d_monitorexit

gc.gcx.BlkInfo gc.gcx.GC.query(void*)

Uses:

• _d_monitorenter
• thread_needLock
• TypeInfo_Class gc.gcx.GC.gcLock
• _d_monitorexit

void* gc.gcx.GC.addrOf(void*)

Uses:

• _d_monitorenter
• thread_needLock
• TypeInfo_Class gc.gcx.GC.gcLock
• _d_monitorexit

void* gc.gcx.GC.calloc(ulong, uint, ulong*)

Uses:

• _d_monitorenter
• memset@plt
• TypeInfo_Class gc.gcx.GC.gcLock
• _d_monitorexit
• void* gc.gcx.GC.mallocNoSync(ulong, uint, ulong*)

void gc.gcx.GC.enable()

Uses:

• _d_monitorenter
• thread_needLock
• TypeInfo_Class gc.gcx.GC.gcLock
• _d_monitorexit

ulong gc.gcx.GC.extend(void*, ulong, ulong)

Uses:

• _d_monitorenter
• ulong gc.gcx.GC.extendNoSync(void*, ulong, ulong)
• thread_needLock
• TypeInfo_Class gc.gcx.GC.gcLock
• _d_monitorexit

TypeInfo_Class gc.gcx.GC.gcLock

Used by:

• void* gc.gcx.GC.malloc(ulong, uint, ulong*)
• ulong gc.gcx.GC.sizeOf(void*)
• void gc.gcx.GC.initialize()
• @property int delegate(int delegate(ref void*)) gc.gcx.GC.rootIter()
• void gc.gcx.GC.disable()
• uint gc.gcx.GC.setAttr(void*, uint)
• uint gc.gcx.GC.getAttr(void*)
• void* gc.gcx.GC.realloc(void*, ulong, uint, ulong*)
• void gc.gcx.GC.removeRoot(void*)
• void gc.gcx.GC.check(void*)
• void* gc.gcx.GC.calloc(ulong, uint, ulong*)
• void gc.gcx.GC.fullCollectNoStack()
• uint gc.gcx.GC.clrAttr(void*, uint)
• void gc.gcx.GC.enable()
• void gc.gcx.GC.removeRange(void*)
• void gc.gcx.GC.free(void*)
• void gc.gcx.GC.getStats(out gc.gcstats.GCStats)
• ulong gc.gcx.GC.extend(void*, ulong, ulong)
• void* gc.gcx.GC.reallocNoSync(void*, ulong, uint, ulong*)
• gc.gcx.BlkInfo gc.gcx.GC.query(void*)
• void* gc.gcx.GC.addrOf(void*)
• ulong gc.gcx.GC.fullCollect()
• void gc.gcx.GC.minimize()
• void gc.gcx.GC.addRoot(void*)
• ulong gc.gcx.GC.reserve(ulong)
• void gc.gcx.GC.addRange(void*, ulong)
• @property int delegate(int delegate(ref gc.gcx.Range)) gc.gcx.GC.rangeIter()

void* gc.gcx.GC.malloc(ulong, uint, ulong*)

Uses:

• _d_monitorenter
• TypeInfo_Class gc.gcx.GC.gcLock
• _d_monitorexit
• void* gc.gcx.GC.mallocNoSync(ulong, uint, ulong*)

ulong gc.gcx.GC.sizeOf(void*)

Uses:

• _d_monitorenter
• thread_needLock
• TypeInfo_Class gc.gcx.GC.gcLock
• _d_monitorexit
• ulong gc.gcx.GC.sizeOfNoSync(void*)

gc.gcx.GC.__Class

Used by:

• gc_init

void gc.gcx.GC.addRoot(void*)

Uses:

• _d_monitorenter
• thread_needLock
• void gc.gcx.Gcx.addRoot(void*)
• TypeInfo_Class gc.gcx.GC.gcLock
• _d_monitorexit

uint gc.gcx.GC.clrAttr(void*, uint)

Uses:

• _d_monitorenter
• thread_needLock
• uint gc.gcx.GC.clrAttr(void*, uint).uint go()
• TypeInfo_Class gc.gcx.GC.gcLock
• _d_monitorexit

uint gc.gcx.GC.clrAttr(void*, uint).uint go()

Used by:

• uint gc.gcx.GC.clrAttr(void*, uint)

Uses:

• @property uint gc.gcx.Pool.shiftBy()
• gc.gcx.Pool* gc.gcx.Gcx.findPool(void*)
• uint gc.gcx.Gcx.getBits(gc.gcx.Pool*, ulong)
• void gc.gcx.Gcx.clrBits(gc.gcx.Pool*, ulong, uint)

void gc.gcx.GC.disable()

Uses:

• _d_monitorenter
• thread_needLock
• TypeInfo_Class gc.gcx.GC.gcLock
• _d_monitorexit

uint gc.gcx.GC.getAttr(void*)

Uses:

• uint gc.gcx.GC.getAttr(void*).uint go()
• _d_monitorenter
• thread_needLock
• TypeInfo_Class gc.gcx.GC.gcLock
• _d_monitorexit

uint gc.gcx.GC.getAttr(void*).uint go()

Used by:

• uint gc.gcx.GC.getAttr(void*)

Uses:

• @property uint gc.gcx.Pool.shiftBy()
• gc.gcx.Pool* gc.gcx.Gcx.findPool(void*)
• uint gc.gcx.Gcx.getBits(gc.gcx.Pool*, ulong)

void* gc.gcx.GC.realloc(void*, ulong, uint, ulong*)

Uses:

• _d_monitorenter
• TypeInfo_Class gc.gcx.GC.gcLock
• void* gc.gcx.GC.reallocNoSync(void*, ulong, uint, ulong*)
• _d_monitorexit

ulong gc.gcx.GC.reserve(ulong)

Uses:

• _d_monitorenter
• thread_needLock
• onInvalidMemoryOperationError
• TypeInfo_Class gc.gcx.GC.gcLock
• _d_monitorexit
• ulong gc.gcx.Gcx.reserve(ulong)

uint gc.gcx.GC.setAttr(void*, uint)

Uses:

• _d_monitorenter
• thread_needLock
• TypeInfo_Class gc.gcx.GC.gcLock
• _d_monitorexit
• uint gc.gcx.GC.setAttr(void*, uint).uint go()

uint gc.gcx.GC.setAttr(void*, uint).uint go()

Used by:

• uint gc.gcx.GC.setAttr(void*, uint)

Uses:

• @property uint gc.gcx.Pool.shiftBy()
• gc.gcx.Pool* gc.gcx.Gcx.findPool(void*)
• uint gc.gcx.Gcx.getBits(gc.gcx.Pool*, ulong)
• void gc.gcx.Gcx.setBits(gc.gcx.Pool*, ulong, uint)

void gc.gcx.GC.addRange(void*, ulong)

Uses:

• _d_monitorenter
• thread_needLock
• void gc.gcx.Gcx.addRange(void*, void*)
• TypeInfo_Class gc.gcx.GC.gcLock
• _d_monitorexit

void gc.gcx.GC.getStats(out gc.gcstats.GCStats)

Uses:

• void gc.gcx.GC.getStatsNoSync(out gc.gcstats.GCStats)
• _d_monitorenter
• thread_needLock
• TypeInfo_Class gc.gcx.GC.gcLock
• _d_monitorexit

void gc.gcx.GC.minimize()

Uses:

• void gc.gcx.Gcx.minimize()
• _d_monitorenter
• thread_needLock
• TypeInfo_Class gc.gcx.GC.gcLock
• _d_monitorexit

@property int delegate(int delegate(ref void*)) gc.gcx.GC.rootIter()

Uses:

• _d_monitorenter
• thread_needLock
• TypeInfo_Class gc.gcx.GC.gcLock
• _d_monitorexit

@property int delegate(int delegate(ref gc.gcx.Range)) gc.gcx.GC.rangeIter()

Uses:

• _d_monitorenter
• thread_needLock
• TypeInfo_Class gc.gcx.GC.gcLock
• _d_monitorexit

void gc.gcx.Gcx.removeRoot(void*)

Used by:

• void gc.gcx.GC.removeRoot(void*)

Uses:

• memmove@plt

ulong gc.gcx.Gcx.fullcollect(void*)

Used by:

• ulong gc.gcx.Gcx.fullcollectshell()

Uses:

• thread_processGCMarks
• memset@plt
• onInvalidMemoryOperationError
• thread_suspendAll
• memcpy@plt
• thread_scanAll
• void gc.gcx.Gcx.mark(void*, void*)
• thread_resumeAll
• rt_finalize

void gc.gcx.Gcx.removeRange(void*)

Used by:

• void gc.gcx.GC.removeRange(void*)

Uses:

• memmove@plt

bool gc.gcx.Gcx.isCollecting(void*)

Used by:

• bool gc.gcx.GC.isCollecting(void*)

Uses:

• gc.gcx.Pool* gc.gcx.Gcx.findPool(void*)

ulong gc.gcx.Gcx.fullcollectshell()

Used by:

• void gc.gcx.GC.fullCollectNoStack()
• void* gc.gcx.Gcx.bigAlloc(ulong, gc.gcx.Pool**, ulong*)
• void* gc.gcx.GC.mallocNoSync(ulong, uint, ulong*)
• ulong gc.gcx.GC.fullCollect()

Uses:

• ulong gc.gcx.Gcx.fullcollect(void*)

void gc.gcx.Gcx.Dtor()

Used by:

• void gc.gcx.GC.Dtor()

Uses:

• free@plt
• void gc.gcx.Pool.Dtor()

void gc.gcx.Gcx.mark(void*, void*)

Used by:

• ulong gc.gcx.Gcx.fullcollect(void*)

Uses:

• gc.gcx.Pool* gc.gcx.Gcx.findPool(void*)

void gc.gcx.Gcx.addRoot(void*)

Used by:

• void gc.gcx.GC.addRoot(void*)

Uses:

• malloc@plt
• free@plt
• onOutOfMemoryError
• memcpy@plt

void gc.gcx.Gcx.clrBits(gc.gcx.Pool*, ulong, uint)

Used by:

• uint gc.gcx.GC.clrAttr(void*, uint).uint go()

ubyte gc.gcx.Gcx.findBin(ulong)

Used by:

• void* gc.gcx.GC.mallocNoSync(ulong, uint, ulong*)

uint gc.gcx.Gcx.getBits(gc.gcx.Pool*, ulong)

Used by:

• uint gc.gcx.GC.getAttr(void*).uint go()
• uint gc.gcx.GC.clrAttr(void*, uint).uint go()
• uint gc.gcx.GC.setAttr(void*, uint).uint go()

gc.gcx.BlkInfo gc.gcx.Gcx.getInfo(void*)

Used by:

• gc.gcx.BlkInfo gc.gcx.GC.queryNoSync(void*)

Uses:

• gc.gcx.Pool* gc.gcx.Gcx.findPool(void*)

gc.gcx.Pool* gc.gcx.Gcx.newPool(ulong, bool)

Used by:

• void* gc.gcx.Gcx.bigAlloc(ulong, gc.gcx.Pool**, ulong*)
• void* gc.gcx.GC.mallocNoSync(ulong, uint, ulong*)
• ulong gc.gcx.Gcx.reserve(ulong)

Uses:

• free@plt
• calloc@plt
• realloc@plt
• memmove@plt
• void gc.gcx.Pool.Dtor()
• void gc.gcx.Pool.initialize(ulong, bool)

ulong gc.gcx.Gcx.reserve(ulong)

Used by:

• ulong gc.gcx.GC.reserve(ulong)

Uses:

• gc.gcx.Pool* gc.gcx.Gcx.newPool(ulong, bool)
• ulong gc.gcx.Pool.extendPages(ulong)

void gc.gcx.Gcx.setBits(gc.gcx.Pool*, ulong, uint)

Used by:

• void* gc.gcx.GC.reallocNoSync(void*, ulong, uint, ulong*)
• uint gc.gcx.GC.setAttr(void*, uint).uint go()
• void* gc.gcx.GC.mallocNoSync(ulong, uint, ulong*)

Uses:

• onOutOfMemoryError
• calloc@plt

void gc.gcx.Gcx.addRange(void*, void*)

Used by:

• void gc.gcx.GC.addRange(void*, ulong)

Uses:

• malloc@plt
• free@plt
• onOutOfMemoryError
• memcpy@plt

void* gc.gcx.Gcx.bigAlloc(ulong, gc.gcx.Pool**, ulong*)

Used by:

• void* gc.gcx.GC.mallocNoSync(ulong, uint, ulong*)

Uses:

• void gc.gcx.Gcx.minimize()
• gc.gcx.Pool* gc.gcx.Gcx.newPool(ulong, bool)
• ulong gc.gcx.Gcx.fullcollectshell()
• memset@plt
• void gc.gcx.Pool.updateOffsets(ulong)
• ulong gc.gcx.Pool.allocPages(ulong)

void* gc.gcx.Gcx.findBase(void*)

Used by:

• void* gc.gcx.GC.addrOfNoSync(void*)

Uses:

• gc.gcx.Pool* gc.gcx.Gcx.findPool(void*)

gc.gcx.Pool* gc.gcx.Gcx.findPool(void*)

Used by:

• uint gc.gcx.GC.getAttr(void*).uint go()
• ulong gc.gcx.GC.extendNoSync(void*, ulong, ulong)
• ulong gc.gcx.Gcx.findSize(void*)
• bool gc.gcx.Gcx.isCollecting(void*)
• uint gc.gcx.GC.clrAttr(void*, uint).uint go()
• void* gc.gcx.GC.reallocNoSync(void*, ulong, uint, ulong*)
• void gc.gcx.GC.freeNoSync(void*)
• void* gc.gcx.Gcx.findBase(void*)
• uint gc.gcx.GC.setAttr(void*, uint).uint go()
• gc.gcx.BlkInfo gc.gcx.Gcx.getInfo(void*)
• void gc.gcx.Gcx.mark(void*, void*)

ulong gc.gcx.Gcx.findSize(void*)

Used by:

• ulong gc.gcx.GC.extendNoSync(void*, ulong, ulong)
• void* gc.gcx.GC.reallocNoSync(void*, ulong, uint, ulong*)
• ulong gc.gcx.GC.sizeOfNoSync(void*)

Uses:

• gc.gcx.Pool* gc.gcx.Gcx.findPool(void*)

void gc.gcx.Gcx.minimize()

Used by:

• void* gc.gcx.Gcx.bigAlloc(ulong, gc.gcx.Pool**, ulong*)
• void gc.gcx.GC.minimize()

Uses:

• free@plt
• void gc.gcx.Pool.Dtor()
• memmove@plt

int gc.gcx.Gcx.rootIter(int delegate(ref void*))

int gc.gcx.Gcx.allocPage(ubyte)

Used by:

• void* gc.gcx.GC.mallocNoSync(ulong, uint, ulong*)

Uses:

• ulong gc.gcx.Pool.allocPages(ulong)

int gc.gcx.Gcx.rangeIter(int delegate(ref gc.gcx.Range))

ulong gc.gcx.Pool.allocPages(ulong)

Used by:

• int gc.gcx.Gcx.allocPage(ubyte)
• void* gc.gcx.Gcx.bigAlloc(ulong, gc.gcx.Pool**, ulong*)

Uses:

• ulong gc.gcx.Pool.extendPages(ulong)

void gc.gcx.Pool.initialize(ulong, bool)

Used by:

• gc.gcx.Pool* gc.gcx.Gcx.newPool(ulong, bool)

Uses:

• malloc@plt
• mmap64@plt
• onOutOfMemoryError
• memset@plt
• calloc@plt

ulong gc.gcx.Pool.extendPages(ulong)

Used by:

• void* gc.gcx.GC.reallocNoSync(void*, ulong, uint, ulong*)
• ulong gc.gcx.Gcx.reserve(ulong)
• ulong gc.gcx.Pool.allocPages(ulong)

Uses:

• memset@plt

void gc.gcx.Pool.updateOffsets(ulong)

Used by:

• ulong gc.gcx.GC.extendNoSync(void*, ulong, ulong)
• void* gc.gcx.Gcx.bigAlloc(ulong, gc.gcx.Pool**, ulong*)
• void* gc.gcx.GC.reallocNoSync(void*, ulong, uint, ulong*)

ulong gc.gcx.Pool.extendPagesUpTo(ulong)

Used by:

• ulong gc.gcx.GC.extendNoSync(void*, ulong, ulong)

Uses:

• memset@plt

void gc.gcx.Pool.Dtor()

Used by:

• void gc.gcx.Gcx.minimize()
• gc.gcx.Pool* gc.gcx.Gcx.newPool(ulong, bool)
• void gc.gcx.Gcx.Dtor()

Uses:

• free@plt
• munmap@plt
• void gc.gcbits.GCBits.Dtor()

@property uint gc.gcx.Pool.shiftBy()

Used by:

• uint gc.gcx.GC.getAttr(void*).uint go()
• uint gc.gcx.GC.clrAttr(void*, uint).uint go()
• uint gc.gcx.GC.setAttr(void*, uint).uint go()

void gc.gcx.Pool.freePages(ulong, ulong)

Used by:

• void* gc.gcx.GC.reallocNoSync(void*, ulong, uint, ulong*)
• void gc.gcx.GC.freeNoSync(void*)

gc.gcx.__array

Uses:

• _d_array_bounds

void gc.gcx.__assert(int)

Uses:

• _d_assertm

void gc.gcbits.GCBits.Dtor()

Used by:

• void gc.gcx.Pool.Dtor()

Uses:

• free@plt

rt.deh2.DHandlerTable* rt.deh2.__eh_finddata(void*)

Used by:

• _d_throwc

void rt.deh2.__unittest_fail(int)

Uses:

• _d_unittestm

ulong rt.deh2.__eh_find_caller(ulong, ulong*)

Used by:

• _d_throwc

Uses:

• void rt.deh2.terminate()

rt.deh2.__array

Uses:

• _d_array_bounds

void rt.deh2.__assert(int)

Uses:

• _d_assertm

void rt.deh2.terminate()

Used by:

• ulong rt.deh2.__eh_find_caller(ulong, ulong*)

ulong rt.util.hash.hashOf(const(void)*, ulong, ulong)

Used by:

• ulong object.TypeInfo_Array.getHash(const(void*))
• ulong rt.typeinfo.ti_Ag.TypeInfo_Ag.getHash(const(void*))
• ulong object.TypeInfo.toHash()
• ulong object.TypeInfo_Struct.getHash(const(void*))

ulong rt.util.hash.hashOf(const(void)*, ulong, ulong).uint get16bits(const(ubyte)*)

char[] rt.util.string.intToString(char[], ulong)

Used by:

• immutable(char)[] object.Throwable.toString()
• rt.util.console.Console rt.util.console.Console.opCall(ulong)
• immutable(char)[] object.TypeInfo_StaticArray.toString()

int rt.util.string.dstrcmp(const(char[]), const(char[]))

Used by:

• int rt.typeinfo.ti_Ag.TypeInfo_Ah.compare(const(void*), const(void*))
• int object.TypeInfo.opCmp(Object)

Uses:

• memcmp@plt

void rt.util.console.__unittest_fail(int)

Uses:

• _d_unittestm

rt.util.console.Console rt.util.console.Console.opCall(ulong)

Used by:

• extern (C) int rt.dmain2.main(int, char**).void tryExec(scope void delegate()).void printLocLine(object.Throwable)
• extern (C) int rt.dmain2.main(int, char**).void tryExec(scope void delegate()).void printMsgLine(object.Throwable)

Uses:

• char[] rt.util.string.intToString(char[], ulong)
• write@plt

rt.util.console.Console rt.util.console.Console.opCall(const(char[]))

Used by:

• extern (C) int rt.dmain2.main(int, char**).void tryExec(scope void delegate()).void printLocLine(object.Throwable)
• extern (C) int rt.dmain2.main(int, char**).void tryExec(scope void delegate()).void print(object.Throwable)
• extern (C) int rt.dmain2.main(int, char**).void tryExec(scope void delegate()).void printMsgLine(object.Throwable)
• extern (C) int rt.dmain2.main(int, char**).void tryExec(scope void delegate()).void printInfoBlock(object.Throwable)
• extern (C) int rt.dmain2.main(int, char**).void tryExec(scope void delegate()).void printInfoBlock(object.Throwable).int __foreachbody393(ref char[])
• extern (C) void object._checkModCtors().bool _checkModCtors2(object.ModuleInfo*)
• extern (C) void object._checkModCtors().void println(immutable(char)[][]...)

Uses:

• write@plt

rt.util.console.__array

Uses:

• _d_array_bounds

void rt.util.console.__assert(int)

Uses:

• _d_assertm

shared(bool) rt.dmain2._d_isHalting

Used by:

• extern (C) int rt.dmain2.main(int, char**).void runAll()

void rt.dmain2.__unittest_fail(int)

Uses:

• _d_unittestm

extern (C) int rt.dmain2.main(int, char**).void runAll()

Uses:

• _moduleTlsCtor
• void rt.memory.initStaticDataGC()
• shared(bool) rt.dmain2._d_isHalting
• rt_lifetimeInit
• runModuleUnitTests
• extern (C) int rt.dmain2.main(int, char**).void tryExec(scope void delegate())
• thread_joinAll
• _moduleDtor
• gc_init
• _moduleCtor
• _moduleTlsDtor
• gc_term

extern (C) int rt.dmain2.main(int, char**).void runMain()

Uses:

• _Dmain

extern (C) int rt.dmain2.main(int, char**).void tryExec(scope void delegate())

Used by:

• main
• extern (C) int rt.dmain2.main(int, char**).void runAll()

Uses:

• extern (C) int rt.dmain2.main(int, char**).void tryExec(scope void delegate()).void print(object.Throwable)

extern (C) int rt.dmain2.main(int, char**).void tryExec(scope void delegate()).void printLocLine(object.Throwable)

Used by:

• extern (C) int rt.dmain2.main(int, char**).void tryExec(scope void delegate()).void print(object.Throwable)

Uses:

• rt.util.console.Console rt.util.console.Console.opCall(const(char[]))
• rt.util.console.Console rt.util.console.Console.opCall(ulong)

extern (C) int rt.dmain2.main(int, char**).void tryExec(scope void delegate()).void printMsgLine(object.Throwable)

Used by:

• extern (C) int rt.dmain2.main(int, char**).void tryExec(scope void delegate()).void print(object.Throwable)

Uses:

• rt.util.console.Console rt.util.console.Console.opCall(const(char[]))
• rt.util.console.Console rt.util.console.Console.opCall(ulong)

extern (C) int rt.dmain2.main(int, char**).void tryExec(scope void delegate()).void printInfoBlock(object.Throwable)

Used by:

• extern (C) int rt.dmain2.main(int, char**).void tryExec(scope void delegate()).void print(object.Throwable)

Uses:

• rt.util.console.Console rt.util.console.Console.opCall(const(char[]))

extern (C) int rt.dmain2.main(int, char**).void tryExec(scope void delegate()).void printInfoBlock(object.Throwable).int __foreachbody393(ref char[])

Uses:

• rt.util.console.Console rt.util.console.Console.opCall(const(char[]))

extern (C) int rt.dmain2.main(int, char**).void tryExec(scope void delegate()).void print(object.Throwable)

Used by:

• extern (C) int rt.dmain2.main(int, char**).void tryExec(scope void delegate())

Uses:

• rt.util.console.Console rt.util.console.Console.opCall(const(char[]))
• extern (C) int rt.dmain2.main(int, char**).void tryExec(scope void delegate()).void printLocLine(object.Throwable)
• extern (C) int rt.dmain2.main(int, char**).void tryExec(scope void delegate()).void printMsgLine(object.Throwable)
• extern (C) int rt.dmain2.main(int, char**).void tryExec(scope void delegate()).void printInfoBlock(object.Throwable)
• _d_dynamic_cast

rt.dmain2.__array

Uses:

• _d_array_bounds

immutable(char)[][] rt.dmain2._d_args

Used by:

• main

void rt.dmain2.__assert(int)

Uses:

• _d_assertm

void rt.memory.initStaticDataGC()

Used by:

• extern (C) int rt.dmain2.main(int, char**).void runAll()

Uses:

• gc_addRange

@property rt.lifetime.BlkInfo* rt.lifetime.__blkcache()

Used by:

• rt.lifetime.BlkInfo* rt.lifetime.__getBlkInfo(void*)
• void rt.lifetime.__insertBlkInfoCache(rt.lifetime.BlkInfo, rt.lifetime.BlkInfo*)

Uses:

• _DYNAMIC
• malloc@plt
• memset@plt

ulong rt.lifetime.newCapacity(ulong, ulong)

Used by:

• _d_arrayappendcTX

void rt.lifetime.__doPostblit(void*, ulong, TypeInfo)

Used by:

• _d_arraysetlengthiT
• _d_arraycatT
• _d_arraycatnT
• _d_arrayappendcTX
• _d_arrayappendT
• _adDupT
• _d_arraysetlengthT

Uses:

• _d_dynamic_cast

rt.lifetime.BlkInfo* rt.lifetime.__getBlkInfo(void*)

Used by:

• _d_arraysetlengthiT
• _d_arrayappendcTX
• _d_arraysetlengthT

Uses:

• @property rt.lifetime.BlkInfo* rt.lifetime.__blkcache()
• _DYNAMIC

void rt.lifetime._staticDtor9()

Used by:

• void rt.lifetime.__moddtor()

Uses:

• _DYNAMIC
• free@plt

bool function(Object)* rt.lifetime.collectHandler

Used by:

• rt_finalize

void rt.lifetime.__unittest_fail(int)

Uses:

• _d_unittestm

ulong rt.lifetime.__blkcache_offset

Used by:

• rt_processGCMarks
• rt_lifetimeInit

void rt.lifetime.__insertBlkInfoCache(rt.lifetime.BlkInfo, rt.lifetime.BlkInfo*)

Used by:

• _d_arraysetlengthiT
• _d_arrayappendcTX
• _d_arraysetlengthT

Uses:

• @property rt.lifetime.BlkInfo* rt.lifetime.__blkcache()
• _DYNAMIC

bool rt.lifetime.__setArrayAllocLength(ref rt.lifetime.BlkInfo, ulong, bool, ulong)

Used by:

• _d_arraysetlengthiT
• _d_newarrayT
• _d_arraycatT
• _d_arraycatnT
• _d_arrayappendcTX
• _d_newarrayiT
• _adDupT
• _d_arraysetlengthT

Uses:

• _d_monitorenter
• _d_monitorexit

rt.lifetime.__array

Uses:

• _d_array_bounds

void rt.lifetime.__assert(int)

Uses:

• _d_assertm

void rt.lifetime.__moddtor()

Uses:

• void rt.lifetime._staticDtor9()

void rt.monitor_.__unittest_fail(int)

Uses:

• _d_unittestm

int rt.monitor_.inited

Used by:

• _STI_monitor_staticctor
• _STD_monitor_staticdtor

rt.monitor_.__array

Uses:

• _d_array_bounds

void rt.monitor_.__assert(int)

Uses:

• _d_assertm

pure nothrow @property TypeInfo rt.typeinfo.ti_Ag.TypeInfo_Aa.next()

ulong rt.typeinfo.ti_Ag.TypeInfo_Aa.getHash(const(void*))

immutable(char)[] rt.typeinfo.ti_Ag.TypeInfo_Aa.toString()

pure nothrow @property TypeInfo rt.typeinfo.ti_Ag.TypeInfo_Ab.next()

immutable(char)[] rt.typeinfo.ti_Ag.TypeInfo_Ab.toString()

pure nothrow @property TypeInfo rt.typeinfo.ti_Ag.TypeInfo_Ag.next()

pure nothrow @property uint rt.typeinfo.ti_Ag.TypeInfo_Ag.flags()

pure nothrow @property ulong rt.typeinfo.ti_Ag.TypeInfo_Ag.tsize()

bool rt.typeinfo.ti_Ag.TypeInfo_Ag.equals(const(void*), const(void*))

Uses:

• memcmp@plt

pure nothrow @property ulong rt.typeinfo.ti_Ag.TypeInfo_Ag.talign()

int rt.typeinfo.ti_Ag.TypeInfo_Ag.compare(const(void*), const(void*))

ulong rt.typeinfo.ti_Ag.TypeInfo_Ag.getHash(const(void*))

Uses:

• ulong rt.util.hash.hashOf(const(void)*, ulong, ulong)

int rt.typeinfo.ti_Ag.TypeInfo_Ag.argTypes(out TypeInfo, out TypeInfo)

immutable(char)[] rt.typeinfo.ti_Ag.TypeInfo_Ag.toString()

pure nothrow @property TypeInfo rt.typeinfo.ti_Ag.TypeInfo_Ah.next()

int rt.typeinfo.ti_Ag.TypeInfo_Ah.compare(const(void*), const(void*))

Uses:

• int rt.util.string.dstrcmp(const(char[]), const(char[]))

immutable(char)[] rt.typeinfo.ti_Ag.TypeInfo_Ah.toString()

pure nothrow @property TypeInfo rt.typeinfo.ti_Ag.TypeInfo_Av.next()

immutable(char)[] rt.typeinfo.ti_Ag.TypeInfo_Av.toString()

pure nothrow @property TypeInfo rt.typeinfo.ti_Ag.TypeInfo_Aya.next()

immutable(char)[] rt.typeinfo.ti_Ag.TypeInfo_Aya.toString()

void rt.typeinfo.ti_Ag.__unittest_fail(int)

Uses:

• _d_unittestm

rt.typeinfo.ti_Ag.__array

Uses:

• _d_array_bounds

void rt.typeinfo.ti_Ag.__assert(int)

Uses:

• _d_assertm

void rt.typeinfo.ti_byte.TypeInfo_g.swap(void*, void*)

pure nothrow @property ulong rt.typeinfo.ti_byte.TypeInfo_g.tsize()

bool rt.typeinfo.ti_byte.TypeInfo_g.equals(const(void*), const(void*))

int rt.typeinfo.ti_byte.TypeInfo_g.compare(const(void*), const(void*))

ulong rt.typeinfo.ti_byte.TypeInfo_g.getHash(const(void*))

immutable(char)[] rt.typeinfo.ti_byte.TypeInfo_g.toString()

void rt.typeinfo.ti_byte.__unittest_fail(int)

Uses:

• _d_unittestm

rt.typeinfo.ti_byte.__array

Uses:

• _d_array_bounds

void rt.typeinfo.ti_byte.__assert(int)

Uses:

• _d_assertm

pure nothrow void[] rt.typeinfo.ti_char.TypeInfo_a.init()

void rt.typeinfo.ti_char.TypeInfo_a.swap(void*, void*)

pure nothrow @property ulong rt.typeinfo.ti_char.TypeInfo_a.tsize()

bool rt.typeinfo.ti_char.TypeInfo_a.equals(const(void*), const(void*))

int rt.typeinfo.ti_char.TypeInfo_a.compare(const(void*), const(void*))

ulong rt.typeinfo.ti_char.TypeInfo_a.getHash(const(void*))

immutable(char)[] rt.typeinfo.ti_char.TypeInfo_a.toString()

void rt.typeinfo.ti_char.__unittest_fail(int)

Uses:

• _d_unittestm

rt.typeinfo.ti_char.__array

Uses:

• _d_array_bounds

void rt.typeinfo.ti_char.__assert(int)

Uses:

• _d_assertm

void rt.typeinfo.ti_void.TypeInfo_v.swap(void*, void*)

pure nothrow @property uint rt.typeinfo.ti_void.TypeInfo_v.flags()

pure nothrow @property ulong rt.typeinfo.ti_void.TypeInfo_v.tsize()

bool rt.typeinfo.ti_void.TypeInfo_v.equals(const(void*), const(void*))

int rt.typeinfo.ti_void.TypeInfo_v.compare(const(void*), const(void*))

ulong rt.typeinfo.ti_void.TypeInfo_v.getHash(const(void*))

immutable(char)[] rt.typeinfo.ti_void.TypeInfo_v.toString()

void rt.typeinfo.ti_void.__unittest_fail(int)

Uses:

• _d_unittestm

rt.typeinfo.ti_void.__array

Uses:

• _d_array_bounds

void rt.typeinfo.ti_void.__assert(int)

Uses:

• _d_assertm

immutable(char)[] rt.typeinfo.ti_ubyte.TypeInfo_b.toString()

void rt.typeinfo.ti_ubyte.TypeInfo_h.swap(void*, void*)

pure nothrow @property ulong rt.typeinfo.ti_ubyte.TypeInfo_h.tsize()

bool rt.typeinfo.ti_ubyte.TypeInfo_h.equals(const(void*), const(void*))

int rt.typeinfo.ti_ubyte.TypeInfo_h.compare(const(void*), const(void*))

ulong rt.typeinfo.ti_ubyte.TypeInfo_h.getHash(const(void*))

immutable(char)[] rt.typeinfo.ti_ubyte.TypeInfo_h.toString()

void rt.typeinfo.ti_ubyte.__unittest_fail(int)

Uses:

• _d_unittestm

rt.typeinfo.ti_ubyte.__array

Uses:

• _d_array_bounds

void rt.typeinfo.ti_ubyte.__assert(int)

Uses:

• _d_assertm

void rt.critical_.__unittest_fail(int)

Uses:

• _d_unittestm

rt.critical_.__array

Uses:

• _d_array_bounds

void rt.critical_.__assert(int)

Uses:

• _d_assertm

rt.critical_.D_CRITICAL_SECTION* rt.critical_.dcs_list

Used by:

• _STD_critical_term
• _STI_critical_init

void std.functional.__unittest_fail(int)

Uses:

• _d_unittestm

bool std.functional.binaryFunImpl!("b < a.timeT", "a", "b").result!(std.datetime.PosixTimeZone.Transition, long).result(std.datetime.PosixTimeZone.Transition, long)

Used by:

• bool std.algorithm.startsWith!("b < a.timeT", std.datetime.PosixTimeZone.Transition[], long).startsWith(std.datetime.PosixTimeZone.Transition[], long)

bool std.functional.binaryFunImpl!("b < a.timeT", "a", "b").result!(std.datetime.PosixTimeZone.LeapSecond, immutable(long)).result(std.datetime.PosixTimeZone.LeapSecond, immutable(long))

Used by:

• bool std.algorithm.startsWith!("b < a.timeT", std.datetime.PosixTimeZone.LeapSecond[], immutable(long)).startsWith(std.datetime.PosixTimeZone.LeapSecond[], immutable(long))

bool std.functional.binaryFunImpl!("b < a.timeT", "a", "b").result!(std.datetime.PosixTimeZone.Transition, immutable(long)).result(std.datetime.PosixTimeZone.Transition, immutable(long))

Used by:

• bool std.algorithm.startsWith!("b < a.timeT", std.datetime.PosixTimeZone.Transition[], immutable(long)).startsWith(std.datetime.PosixTimeZone.Transition[], immutable(long))

std.functional.__array

Uses:

• _d_array_bounds

void std.functional.__assert(int)

Uses:

• _d_assertm

pure nothrow @safe std.utf.UTFException std.utf.UTFException.setSequence(uint[]...)

Uses:

• _d_arraycopy
• int std.algorithm.min!(ulong, int).min(ulong, int)
• std.utf.__array

immutable(char)[] std.utf.UTFException.toString()

Uses:

• immutable(char)[] object.Throwable.toString()
• _d_arraycatT
• immutable(char)[] std.conv.to!(immutable(char)[]).to!(uint, int).to(uint, int)
• _d_arrayappendT

void std.utf.__unittest_fail(int)

Uses:

• _d_unittestm

std.utf.__array

Used by:

• pure nothrow @safe std.utf.UTFException std.utf.UTFException.setSequence(uint[]...)

Uses:

• _d_array_bounds

void std.utf.__assert(int)

Uses:

• _d_assertm

immutable(char)[] std.conv.to!(immutable(char)[]).to!(char[]).to(char[])

Used by:

• immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint)

Uses:

• immutable(char)[] std.conv.toImpl!(immutable(char)[], char[]).toImpl(char[])

immutable(char)[] std.conv.to!(immutable(char)[]).to!(const(char)*).to(const(char)*)

Used by:

• const(nothrow @property immutable(char)[] function()) std.datetime.LocalTime.stdName
• const(nothrow @property immutable(char)[] function()) std.datetime.LocalTime.dstName

Uses:

• immutable(char)[] std.conv.toImpl!(immutable(char)[], const(char)*).toImpl(const(char)*)

immutable(char)[] std.conv.to!(immutable(char)[]).to!(uint, int).to(uint, int)

Used by:

• immutable(char)[] std.utf.UTFException.toString()

Uses:

• immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint)

immutable(char)[] std.conv.to!(immutable(char)[]).to!(ulong, uint).to(ulong, uint)

Used by:

• immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint)

Uses:

• immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint)

immutable(char)[] std.conv.to!(immutable(char)[]).to!(uint).to(uint)

Used by:

• immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint)

Uses:

• immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint)

std.conv.ConvException std.conv.ConvException.__ctor(immutable(char)[], immutable(char)[], ulong)

Used by:

• immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint).object.Throwable __dgliteral2800()

Uses:

• Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)

void std.conv.__unittest_fail(int)

Uses:

• _d_unittestm

immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint)

Used by:

• immutable(char)[] std.conv.to!(immutable(char)[]).to!(uint).to(uint)

Uses:

• char[] std.array.uninitializedArray!(char[], ulong).uninitializedArray(ulong)

immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint)

Used by:

• immutable(char)[] std.conv.to!(immutable(char)[]).to!(uint, int).to(uint, int)

Uses:

• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy object.Throwable)
• immutable(char)[] std.conv.to!(immutable(char)[]).to!(ulong, uint).to(ulong, uint)
• immutable(char)[] std.conv.to!(immutable(char)[]).to!(uint).to(uint)

immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint).object.Throwable __dgliteral2800()

Uses:

• _d_newclass
• std.conv.ConvException std.conv.ConvException.__ctor(immutable(char)[], immutable(char)[], ulong)

immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint)

Used by:

• immutable(char)[] std.conv.to!(immutable(char)[]).to!(ulong, uint).to(ulong, uint)

Uses:

• immutable(char[]) std.ascii.hexDigits
• std.conv.__array
• _adDupT
• immutable(char)[] std.conv.to!(immutable(char)[]).to!(char[]).to(char[])

immutable(char)[] std.conv.toImpl!(immutable(char)[], char[]).toImpl(char[])

Used by:

• immutable(char)[] std.conv.to!(immutable(char)[]).to!(char[]).to(char[])

Uses:

• _adDupT

immutable(char)[] std.conv.toImpl!(immutable(char)[], const(char)*).toImpl(const(char)*)

Used by:

• immutable(char)[] std.conv.to!(immutable(char)[]).to!(const(char)*).to(const(char)*)

Uses:

• strlen@plt
• _adDupT

std.conv.__array

Used by:

• immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint)

Uses:

• _d_array_bounds

void std.conv.__assert(int)

Uses:

• _d_assertm

void std.file.__unittest_fail(int)

Uses:

• _d_unittestm

std.file.__array

Uses:

• _d_array_bounds

void std.file.__assert(int)

Uses:

• _d_assertm

void std.math.__unittest_fail(int)

Uses:

• _d_unittestm

std.math.__array

Uses:

• _d_array_bounds

void std.math.__assert(int)

Uses:

• _d_assertm

void std.path.__unittest_fail(int)

Uses:

• _d_unittestm

std.path.__array

Uses:

• _d_array_bounds

void std.path.__assert(int)

Uses:

• _d_assertm

pure nothrow @property @safe bool std.array.empty!(immutable(char)).empty(const(immutable(char)[]))

Used by:

• pure nothrow immutable(char)* std.string.toStringz(immutable(char)[])

void std.array.__unittest_fail(int)

Uses:

• _d_unittestm

char[] std.array.arrayAllocImpl!(false, char[], ulong).arrayAllocImpl(ulong)

Used by:

• char[] std.array.uninitializedArray!(char[], ulong).uninitializedArray(ulong)

Uses:

• void* core.memory.GC.malloc(ulong, uint)

char[] std.array.uninitializedArray!(char[], ulong).uninitializedArray(ulong)

Used by:

• immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint)

Uses:

• char[] std.array.arrayAllocImpl!(false, char[], ulong).arrayAllocImpl(ulong)

ref immutable(std.datetime.PosixTimeZone.LeapSecond) std.array.back!(immutable(std.datetime.PosixTimeZone.LeapSecond)).back(immutable(std.datetime.PosixTimeZone.LeapSecond)[])

Used by:

• const(nothrow int function(long)) std.datetime.PosixTimeZone.calculateLeapSeconds

Uses:

• std.array.__array

ref immutable(std.datetime.PosixTimeZone.Transition) std.array.back!(immutable(std.datetime.PosixTimeZone.Transition)).back(immutable(std.datetime.PosixTimeZone.Transition)[])

Used by:

• const(nothrow bool function(long)) std.datetime.PosixTimeZone.dstInEffect
• const(nothrow long function(long)) std.datetime.PosixTimeZone.utcToTZ
• const(nothrow long function(long)) std.datetime.PosixTimeZone.tzToUTC

Uses:

• std.array.__array

pure nothrow @property @safe bool std.array.empty!(std.datetime.PosixTimeZone.LeapSecond).empty(const(std.datetime.PosixTimeZone.LeapSecond[]))

Used by:

• bool std.algorithm.startsWith!("b < a.timeT", std.datetime.PosixTimeZone.LeapSecond[], immutable(long)).startsWith(std.datetime.PosixTimeZone.LeapSecond[], immutable(long))
• long std.algorithm.countUntil!("b < a.timeT", std.datetime.PosixTimeZone.LeapSecond[], immutable(long)).countUntil(std.datetime.PosixTimeZone.LeapSecond[], immutable(long))

pure nothrow @property @safe bool std.array.empty!(std.datetime.PosixTimeZone.Transition).empty(const(std.datetime.PosixTimeZone.Transition[]))

Used by:

• long std.algorithm.countUntil!("b < a.timeT", std.datetime.PosixTimeZone.Transition[], long).countUntil(std.datetime.PosixTimeZone.Transition[], long)
• bool std.algorithm.startsWith!("b < a.timeT", std.datetime.PosixTimeZone.Transition[], immutable(long)).startsWith(std.datetime.PosixTimeZone.Transition[], immutable(long))
• bool std.algorithm.startsWith!("b < a.timeT", std.datetime.PosixTimeZone.Transition[], long).startsWith(std.datetime.PosixTimeZone.Transition[], long)
• long std.algorithm.countUntil!("b < a.timeT", std.datetime.PosixTimeZone.Transition[], immutable(long)).countUntil(std.datetime.PosixTimeZone.Transition[], immutable(long))

ref std.datetime.PosixTimeZone.LeapSecond std.array.front!(std.datetime.PosixTimeZone.LeapSecond).front(std.datetime.PosixTimeZone.LeapSecond[])

Used by:

• bool std.algorithm.startsWith!("b < a.timeT", std.datetime.PosixTimeZone.LeapSecond[], immutable(long)).startsWith(std.datetime.PosixTimeZone.LeapSecond[], immutable(long))

Uses:

• std.array.__array

ref std.datetime.PosixTimeZone.Transition std.array.front!(std.datetime.PosixTimeZone.Transition).front(std.datetime.PosixTimeZone.Transition[])

Used by:

• bool std.algorithm.startsWith!("b < a.timeT", std.datetime.PosixTimeZone.Transition[], immutable(long)).startsWith(std.datetime.PosixTimeZone.Transition[], immutable(long))
• bool std.algorithm.startsWith!("b < a.timeT", std.datetime.PosixTimeZone.Transition[], long).startsWith(std.datetime.PosixTimeZone.Transition[], long)

Uses:

• std.array.__array

pure nothrow @property @safe bool std.array.empty!(immutable(std.datetime.PosixTimeZone.LeapSecond)).empty(const(immutable(std.datetime.PosixTimeZone.LeapSecond)[]))

Used by:

• const(nothrow int function(long)) std.datetime.PosixTimeZone.calculateLeapSeconds

ref immutable(std.datetime.PosixTimeZone.LeapSecond) std.array.front!(immutable(std.datetime.PosixTimeZone.LeapSecond)).front(immutable(std.datetime.PosixTimeZone.LeapSecond)[])

Used by:

• const(nothrow int function(long)) std.datetime.PosixTimeZone.calculateLeapSeconds

Uses:

• std.array.__array

void std.array.popFront!(std.datetime.PosixTimeZone.LeapSecond[]).popFront(ref std.datetime.PosixTimeZone.LeapSecond[])

Used by:

• long std.algorithm.countUntil!("b < a.timeT", std.datetime.PosixTimeZone.LeapSecond[], immutable(long)).countUntil(std.datetime.PosixTimeZone.LeapSecond[], immutable(long))

Uses:

• std.array.__array

void std.array.popFront!(std.datetime.PosixTimeZone.Transition[]).popFront(ref std.datetime.PosixTimeZone.Transition[])

Used by:

• long std.algorithm.countUntil!("b < a.timeT", std.datetime.PosixTimeZone.Transition[], long).countUntil(std.datetime.PosixTimeZone.Transition[], long)
• long std.algorithm.countUntil!("b < a.timeT", std.datetime.PosixTimeZone.Transition[], immutable(long)).countUntil(std.datetime.PosixTimeZone.Transition[], immutable(long))

Uses:

• std.array.__array

std.array.__array

Used by:

• ref immutable(std.datetime.PosixTimeZone.LeapSecond) std.array.back!(immutable(std.datetime.PosixTimeZone.LeapSecond)).back(immutable(std.datetime.PosixTimeZone.LeapSecond)[])
• ref immutable(std.datetime.PosixTimeZone.LeapSecond) std.array.front!(immutable(std.datetime.PosixTimeZone.LeapSecond)).front(immutable(std.datetime.PosixTimeZone.LeapSecond)[])
• void std.array.popFront!(std.datetime.PosixTimeZone.LeapSecond[]).popFront(ref std.datetime.PosixTimeZone.LeapSecond[])
• ref std.datetime.PosixTimeZone.Transition std.array.front!(std.datetime.PosixTimeZone.Transition).front(std.datetime.PosixTimeZone.Transition[])
• ref immutable(std.datetime.PosixTimeZone.Transition) std.array.back!(immutable(std.datetime.PosixTimeZone.Transition)).back(immutable(std.datetime.PosixTimeZone.Transition)[])
• void std.array.popFront!(std.datetime.PosixTimeZone.Transition[]).popFront(ref std.datetime.PosixTimeZone.Transition[])
• ref std.datetime.PosixTimeZone.LeapSecond std.array.front!(std.datetime.PosixTimeZone.LeapSecond).front(std.datetime.PosixTimeZone.LeapSecond[])

Uses:

• _d_array_bounds

void std.array.__assert(int)

Uses:

• _d_assertm

void std.ascii.__unittest_fail(int)

Uses:

• _d_unittestm

std.ascii.__array

Uses:

• _d_array_bounds

void std.ascii.__assert(int)

Uses:

• _d_assertm

immutable(char[]) std.ascii.hexDigits

Used by:

• immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint)

void std.range.__unittest_fail(int)

Uses:

• _d_unittestm

std.range.__array

Uses:

• _d_array_bounds

void std.range.__assert(int)

Uses:

• _d_assertm

void std.regex.__unittest_fail(int)

Uses:

• _d_unittestm

std.regex.__array

Uses:

• _d_array_bounds

void std.regex.__assert(int)

Uses:

• _d_assertm

void std.stdio.__unittest_fail(int)

Uses:

• _d_unittestm

void std.stdio.writeln!(immutable(char)[]).writeln(immutable(char)[])

Used by:

• _Dmain

Uses:

• pure @safe bool std.exception.enforce!(bool, "/home/frg/dpl/dmd2/linux/bin64/../../src/phobos/std/stdio.d", 1498).enforce(bool, lazy const(char)[])
• std.stdio.File std.stdio.stdout
• fprintf@plt

void std.stdio.writeln!(immutable(char)[]).writeln(immutable(char)[]).const(char)[] __dgliteral1274()

extern (C) void std.stdio.std_stdio_static_this().std.stdio.File.Impl stderrImpl

Used by:

• std_stdio_static_this

extern (C) void std.stdio.std_stdio_static_this().std.stdio.File.Impl stdoutImpl

Used by:

• std_stdio_static_this

extern (C) void std.stdio.std_stdio_static_this().std.stdio.File.Impl stdinImpl

Used by:

• std_stdio_static_this

std.stdio.File std.stdio.stdin

Used by:

• std_stdio_static_this

std.stdio.File std.stdio.stderr

Used by:

• std_stdio_static_this

std.stdio.File std.stdio.stdout

Used by:

• std_stdio_static_this
• void std.stdio.writeln!(immutable(char)[]).writeln(immutable(char)[])

std.stdio.__array

Uses:

• _d_array_bounds

void std.stdio.__assert(int)

Uses:

• _d_assertm

std.format.FormatException std.format.FormatException.__ctor()

Uses:

• Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)

void std.format.__unittest_fail(int)

Uses:

• _d_unittestm

std.format.__array

Uses:

• _d_array_bounds

void std.format.__assert(int)

Uses:

• _d_assertm

void std.string.__unittest_fail(int)

Uses:

• _d_unittestm

std.string.__array

Uses:

• _d_array_bounds

void std.string.__assert(int)

Uses:

• _d_assertm

pure nothrow immutable(char)* std.string.toStringz(const(char)[])

Used by:

• pure nothrow immutable(char)* std.string.toStringz(immutable(char)[])

Uses:

• _d_newarrayiT
• memcpy@plt
• pure nothrow immutable(char)[] std.exception.assumeUnique!(char).assumeUnique(ref char[])

pure nothrow immutable(char)* std.string.toStringz(immutable(char)[])

Used by:

• void std.outbuffer.OutBuffer.vprintf(immutable(char)[], void*)

Uses:

• pure nothrow @property @safe bool std.array.empty!(immutable(char)).empty(const(immutable(char)[]))
• pure nothrow immutable(char)* std.string.toStringz(const(char)[])

void std.traits.__unittest_fail(int)

Uses:

• _d_unittestm

std.traits.__array

Uses:

• _d_array_bounds

void std.traits.__assert(int)

Uses:

• _d_assertm

void std.process.__unittest_fail(int)

Uses:

• _d_unittestm

std.process.__array

Uses:

• _d_array_bounds

void std.process.__assert(int)

Uses:

• _d_assertm

void std.bitmanip.__unittest_fail(int)

Uses:

• _d_unittestm

std.bitmanip.__array

Uses:

• _d_array_bounds

void std.bitmanip.__assert(int)

Uses:

• _d_assertm

const(nothrow bool function(long)) std.datetime.PosixTimeZone.dstInEffect

Uses:

• pure nothrow long std.datetime.stdTimeToUnixTime(long)
• long std.algorithm.countUntil!("b < a.timeT", std.datetime.PosixTimeZone.Transition[], immutable(long)).countUntil(std.datetime.PosixTimeZone.Transition[], immutable(long))
• ref immutable(std.datetime.PosixTimeZone.Transition) std.array.back!(immutable(std.datetime.PosixTimeZone.Transition)).back(immutable(std.datetime.PosixTimeZone.Transition)[])

const(nothrow int function(long)) std.datetime.PosixTimeZone.calculateLeapSeconds

Used by:

• const(nothrow long function(long)) std.datetime.PosixTimeZone.utcToTZ
• const(nothrow long function(long)) std.datetime.PosixTimeZone.tzToUTC

Uses:

• ref immutable(std.datetime.PosixTimeZone.LeapSecond) std.array.back!(immutable(std.datetime.PosixTimeZone.LeapSecond)).back(immutable(std.datetime.PosixTimeZone.LeapSecond)[])
• pure nothrow @property @safe bool std.array.empty!(immutable(std.datetime.PosixTimeZone.LeapSecond)).empty(const(immutable(std.datetime.PosixTimeZone.LeapSecond)[]))
• pure nothrow long std.datetime.stdTimeToUnixTime(long)
• ref immutable(std.datetime.PosixTimeZone.LeapSecond) std.array.front!(immutable(std.datetime.PosixTimeZone.LeapSecond)).front(immutable(std.datetime.PosixTimeZone.LeapSecond)[])
• long std.algorithm.countUntil!("b < a.timeT", std.datetime.PosixTimeZone.LeapSecond[], immutable(long)).countUntil(std.datetime.PosixTimeZone.LeapSecond[], immutable(long))

const(nothrow @property bool function()) std.datetime.PosixTimeZone.hasDST

const(nothrow long function(long)) std.datetime.PosixTimeZone.tzToUTC

Uses:

• long std.algorithm.countUntil!("b < a.timeT", std.datetime.PosixTimeZone.Transition[], long).countUntil(std.datetime.PosixTimeZone.Transition[], long)
• pure nothrow long std.datetime.stdTimeToUnixTime(long)
• pure nothrow @safe long core.time.convert!("hours", "seconds").convert(long)
• pure nothrow @safe long core.time.convert!("seconds", "hnsecs").convert(long)
• const(nothrow int function(long)) std.datetime.PosixTimeZone.calculateLeapSeconds
• pure nothrow @safe long core.time.convert!("days", "seconds").convert(long)
• long std.algorithm.countUntil!("b < a.timeT", std.datetime.PosixTimeZone.Transition[], immutable(long)).countUntil(std.datetime.PosixTimeZone.Transition[], immutable(long))
• ref immutable(std.datetime.PosixTimeZone.Transition) std.array.back!(immutable(std.datetime.PosixTimeZone.Transition)).back(immutable(std.datetime.PosixTimeZone.Transition)[])

const(nothrow long function(long)) std.datetime.PosixTimeZone.utcToTZ

Uses:

• pure nothrow long std.datetime.stdTimeToUnixTime(long)
• pure nothrow @safe long core.time.convert!("seconds", "hnsecs").convert(long)
• const(nothrow int function(long)) std.datetime.PosixTimeZone.calculateLeapSeconds
• long std.algorithm.countUntil!("b < a.timeT", std.datetime.PosixTimeZone.Transition[], immutable(long)).countUntil(std.datetime.PosixTimeZone.Transition[], immutable(long))
• ref immutable(std.datetime.PosixTimeZone.Transition) std.array.back!(immutable(std.datetime.PosixTimeZone.Transition)).back(immutable(std.datetime.PosixTimeZone.Transition)[])

const(nothrow bool function(long)) std.datetime.SimpleTimeZone.dstInEffect

const(nothrow core.time.Duration function(long)) std.datetime.SimpleTimeZone.utcOffsetAt

Uses:

• pure nothrow @safe core.time.Duration core.time.dur!("minutes").dur(long)

const(nothrow @property bool function()) std.datetime.SimpleTimeZone.hasDST

const(nothrow long function(long)) std.datetime.SimpleTimeZone.tzToUTC

Uses:

• pure nothrow @safe long core.time.convert!("minutes", "hnsecs").convert(long)

const(nothrow long function(long)) std.datetime.SimpleTimeZone.utcToTZ

Uses:

• pure nothrow @safe long core.time.convert!("minutes", "hnsecs").convert(long)

void std.datetime.__modsharedctor()

Uses:

• void std.datetime.LocalTime._sharedStaticCtor7()
• void std.datetime.UTC._sharedStaticCtor8()

void std.datetime.__unittest_fail(int)

Uses:

• _d_unittestm

pure nothrow long std.datetime.stdTimeToUnixTime(long)

Used by:

• const(nothrow long function(long)) std.datetime.LocalTime.tzToUTC
• const(nothrow bool function(long)) std.datetime.PosixTimeZone.dstInEffect
• const(nothrow long function(long)) std.datetime.PosixTimeZone.utcToTZ
• const(nothrow long function(long)) std.datetime.LocalTime.utcToTZ
• const(nothrow bool function(long)) std.datetime.LocalTime.dstInEffect
• const(nothrow long function(long)) std.datetime.PosixTimeZone.tzToUTC
• const(nothrow int function(long)) std.datetime.PosixTimeZone.calculateLeapSeconds

Uses:

• pure nothrow @safe long core.time.convert!("hnsecs", "seconds").convert(long)

const(nothrow bool function(long)) std.datetime.UTC.dstInEffect

const(nothrow core.time.Duration function(long)) std.datetime.UTC.utcOffsetAt

Uses:

• pure nothrow @safe core.time.Duration core.time.dur!("hnsecs").dur(long)

void std.datetime.UTC._sharedStaticCtor8()

Used by:

• void std.datetime.__modsharedctor()

Uses:

• immutable(std.datetime.UTC) std.datetime.UTC._utc
• _d_newclass
• immutable(pure immutable(std.datetime.UTC) function()) std.datetime.UTC.__ctor

immutable(std.datetime.UTC) std.datetime.UTC._utc

Used by:

• void std.datetime.UTC._sharedStaticCtor8()

immutable(pure immutable(std.datetime.UTC) function()) std.datetime.UTC.__ctor

Used by:

• void std.datetime.UTC._sharedStaticCtor8()

Uses:

• immutable(pure immutable(std.datetime.TimeZone) function(immutable(char)[], immutable(char)[], immutable(char)[])) std.datetime.TimeZone.__ctor

const(nothrow @property bool function()) std.datetime.UTC.hasDST

const(nothrow long function(long)) std.datetime.UTC.tzToUTC

const(nothrow long function(long)) std.datetime.UTC.utcToTZ

std.datetime.Clock std.datetime.Clock.__ctor()

std.datetime.__array

Uses:

• _d_array_bounds

const(nothrow core.time.Duration function(long)) std.datetime.TimeZone.utcOffsetAt

Uses:

• pure nothrow @safe core.time.Duration core.time.dur!("hnsecs").dur(long)

const(nothrow @property immutable(char)[] function()) std.datetime.TimeZone.name

immutable(pure immutable(std.datetime.TimeZone) function(immutable(char)[], immutable(char)[], immutable(char)[])) std.datetime.TimeZone.__ctor

Used by:

• immutable(pure immutable(std.datetime.LocalTime) function()) std.datetime.LocalTime.__ctor
• immutable(pure immutable(std.datetime.UTC) function()) std.datetime.UTC.__ctor

const(nothrow @property immutable(char)[] function()) std.datetime.TimeZone.dstName

const(nothrow @property immutable(char)[] function()) std.datetime.TimeZone.stdName

void std.datetime.__assert(int)

Uses:

• _d_assertm

immutable(std.datetime.LocalTime) std.datetime.LocalTime._localTime

Used by:

• void std.datetime.LocalTime._sharedStaticCtor7()

const(nothrow bool function(long)) std.datetime.LocalTime.dstInEffect

Uses:

• localtime@plt
• pure nothrow long std.datetime.stdTimeToUnixTime(long)

void std.datetime.LocalTime._sharedStaticCtor7()

Used by:

• void std.datetime.__modsharedctor()

Uses:

• tzset@plt
• _d_newclass
• immutable(pure immutable(std.datetime.LocalTime) function()) std.datetime.LocalTime.__ctor
• immutable(std.datetime.LocalTime) std.datetime.LocalTime._localTime

immutable(pure immutable(std.datetime.LocalTime) function()) std.datetime.LocalTime.__ctor

Used by:

• void std.datetime.LocalTime._sharedStaticCtor7()

Uses:

• immutable(pure immutable(std.datetime.TimeZone) function(immutable(char)[], immutable(char)[], immutable(char)[])) std.datetime.TimeZone.__ctor

const(nothrow @property bool function()) std.datetime.LocalTime.hasDST

Uses:

• __daylight@@GLIBC_2.2.5

const(nothrow @property immutable(char)[] function()) std.datetime.LocalTime.dstName

Uses:

• immutable(char)[] std.conv.to!(immutable(char)[]).to!(const(char)*).to(const(char)*)
• __tzname@@GLIBC_2.2.5

const(nothrow @property immutable(char)[] function()) std.datetime.LocalTime.stdName

Uses:

• immutable(char)[] std.conv.to!(immutable(char)[]).to!(const(char)*).to(const(char)*)
• __tzname@@GLIBC_2.2.5

const(nothrow long function(long)) std.datetime.LocalTime.tzToUTC

Uses:

• localtime@plt
• pure nothrow long std.datetime.stdTimeToUnixTime(long)
• pure nothrow @safe long core.time.convert!("hours", "seconds").convert(long)
• pure nothrow @safe long core.time.convert!("seconds", "hnsecs").convert(long)
• pure nothrow @safe long core.time.convert!("days", "seconds").convert(long)

const(nothrow long function(long)) std.datetime.LocalTime.utcToTZ

Uses:

• localtime@plt
• pure nothrow long std.datetime.stdTimeToUnixTime(long)
• pure nothrow @safe long core.time.convert!("seconds", "hnsecs").convert(long)

void std.typecons.__unittest_fail(int)

Uses:

• _d_unittestm

std.typecons.__array

Uses:

• _d_array_bounds

void std.typecons.__assert(int)

Uses:

• _d_assertm

int std.algorithm.min!(ulong, int).min(ulong, int)

Used by:

• pure nothrow @safe std.utf.UTFException std.utf.UTFException.setSequence(uint[]...)

void std.algorithm.__unittest_fail(int)

Uses:

• _d_unittestm

std.algorithm.__array

Uses:

• _d_array_bounds

void std.algorithm.__assert(int)

Uses:

• _d_assertm

long std.algorithm.countUntil!("b < a.timeT", std.datetime.PosixTimeZone.Transition[], long).countUntil(std.datetime.PosixTimeZone.Transition[], long)

Used by:

• const(nothrow long function(long)) std.datetime.PosixTimeZone.tzToUTC

Uses:

• pure nothrow @property @safe bool std.array.empty!(std.datetime.PosixTimeZone.Transition).empty(const(std.datetime.PosixTimeZone.Transition[]))
• bool std.algorithm.startsWith!("b < a.timeT", std.datetime.PosixTimeZone.Transition[], long).startsWith(std.datetime.PosixTimeZone.Transition[], long)
• void std.array.popFront!(std.datetime.PosixTimeZone.Transition[]).popFront(ref std.datetime.PosixTimeZone.Transition[])

bool std.algorithm.startsWith!("b < a.timeT", std.datetime.PosixTimeZone.Transition[], long).startsWith(std.datetime.PosixTimeZone.Transition[], long)

Used by:

• long std.algorithm.countUntil!("b < a.timeT", std.datetime.PosixTimeZone.Transition[], long).countUntil(std.datetime.PosixTimeZone.Transition[], long)

Uses:

• pure nothrow @property @safe bool std.array.empty!(std.datetime.PosixTimeZone.Transition).empty(const(std.datetime.PosixTimeZone.Transition[]))
• bool std.functional.binaryFunImpl!("b < a.timeT", "a", "b").result!(std.datetime.PosixTimeZone.Transition, long).result(std.datetime.PosixTimeZone.Transition, long)
• ref std.datetime.PosixTimeZone.Transition std.array.front!(std.datetime.PosixTimeZone.Transition).front(std.datetime.PosixTimeZone.Transition[])

long std.algorithm.countUntil!("b < a.timeT", std.datetime.PosixTimeZone.LeapSecond[], immutable(long)).countUntil(std.datetime.PosixTimeZone.LeapSecond[], immutable(long))

Used by:

• const(nothrow int function(long)) std.datetime.PosixTimeZone.calculateLeapSeconds

Uses:

• pure nothrow @property @safe bool std.array.empty!(std.datetime.PosixTimeZone.LeapSecond).empty(const(std.datetime.PosixTimeZone.LeapSecond[]))
• bool std.algorithm.startsWith!("b < a.timeT", std.datetime.PosixTimeZone.LeapSecond[], immutable(long)).startsWith(std.datetime.PosixTimeZone.LeapSecond[], immutable(long))
• void std.array.popFront!(std.datetime.PosixTimeZone.LeapSecond[]).popFront(ref std.datetime.PosixTimeZone.LeapSecond[])

long std.algorithm.countUntil!("b < a.timeT", std.datetime.PosixTimeZone.Transition[], immutable(long)).countUntil(std.datetime.PosixTimeZone.Transition[], immutable(long))

Used by:

• const(nothrow bool function(long)) std.datetime.PosixTimeZone.dstInEffect
• const(nothrow long function(long)) std.datetime.PosixTimeZone.utcToTZ
• const(nothrow long function(long)) std.datetime.PosixTimeZone.tzToUTC

Uses:

• pure nothrow @property @safe bool std.array.empty!(std.datetime.PosixTimeZone.Transition).empty(const(std.datetime.PosixTimeZone.Transition[]))
• bool std.algorithm.startsWith!("b < a.timeT", std.datetime.PosixTimeZone.Transition[], immutable(long)).startsWith(std.datetime.PosixTimeZone.Transition[], immutable(long))
• void std.array.popFront!(std.datetime.PosixTimeZone.Transition[]).popFront(ref std.datetime.PosixTimeZone.Transition[])

bool std.algorithm.startsWith!("b < a.timeT", std.datetime.PosixTimeZone.LeapSecond[], immutable(long)).startsWith(std.datetime.PosixTimeZone.LeapSecond[], immutable(long))

Used by:

• long std.algorithm.countUntil!("b < a.timeT", std.datetime.PosixTimeZone.LeapSecond[], immutable(long)).countUntil(std.datetime.PosixTimeZone.LeapSecond[], immutable(long))

Uses:

• pure nothrow @property @safe bool std.array.empty!(std.datetime.PosixTimeZone.LeapSecond).empty(const(std.datetime.PosixTimeZone.LeapSecond[]))
• ref std.datetime.PosixTimeZone.LeapSecond std.array.front!(std.datetime.PosixTimeZone.LeapSecond).front(std.datetime.PosixTimeZone.LeapSecond[])
• bool std.functional.binaryFunImpl!("b < a.timeT", "a", "b").result!(std.datetime.PosixTimeZone.LeapSecond, immutable(long)).result(std.datetime.PosixTimeZone.LeapSecond, immutable(long))

bool std.algorithm.startsWith!("b < a.timeT", std.datetime.PosixTimeZone.Transition[], immutable(long)).startsWith(std.datetime.PosixTimeZone.Transition[], immutable(long))

Used by:

• long std.algorithm.countUntil!("b < a.timeT", std.datetime.PosixTimeZone.Transition[], immutable(long)).countUntil(std.datetime.PosixTimeZone.Transition[], immutable(long))

Uses:

• pure nothrow @property @safe bool std.array.empty!(std.datetime.PosixTimeZone.Transition).empty(const(std.datetime.PosixTimeZone.Transition[]))
• ref std.datetime.PosixTimeZone.Transition std.array.front!(std.datetime.PosixTimeZone.Transition).front(std.datetime.PosixTimeZone.Transition[])
• bool std.functional.binaryFunImpl!("b < a.timeT", "a", "b").result!(std.datetime.PosixTimeZone.Transition, immutable(long)).result(std.datetime.PosixTimeZone.Transition, immutable(long))

void std.container.__unittest_fail(int)

Uses:

• _d_unittestm

std.container.__array

Uses:

• _d_array_bounds

void std.container.__assert(int)

Uses:

• _d_assertm

pure @safe bool std.exception.enforce!(bool, "/home/frg/dpl/dmd2/linux/bin64/../../src/phobos/std/stdio.d", 1498).enforce(bool, lazy const(char)[])

Used by:

• void std.stdio.writeln!(immutable(char)[]).writeln(immutable(char)[])

Uses:

• pure @safe void std.exception.bailOut(immutable(char)[], ulong, const(char[]))

pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy object.Throwable)

Used by:

• immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint)

Uses:

• _d_throwc

void std.exception.__unittest_fail(int)

Uses:

• _d_unittestm

pure nothrow immutable(char)[] std.exception.assumeUnique!(char).assumeUnique(ref char[])

Used by:

• pure nothrow immutable(char)* std.string.toStringz(const(char)[])

std.exception.__array

Uses:

• _d_array_bounds

pure @safe void std.exception.bailOut(immutable(char)[], ulong, const(char[]))

Used by:

• pure @safe bool std.exception.enforce!(bool, "/home/frg/dpl/dmd2/linux/bin64/../../src/phobos/std/stdio.d", 1498).enforce(bool, lazy const(char)[])

Uses:

• Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_newclass
• _adDupT
• _d_throwc

void std.exception.__assert(int)

Uses:

• _d_assertm

void std.outbuffer.__unittest_fail(int)

Uses:

• _d_unittestm

std.outbuffer.__array

Uses:

• _d_array_bounds

void std.outbuffer.__assert(int)

Uses:

• _d_assertm

void std.outbuffer.OutBuffer.__invariant()

void std.outbuffer.OutBuffer.fill0(ulong)

void std.outbuffer.OutBuffer.write(const(ubyte)[])

Uses:

• memcpy@plt

void std.outbuffer.OutBuffer.write(const(dchar)[])

Uses:

• _d_arraycast

void std.outbuffer.OutBuffer.write(std.outbuffer.OutBuffer)

void std.outbuffer.OutBuffer.write(char)

void std.outbuffer.OutBuffer.write(double)

void std.outbuffer.OutBuffer.write(real)

void std.outbuffer.OutBuffer.write(float)

void std.outbuffer.OutBuffer.write(byte)

void std.outbuffer.OutBuffer.write(ubyte)

void std.outbuffer.OutBuffer.write(int)

void std.outbuffer.OutBuffer.write(uint)

void std.outbuffer.OutBuffer.write(long)

void std.outbuffer.OutBuffer.write(ulong)

void std.outbuffer.OutBuffer.write(short)

void std.outbuffer.OutBuffer.write(ushort)

void std.outbuffer.OutBuffer.write(wchar)

void std.outbuffer.OutBuffer.write(dchar)

void std.outbuffer.OutBuffer.write(const(char[]))

void std.outbuffer.OutBuffer.write(const(wchar[]))

Uses:

• _d_arraycast

std.outbuffer.OutBuffer std.outbuffer.OutBuffer.__ctor()

void std.outbuffer.OutBuffer.align2()

void std.outbuffer.OutBuffer.align4()

extern (C) void std.outbuffer.OutBuffer.printf(immutable(char)[], ...)

Uses:

• void core.stdc.stdarg.va_start!(core.stdc.stdarg.__va_argsave_t).va_start(out void*, ref core.stdc.stdarg.__va_argsave_t)
• void core.stdc.stdarg.va_end(void*)

void std.outbuffer.OutBuffer.spread(ulong, ulong)

void std.outbuffer.OutBuffer.reserve(ulong)

Uses:

• uint core.memory.GC.clrAttr(const(void*), uint)
• _d_arraysetlengthT

ubyte[] std.outbuffer.OutBuffer.toBytes()

void std.outbuffer.OutBuffer.vprintf(immutable(char)[], void*)

Uses:

• __alloca
• pure nothrow immutable(char)* std.string.toStringz(immutable(char)[])
• vsnprintf@plt

immutable(char)[] std.outbuffer.OutBuffer.toString()

Uses:

• _adDupT

void std.outbuffer.OutBuffer.alignSize(ulong)

void std.stdiobase.__modsharedctor()

Uses:

• void std.stdiobase._sharedStaticCtor28()

void std.stdiobase.__unittest_fail(int)

Uses:

• _d_unittestm

void std.stdiobase._sharedStaticCtor28()

Used by:

• void std.stdiobase.__modsharedctor()

Uses:

• std_stdio_static_this

std.stdiobase.__array

Uses:

• _d_array_bounds

void std.stdiobase.__assert(int)

Uses:

• _d_assertm

void std.typetuple.__unittest_fail(int)

Uses:

• _d_unittestm

std.typetuple.__array

Uses:

• _d_array_bounds

void std.typetuple.__assert(int)

Uses:

• _d_assertm

void core.stdc.stdarg.va_start!(core.stdc.stdarg.__va_argsave_t).va_start(out void*, ref core.stdc.stdarg.__va_argsave_t)

Used by:

• extern (C) void std.outbuffer.OutBuffer.printf(immutable(char)[], ...)

void core.stdc.stdarg.va_end(void*)

Used by:

• extern (C) void std.outbuffer.OutBuffer.printf(immutable(char)[], ...)

void core.sync.mutex.__unittest_fail(int)

Uses:

• _d_unittestm

void core.sync.mutex.Mutex.lock()

Uses:

• pthread_mutex_lock@plt
• core.sync.exception.SyncException core.sync.exception.SyncException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_newclass
• _d_throwc

core.sync.mutex.Mutex core.sync.mutex.Mutex.__ctor()

Used by:

• @property core.sync.mutex.Mutex core.thread.Thread.slock()

Uses:

• pthread_mutexattr_init@plt
• pthread_mutexattr_settype@plt
• core.sync.exception.SyncException core.sync.exception.SyncException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• pthread_mutex_init@plt
• _d_newclass
• pthread_mutexattr_destroy@plt
• _d_throwc

void core.sync.mutex.Mutex.__dtor()

Uses:

• pthread_mutex_destroy@plt

void core.sync.mutex.Mutex.unlock()

Uses:

• pthread_mutex_unlock@plt
• core.sync.exception.SyncException core.sync.exception.SyncException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_newclass
• _d_throwc

core.sync.mutex.Mutex.__Class

Used by:

• @property core.sync.mutex.Mutex core.thread.Thread.slock()

bool core.sync.mutex.Mutex.tryLock()

Uses:

• pthread_mutex_trylock@plt

core.sync.mutex.__array

Uses:

• _d_array_bounds

void core.sync.mutex.__assert(int)

Uses:

• _d_assertm

core.sync.exception.SyncException core.sync.exception.SyncException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)

Used by:

• void core.sync.mutex.Mutex.unlock()
• core.sync.mutex.Mutex core.sync.mutex.Mutex.__ctor()
• void core.sync.mutex.Mutex.lock()

void core.sync.exception.__unittest_fail(int)

Uses:

• _d_unittestm

core.sync.exception.__array

Uses:

• _d_array_bounds

void core.sync.exception.__assert(int)

Uses:

• _d_assertm

immutable(long) core.time.TickDuration.ticksPerSec

Used by:

• @trusted void core.time.TickDuration._sharedStaticCtor7()
• @property @trusted core.time.TickDuration core.time.TickDuration.currSystemTick()

@property @trusted core.time.TickDuration core.time.TickDuration.currSystemTick()

Used by:

• @trusted void core.time.TickDuration._sharedStaticCtor7()

Uses:

• immutable(long) core.time.TickDuration.ticksPerSec
• nothrow core.time.TimeException core.time.TimeException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• clock_gettime@plt
• _d_newclass
• _d_throwc

@trusted void core.time.TickDuration._sharedStaticCtor7()

Used by:

• void core.time.__modsharedctor()

Uses:

• immutable(long) core.time.TickDuration.ticksPerSec
• immutable(core.time.TickDuration) core.time.TickDuration.appOrigin
• @property @trusted core.time.TickDuration core.time.TickDuration.currSystemTick()
• clock_getres@plt

immutable(core.time.TickDuration) core.time.TickDuration.appOrigin

Used by:

• @trusted void core.time.TickDuration._sharedStaticCtor7()

nothrow core.time.TimeException core.time.TimeException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)

Used by:

• @property @trusted core.time.TickDuration core.time.TickDuration.currSystemTick()

void core.time.__modsharedctor()

Uses:

• @trusted void core.time.TickDuration._sharedStaticCtor7()

void core.time.__unittest_fail(int)

Uses:

• _d_unittestm

pure nothrow @safe core.time.Duration core.time.dur!("hnsecs").dur(long)

Used by:

• const(nothrow core.time.Duration function(long)) std.datetime.TimeZone.utcOffsetAt
• const(nothrow core.time.Duration function(long)) std.datetime.UTC.utcOffsetAt

pure nothrow @safe core.time.Duration core.time.dur!("minutes").dur(long)

Used by:

• const(nothrow core.time.Duration function(long)) std.datetime.SimpleTimeZone.utcOffsetAt

Uses:

• pure nothrow @safe core.time.Duration core.time.Duration.__ctor(long)
• pure nothrow @safe long core.time.convert!("minutes", "hnsecs").convert(long)

pure nothrow @safe long core.time.convert!("days", "seconds").convert(long)

Used by:

• const(nothrow long function(long)) std.datetime.LocalTime.tzToUTC
• const(nothrow long function(long)) std.datetime.PosixTimeZone.tzToUTC

pure nothrow @safe long core.time.convert!("hours", "seconds").convert(long)

Used by:

• const(nothrow long function(long)) std.datetime.LocalTime.tzToUTC
• const(nothrow long function(long)) std.datetime.PosixTimeZone.tzToUTC

pure nothrow @safe long core.time.convert!("hnsecs", "seconds").convert(long)

Used by:

• pure nothrow long std.datetime.stdTimeToUnixTime(long)

pure nothrow @safe long core.time.convert!("minutes", "hnsecs").convert(long)

Used by:

• const(nothrow long function(long)) std.datetime.SimpleTimeZone.utcToTZ
• pure nothrow @safe core.time.Duration core.time.dur!("minutes").dur(long)
• const(nothrow long function(long)) std.datetime.SimpleTimeZone.tzToUTC

pure nothrow @safe long core.time.convert!("seconds", "hnsecs").convert(long)

Used by:

• const(nothrow long function(long)) std.datetime.LocalTime.tzToUTC
• const(nothrow long function(long)) std.datetime.PosixTimeZone.utcToTZ
• const(nothrow long function(long)) std.datetime.LocalTime.utcToTZ
• const(nothrow long function(long)) std.datetime.PosixTimeZone.tzToUTC

core.time.__array

Uses:

• _d_array_bounds

pure nothrow @safe core.time.Duration core.time.Duration.__ctor(long)

Used by:

• pure nothrow @safe core.time.Duration core.time.dur!("minutes").dur(long)

void core.time.__assert(int)

Uses:

• _d_assertm

bool core.atomic.cas!(ulong, shared(ulong), shared(ulong)).cas(shared(ulong)*, shared(const(ulong)), shared(const(ulong)))

Used by:

• shared(ulong) core.atomic.atomicOp!("-=", shared(ulong), ulong).atomicOp(ref shared(ulong), ulong)

shared(ulong) core.atomic.atomicOp!("-=", shared(ulong), ulong).atomicOp(ref shared(ulong), ulong)

Used by:

• _d_monitordelete

Uses:

• shared(ulong) core.atomic.__T10atomicLoadVE4core6atomic5msync0TOmZ.atomicLoad(ref shared(const(ulong)))
• bool core.atomic.cas!(ulong, shared(ulong), shared(ulong)).cas(shared(ulong)*, shared(const(ulong)), shared(const(ulong)))

shared(ulong) core.atomic.__T10atomicLoadVE4core6atomic5msync0TOmZ.atomicLoad(ref shared(const(ulong)))

Used by:

• shared(ulong) core.atomic.atomicOp!("-=", shared(ulong), ulong).atomicOp(ref shared(ulong), ulong)

void* core.memory.GC.malloc(ulong, uint)

Used by:

• char[] std.array.arrayAllocImpl!(false, char[], ulong).arrayAllocImpl(ulong)

Uses:

• gc_malloc

uint core.memory.GC.clrAttr(const(void*), uint)

Used by:

• void std.outbuffer.OutBuffer.reserve(ulong)

Uses:

• gc_clrAttr

uint core.thread.suspendDepth

Used by:

• thread_suspendAll
• void core.thread.Thread.add(core.thread.Thread.Context*)
• void core.thread.Thread.add(core.thread.Thread)
• thread_resumeAll

extern (C) void core.thread.thread_joinAll().int __foreachbody284(ref core.thread.Thread)

Uses:

• @property bool core.thread.Thread.isRunning()
• void core.thread.Thread.remove(core.thread.Thread)
• @property bool core.thread.Thread.isDaemon()

core.thread.ThreadException core.thread.ThreadException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)

Used by:

• extern (C) void core.thread.thread_suspendAll().void suspend(core.thread.Thread)
• extern (C) void core.thread.thread_resumeAll().void resume(core.thread.Thread)
• object.Throwable core.thread.Thread.join(bool)

void core.thread.__modsharedctor()

Uses:

• void core.thread.Thread._sharedStaticCtor3()
• void core.thread._sharedStaticCtor5()

void core.thread.__modshareddtor()

Uses:

• void core.thread._sharedStaticDtor4()

void core.thread.__unittest_fail(int)

Uses:

• _d_unittestm

extern (C) void core.thread.thread_resumeAll().void resume(core.thread.Thread)

Used by:

• thread_resumeAll

Uses:

• pthread_self@plt
• @property bool core.thread.Thread.isRunning()
• core.thread.ThreadException core.thread.ThreadException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• void core.thread.Thread.remove(core.thread.Thread)
• _d_newclass
• pthread_kill@plt
• _d_throwc

bool core.thread.multiThreadedFlag

Used by:

• thread_attachThis
• thread_needLock
• thread_suspendAll
• thread_resumeAll

extern (C) void core.thread.thread_suspendAll().void suspend(core.thread.Thread)

Used by:

• thread_suspendAll

Uses:

• pthread_self@plt
• @property bool core.thread.Thread.isRunning()
• core.thread.ThreadException core.thread.ThreadException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• sem_wait@plt
• void core.thread.Thread.remove(core.thread.Thread)
• _d_newclass
• rt_stackTop
• pthread_kill@plt
• _d_throwc

void core.thread._sharedStaticCtor5()

Used by:

• void core.thread.__modsharedctor()

Uses:

• sysconf@plt
• const(ulong) core.thread.PAGESIZE

void core.thread._sharedStaticDtor4()

Used by:

• void core.thread.__modshareddtor()

Uses:

• core.thread.Thread core.thread.Thread.sm_tbeg
• @property bool core.thread.Thread.isRunning()
• void core.thread.Thread.remove(core.thread.Thread)

void core.thread.Fiber._staticCtor6()

Used by:

• void core.thread.__modctor()

core.thread.Fiber core.thread.Fiber.__ctor()

void core.thread.Fiber.__dtor()

Uses:

• void core.thread.Thread.remove(core.thread.Thread.Context*)
• munmap@plt

const(int) core.thread.Thread.PRIORITY_MAX

Used by:

• void core.thread.Thread._sharedStaticCtor3()

const(int) core.thread.Thread.PRIORITY_MIN

Used by:

• void core.thread.Thread._sharedStaticCtor3()

void core.thread.Thread._sharedStaticCtor3()

Used by:

• void core.thread.__modsharedctor()

Uses:

• sched_get_priority_min@plt
• pthread_self@plt
• const(int) core.thread.Thread.PRIORITY_MAX
• sched_get_priority_max@plt
• pthread_getschedparam@plt
• const(int) core.thread.Thread.PRIORITY_MIN

void core.thread.Thread.add(core.thread.Thread)

Used by:

• thread_attachThis

Uses:

• _d_monitorenter
• core.thread.Thread core.thread.Thread.sm_tbeg
• ulong core.thread.Thread.sm_tlen
• uint core.thread.suspendDepth
• sched_yield@plt
• @property core.sync.mutex.Mutex core.thread.Thread.slock()
• _d_monitorexit

void core.thread.Thread.add(core.thread.Thread.Context*)

Used by:

• thread_attachThis

Uses:

• _d_monitorenter
• uint core.thread.suspendDepth
• sched_yield@plt
• @property core.sync.mutex.Mutex core.thread.Thread.slock()
• _d_monitorexit
• core.thread.Thread.Context* core.thread.Thread.sm_cbeg
• ulong core.thread.Thread.sm_clen

object.Throwable core.thread.Thread.join(bool)

Used by:

• thread_joinAll

Uses:

• core.thread.ThreadException core.thread.ThreadException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_newclass
• pthread_join@plt
• _d_throwc

@property core.sync.mutex.Mutex core.thread.Thread.slock()

Used by:

• int core.thread.Thread.opApply(scope int delegate(ref core.thread.Thread))
• void core.thread.Thread.remove(core.thread.Thread)
• thread_suspendAll
• void core.thread.Thread.add(core.thread.Thread.Context*)
• void core.thread.Thread.remove(core.thread.Thread.Context*)
• void core.thread.Thread.add(core.thread.Thread)
• thread_resumeAll

Uses:

• core.sync.mutex.Mutex.__Class
• malloc@plt
• core.thread.Thread.slock.FNdZC4core4sync5mutex5Mutex1mC4core4sync5mutex5Mutex
• memcpy@plt
• core.sync.mutex.Mutex core.sync.mutex.Mutex.__ctor()

core.thread.Thread.slock.FNdZC4core4sync5mutex5Mutex1mC4core4sync5mutex5Mutex

Used by:

• @property core.sync.mutex.Mutex core.thread.Thread.slock()

core.thread.Thread core.thread.Thread.__ctor()

Used by:

• thread_attachThis

Uses:

• _DYNAMIC

void core.thread.Thread.__dtor()

Uses:

• pthread_detach@plt

void core.thread.Thread.remove(core.thread.Thread)

Used by:

• extern (C) void core.thread.thread_joinAll().int __foreachbody284(ref core.thread.Thread)
• extern (C) void core.thread.thread_suspendAll().void suspend(core.thread.Thread)
• extern (C) void core.thread.thread_resumeAll().void resume(core.thread.Thread)
• void core.thread._sharedStaticDtor4()
• thread_suspendAll

Uses:

• _d_monitorenter
• core.thread.Thread core.thread.Thread.sm_tbeg
• ulong core.thread.Thread.sm_tlen
• @property core.sync.mutex.Mutex core.thread.Thread.slock()
• void core.thread.Thread.remove(core.thread.Thread.Context*)
• bool object.opEquals(Object, Object)
• _d_monitorexit

void core.thread.Thread.remove(core.thread.Thread.Context*)

Used by:

• void core.thread.Fiber.__dtor()
• void core.thread.Thread.remove(core.thread.Thread)

Uses:

• _d_monitorenter
• @property core.sync.mutex.Mutex core.thread.Thread.slock()
• _d_monitorexit
• core.thread.Thread.Context* core.thread.Thread.sm_cbeg
• ulong core.thread.Thread.sm_clen

int core.thread.Thread.opApply(scope int delegate(ref core.thread.Thread))

Used by:

• thread_joinAll

Uses:

• _d_monitorenter
• core.thread.Thread core.thread.Thread.sm_tbeg
• @property core.sync.mutex.Mutex core.thread.Thread.slock()
• _d_monitorexit

core.thread.Thread.Context* core.thread.Thread.sm_cbeg

Used by:

• void core.thread.Thread.add(core.thread.Thread.Context*)
• void core.thread.Thread.remove(core.thread.Thread.Context*)
• thread_scanAll

ulong core.thread.Thread.sm_clen

Used by:

• void core.thread.Thread.add(core.thread.Thread.Context*)
• void core.thread.Thread.remove(core.thread.Thread.Context*)

core.thread.Thread core.thread.Thread.sm_main

Used by:

• thread_attachThis
• thread_init

core.thread.Thread core.thread.Thread.sm_tbeg

Used by:

• int core.thread.Thread.opApply(scope int delegate(ref core.thread.Thread))
• thread_processGCMarks
• void core.thread._sharedStaticDtor4()
• void core.thread.Thread.remove(core.thread.Thread)
• thread_suspendAll
• void core.thread.Thread.add(core.thread.Thread)
• thread_resumeAll
• thread_scanAll

uint core.thread.Thread.sm_this

Used by:

• thread_attachThis
• thread_suspendAll
• thread_stackBottom
• thread_resumeAll
• thread_scanAll
• thread_suspendHandler

ulong core.thread.Thread.sm_tlen

Used by:

• void core.thread.Thread.remove(core.thread.Thread)
• void core.thread.Thread.add(core.thread.Thread)

@property bool core.thread.Thread.isDaemon()

Used by:

• extern (C) void core.thread.thread_joinAll().int __foreachbody284(ref core.thread.Thread)

Uses:

• _d_monitorenter
• _d_monitorexit

@property bool core.thread.Thread.isRunning()

Used by:

• extern (C) void core.thread.thread_joinAll().int __foreachbody284(ref core.thread.Thread)
• extern (C) void core.thread.thread_suspendAll().void suspend(core.thread.Thread)
• extern (C) void core.thread.thread_resumeAll().void resume(core.thread.Thread)
• void core.thread._sharedStaticDtor4()
• thread_suspendAll

core.thread.__array

Uses:

• _d_array_bounds

const(ulong) core.thread.PAGESIZE

Used by:

• void core.thread._sharedStaticCtor5()

void core.thread.__assert(int)

Uses:

• _d_assertm

void core.thread.__modctor()

Uses:

• void core.thread.Fiber._staticCtor6()

void core.runtime._staticCtor2()

Used by:

• void core.runtime.__modctor()

Uses:

• rt_setTraceHandler

void core.runtime.__unittest_fail(int)

Uses:

• _d_unittestm

extern (C) bool core.runtime.runModuleUnitTests().int __foreachbody265(ref object.ModuleInfo*)

Uses:

• pure nothrow @property void function()* object.ModuleInfo.unitTest()
• write@plt

extern (C) bool core.runtime.runModuleUnitTests().extern (C) void unittestSegvHandler(int, core.sys.posix.signal.siginfo_t*, void*)

Uses:

• backtrace@plt
• backtrace_symbols_fd@plt

core.runtime.runModuleUnitTests.UZb7Console6opCallMFxAaZSrunModuleUnitTests7Console

Uses:

• write@plt

object.Throwable.TraceInfo core.runtime.defaultTraceHandler(void*)

Uses:

• _d_newclass
• core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo6__ctorMFZC4core7runtime19defaultTraceHandlerFPvZC6object9Throwable9TraceInfo16DefaultTraceInfo

core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo6__ctorMFZC4core7runtime19defaultTraceHandlerFPvZC6object9Throwable9TraceInfo16DefaultTraceInfo

Used by:

• object.Throwable.TraceInfo core.runtime.defaultTraceHandler(void*)

Uses:

• core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo6__ctorMFZC4core7runtime19defaultTraceHandlerFPvZC6object9Throwable9TraceInfo16DefaultTraceInfo10getBasePtrFZPPv
• thread_stackBottom
• backtrace_symbols@plt

core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo6__ctorMFZC4core7runtime19defaultTraceHandlerFPvZC6object9Throwable9TraceInfo16DefaultTraceInfo10getBasePtrFZPPv

Used by:

• core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo6__ctorMFZC4core7runtime19defaultTraceHandlerFPvZC6object9Throwable9TraceInfo16DefaultTraceInfo

core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo6__dtorMFZv

Uses:

• free@plt

core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo7fixlineMFAaZAa

Used by:

• core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo7opApplyMFMDFKmKAaZiZi

Uses:

• memchr@plt
• char[] core.demangle.Demangle.opCall()
• memcpy@plt

core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo7opApplyMFMDFKAaZiZi

core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo7opApplyMFMDFKAaZiZi13__dgliteral29MFKmKAaZi

core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo7opApplyMFMDFKmKAaZiZi

Uses:

• strlen@plt
• core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo7fixlineMFAaZAa

core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo8toStringMFZAya

core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo8toStringMFZAya16__foreachbody266MFKmKAaZi

Uses:

• _d_arraycatT
• _d_arrayappendT

bool function()* core.runtime.Runtime.sm_moduleUnitTester

Used by:

• runModuleUnitTests

core.runtime.__array

Uses:

• _d_array_bounds

void core.runtime.__assert(int)

Uses:

• _d_assertm

void core.runtime.__modctor()

Uses:

• void core.runtime._staticCtor2()

void core.demangle.__unittest_fail(int)

Uses:

• _d_unittestm

core.demangle.__array

Uses:

• _d_array_bounds

void core.demangle.Demangle.parseLName()

Used by:

• void core.demangle.Demangle.parseSymbolName()
• void core.demangle.Demangle.parseTemplateInstanceName()

Uses:

• void core.demangle.Demangle.error(immutable(char)[])
• const(char)[] core.demangle.Demangle.sliceNumber()
• ulong core.demangle.Demangle.decodeNumber(const(char)[])
• char core.demangle.Demangle.tok()
• char[] core.demangle.Demangle.put(const(char)[])

void core.demangle.Demangle.parseValue(char[], char)

Used by:

• void core.demangle.Demangle.parseTemplateArgs()

Uses:

• void core.demangle.Demangle.error(immutable(char)[])
• ubyte core.demangle.Demangle.ascii2hex(char)
• void core.demangle.Demangle.parseIntegerValue(char[], char)
• const(char)[] core.demangle.Demangle.sliceNumber()
• ulong core.demangle.Demangle.decodeNumber(const(char)[])
• char core.demangle.Demangle.tok()
• char[] core.demangle.Demangle.put(const(char)[])
• void core.demangle.Demangle.parseReal()

const(char)[] core.demangle.Demangle.sliceNumber()

Used by:

• void core.demangle.Demangle.parseTemplateInstanceName()
• void core.demangle.Demangle.parseValue(char[], char)
• void core.demangle.Demangle.parseLName()
• bool core.demangle.Demangle.mayBeTemplateInstanceName()
• void core.demangle.Demangle.parseIntegerValue(char[], char)
• char[] core.demangle.Demangle.parseType(char[])

Uses:

• void core.demangle.Demangle.error(immutable(char)[])
• char core.demangle.Demangle.tok()

ulong core.demangle.Demangle.decodeNumber(const(char)[])

Used by:

• void core.demangle.Demangle.parseTemplateInstanceName()
• void core.demangle.Demangle.parseValue(char[], char)
• void core.demangle.Demangle.parseLName()
• bool core.demangle.Demangle.mayBeTemplateInstanceName()
• void core.demangle.Demangle.parseIntegerValue(char[], char)

Uses:

• void core.demangle.Demangle.error(immutable(char)[])

core.demangle.Demangle.ParseException.__Class

Used by:

• void core.demangle.Demangle.error(immutable(char)[])

void core.demangle.Demangle.parseSymbolName()

Used by:

• char[] core.demangle.Demangle.parseQualifiedName()

Uses:

• void core.demangle.Demangle.error(immutable(char)[])
• void core.demangle.Demangle.parseTemplateInstanceName()
• bool core.demangle.Demangle.mayBeTemplateInstanceName()
• void core.demangle.Demangle.parseLName()
• char core.demangle.Demangle.tok()

void core.demangle.Demangle.parseMangledName()

Used by:

• char[] core.demangle.Demangle.opCall()

Uses:

• void core.demangle.Demangle.error(immutable(char)[])
• char[] core.demangle.Demangle.parseQualifiedName()
• char core.demangle.Demangle.tok()
• char[] core.demangle.Demangle.parseType(char[])
• char[] core.demangle.Demangle.put(const(char)[])

core.demangle.Demangle.OverflowException.__Class

Used by:

• void core.demangle.Demangle.overflow(immutable(char)[])

void core.demangle.Demangle.parseIntegerValue(char[], char)

Used by:

• void core.demangle.Demangle.parseValue(char[], char)

Uses:

• char[] core.demangle.Demangle.putAsHex(ulong, int)
• const(char)[] core.demangle.Demangle.sliceNumber()
• ulong core.demangle.Demangle.decodeNumber(const(char)[])
• char[] core.demangle.Demangle.put(const(char)[])

void core.demangle.Demangle.parseTemplateArgs()

Used by:

• void core.demangle.Demangle.parseTemplateInstanceName()

Uses:

• void core.demangle.Demangle.error(immutable(char)[])
• char[] core.demangle.Demangle.parseQualifiedName()
• void core.demangle.Demangle.parseValue(char[], char)
• char[] core.demangle.Demangle.put(const(char)[])
• char[] core.demangle.Demangle.parseType(char[])
• char core.demangle.Demangle.tok()

void core.demangle.Demangle.parseTemplateArgs().void __dgliteral262()

Uses:

• char[] core.demangle.Demangle.parseType(char[])

char[] core.demangle.Demangle.parseTypeFunction(char[], core.demangle.Demangle.IsDelegate)

Used by:

• char[] core.demangle.Demangle.parseType(char[])

Uses:

• void core.demangle.Demangle.error(immutable(char)[])
• char[] core.demangle.Demangle.shift(const(char)[])
• char core.demangle.Demangle.tok()
• char[] core.demangle.Demangle.put(const(char)[])
• char[] core.demangle.Demangle.parseType(char[])
• _d_throwc

char[] core.demangle.Demangle.parseQualifiedName()

Used by:

• void core.demangle.Demangle.parseMangledName()
• char[] core.demangle.Demangle.parseType(char[])
• void core.demangle.Demangle.parseTemplateArgs()

Uses:

• void core.demangle.Demangle.parseSymbolName()
• char[] core.demangle.Demangle.put(const(char)[])
• char core.demangle.Demangle.tok()

bool core.demangle.Demangle.mayBeTemplateInstanceName()

Used by:

• void core.demangle.Demangle.parseSymbolName()

Uses:

• const(char)[] core.demangle.Demangle.sliceNumber()
• ulong core.demangle.Demangle.decodeNumber(const(char)[])

void core.demangle.Demangle.parseTemplateInstanceName()

Used by:

• void core.demangle.Demangle.parseSymbolName()

Uses:

• void core.demangle.Demangle.error(immutable(char)[])
• const(char)[] core.demangle.Demangle.sliceNumber()
• ulong core.demangle.Demangle.decodeNumber(const(char)[])
• void core.demangle.Demangle.parseLName()
• void core.demangle.Demangle.match(const(char)[])
• char[] core.demangle.Demangle.put(const(char)[])
• void core.demangle.Demangle.parseTemplateArgs()
• char core.demangle.Demangle.tok()
• _d_throwc

void core.demangle.Demangle.pad(const(char)[])

Used by:

• char[] core.demangle.Demangle.parseType(char[])

Uses:

• char[] core.demangle.Demangle.append(const(char)[])
• char[] core.demangle.Demangle.put(const(char)[])

char[] core.demangle.Demangle.put(const(char)[])

Used by:

• char[] core.demangle.Demangle.parseTypeFunction(char[], core.demangle.Demangle.IsDelegate)
• char[] core.demangle.Demangle.parseQualifiedName()
• void core.demangle.Demangle.parseTemplateInstanceName()
• void core.demangle.Demangle.parseValue(char[], char)
• char[] core.demangle.Demangle.putAsHex(ulong, int)
• void core.demangle.Demangle.parseMangledName()
• void core.demangle.Demangle.parseLName()
• void core.demangle.Demangle.parseIntegerValue(char[], char)
• char[] core.demangle.Demangle.parseType(char[])
• void core.demangle.Demangle.pad(const(char)[])
• void core.demangle.Demangle.parseTemplateArgs()
• void core.demangle.Demangle.parseReal()

Uses:

• char[] core.demangle.Demangle.shift(const(char)[])
• char[] core.demangle.Demangle.append(const(char)[])

char core.demangle.Demangle.tok()

Used by:

• char[] core.demangle.Demangle.parseTypeFunction(char[], core.demangle.Demangle.IsDelegate)
• char[] core.demangle.Demangle.parseQualifiedName()
• void core.demangle.Demangle.parseSymbolName()
• void core.demangle.Demangle.parseTemplateInstanceName()
• void core.demangle.Demangle.parseValue(char[], char)
• void core.demangle.Demangle.parseMangledName()
• const(char)[] core.demangle.Demangle.sliceNumber()
• void core.demangle.Demangle.parseLName()
• char[] core.demangle.Demangle.parseType(char[])
• void core.demangle.Demangle.match(const(char)[])
• void core.demangle.Demangle.parseTemplateArgs()
• void core.demangle.Demangle.parseReal()

void core.demangle.Demangle.error(immutable(char)[])

Used by:

• char[] core.demangle.Demangle.parseTypeFunction(char[], core.demangle.Demangle.IsDelegate)
• ubyte core.demangle.Demangle.ascii2hex(char)
• void core.demangle.Demangle.parseSymbolName()
• void core.demangle.Demangle.parseTemplateInstanceName()
• void core.demangle.Demangle.parseValue(char[], char)
• void core.demangle.Demangle.parseMangledName()
• const(char)[] core.demangle.Demangle.sliceNumber()
• void core.demangle.Demangle.parseLName()
• ulong core.demangle.Demangle.decodeNumber(const(char)[])
• char[] core.demangle.Demangle.parseType(char[])
• void core.demangle.Demangle.match(const(char)[])
• void core.demangle.Demangle.parseTemplateArgs()
• void core.demangle.Demangle.parseReal()

Uses:

• core.demangle.Demangle.ParseException.__Class
• _d_throwc

void core.demangle.Demangle.match(const(char)[])

Used by:

• void core.demangle.Demangle.parseTemplateInstanceName()
• void core.demangle.Demangle.parseReal()

Uses:

• void core.demangle.Demangle.error(immutable(char)[])
• char core.demangle.Demangle.tok()

char[] core.demangle.Demangle.shift(const(char)[])

Used by:

• char[] core.demangle.Demangle.parseTypeFunction(char[], core.demangle.Demangle.IsDelegate)
• char[] core.demangle.Demangle.put(const(char)[])

Uses:

• char[] core.demangle.Demangle.shift(const(char)[]).void exch(ulong, ulong)

char[] core.demangle.Demangle.shift(const(char)[]).void exch(ulong, ulong)

Used by:

• char[] core.demangle.Demangle.shift(const(char)[])

char[] core.demangle.Demangle.append(const(char)[])

Used by:

• char[] core.demangle.Demangle.put(const(char)[])
• void core.demangle.Demangle.pad(const(char)[])

Uses:

• _d_arraysetlengthiT
• memcpy@plt
• void core.demangle.Demangle.overflow(immutable(char)[])

char[] core.demangle.Demangle.opCall()

Used by:

• core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo7fixlineMFAaZAa

Uses:

• _d_arraysetlengthiT
• void core.demangle.Demangle.parseMangledName()
• memcpy@plt

void core.demangle.Demangle.overflow(immutable(char)[])

Used by:

• char[] core.demangle.Demangle.append(const(char)[])

Uses:

• core.demangle.Demangle.OverflowException.__Class
• _d_throwc

char[] core.demangle.Demangle.putAsHex(ulong, int)

Used by:

• void core.demangle.Demangle.parseIntegerValue(char[], char)

Uses:

• char[] core.demangle.Demangle.put(const(char)[])

ubyte core.demangle.Demangle.ascii2hex(char)

Used by:

• void core.demangle.Demangle.parseValue(char[], char)

Uses:

• void core.demangle.Demangle.error(immutable(char)[])

void core.demangle.Demangle.parseReal()

Used by:

• void core.demangle.Demangle.parseValue(char[], char)

Uses:

• void core.demangle.Demangle.error(immutable(char)[])
• strtold@plt
• snprintf@plt
• char core.demangle.Demangle.tok()
• void core.demangle.Demangle.match(const(char)[])
• char[] core.demangle.Demangle.put(const(char)[])

char[] core.demangle.Demangle.parseType(char[])

Used by:

• char[] core.demangle.Demangle.parseTypeFunction(char[], core.demangle.Demangle.IsDelegate)
• void core.demangle.Demangle.parseTemplateArgs().void __dgliteral262()
• void core.demangle.Demangle.parseMangledName()
• void core.demangle.Demangle.parseTemplateArgs()

Uses:

• void core.demangle.Demangle.error(immutable(char)[])
• char[] core.demangle.Demangle.parseTypeFunction(char[], core.demangle.Demangle.IsDelegate)
• char[] core.demangle.Demangle.parseQualifiedName()
• const(char)[] core.demangle.Demangle.sliceNumber()
• char core.demangle.Demangle.tok()
• char[] core.demangle.Demangle.put(const(char)[])
• void core.demangle.Demangle.pad(const(char)[])

void core.demangle.__assert(int)

Uses:

• _d_assertm

core.exception.RangeError core.exception.RangeError.__ctor(immutable(char)[], ulong, object.Throwable)

Used by:

• onRangeError

core.exception.AssertError core.exception.AssertError.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)

Used by:

• onAssertErrorMsg
• core.exception.AssertError core.exception.AssertError.__ctor(immutable(char)[], ulong)

core.exception.AssertError core.exception.AssertError.__ctor(immutable(char)[], ulong)

Used by:

• onAssertError

Uses:

• core.exception.AssertError core.exception.AssertError.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)

core.exception.FinalizeError core.exception.FinalizeError.__ctor(TypeInfo_Class, immutable(char)[], ulong, object.Throwable)

Used by:

• onFinalizeError

immutable(char)[] core.exception.FinalizeError.toString()

Uses:

• _d_arraycatT

void function(immutable(char)[], ulong, immutable(char)[])* core.exception.assertHandler

Used by:

• onAssertErrorMsg
• onAssertError

void core.exception.__unittest_fail(int)

Uses:

• _d_unittestm

core.exception.OutOfMemoryError.__Class

Used by:

• onOutOfMemoryError

immutable(char)[] core.exception.OutOfMemoryError.toString()

Uses:

• immutable(char)[] object.Throwable.toString()

core.exception.InvalidMemoryOperationError.__Class

Used by:

• onInvalidMemoryOperationError

immutable(char)[] core.exception.InvalidMemoryOperationError.toString()

Uses:

• immutable(char)[] object.Throwable.toString()

core.exception.__array

Uses:

• _d_array_bounds

void core.exception.__assert(int)

Uses:

• _d_assertm

pure nothrow @property object.ModuleInfo*[] object.ModuleInfo.importedModules()

Used by:

• extern (C) void object._checkModCtors().bool printCycle(object.ModuleInfo*, object.ModuleInfo*, bool)
• extern (C) void object._checkModCtors().ulong _findDependencies(object.ModuleInfo*, bool)

pure nothrow @property void function()* object.ModuleInfo.ctor()

Used by:

• _checkModCtors
• _moduleCtor

pure nothrow @property void function()* object.ModuleInfo.dtor()

Used by:

• _checkModCtors
• _moduleDtor

pure nothrow @property immutable(char)[] object.ModuleInfo.name()

Used by:

• _d_assertm
• _d_unittestm
• _d_array_bounds
• extern (C) void object._checkModCtors().bool printCycle(object.ModuleInfo*, object.ModuleInfo*, bool)
• extern (C) void object._checkModCtors().bool _checkModCtors2(object.ModuleInfo*)

Uses:

• strlen@plt

pure nothrow @property void function()* object.ModuleInfo.ictor()

Used by:

• _moduleIndependentCtors

int object.ModuleInfo.opApply(scope int delegate(ref object.ModuleInfo*))

Used by:

• runModuleUnitTests

Uses:

• _moduleinfo_array

pure nothrow @property void function()* object.ModuleInfo.tlsctor()

Used by:

• _moduleTlsCtor
• _checkModCtors

pure nothrow @property void function()* object.ModuleInfo.tlsdtor()

Used by:

• _checkModCtors
• _moduleTlsDtor

pure nothrow @property void function()* object.ModuleInfo.unitTest()

Used by:

• extern (C) bool core.runtime.runModuleUnitTests().int __foreachbody265(ref object.ModuleInfo*)

object.Throwable.TraceInfo function(void*)* object.traceHandler

Used by:

• _d_traceContext
• rt_setTraceHandler

pure nothrow @property TypeInfo object.TypeInfo_Array.next()

void object.TypeInfo_Array.swap(void*, void*)

pure nothrow @property uint object.TypeInfo_Array.flags()

pure nothrow @property ulong object.TypeInfo_Array.tsize()

bool object.TypeInfo_Array.equals(const(void*), const(void*))

pure nothrow @property ulong object.TypeInfo_Array.talign()

int object.TypeInfo_Array.compare(const(void*), const(void*))

ulong object.TypeInfo_Array.getHash(const(void*))

Uses:

• ulong rt.util.hash.hashOf(const(void)*, ulong, ulong)

int object.TypeInfo_Array.argTypes(out TypeInfo, out TypeInfo)

bool object.TypeInfo_Array.opEquals(Object)

Uses:

• bool object.opEquals(TypeInfo, TypeInfo)
• _d_dynamic_cast

immutable(char)[] object.TypeInfo_Array.toString()

Uses:

• _d_arraycatT

const(object.MemberInfo[]) object.TypeInfo_Class.getMembers(const(char[]))

pure nothrow @property TypeInfo_Class object.TypeInfo_Class.info()

pure nothrow @property uint object.TypeInfo_Class.flags()

pure nothrow @property object.OffsetTypeInfo[] object.TypeInfo_Class.offTi()

pure nothrow @property ulong object.TypeInfo_Class.tsize()

Object object.TypeInfo_Class.create()

Uses:

• _d_newclass

bool object.TypeInfo_Class.equals(const(void*), const(void*))

int object.TypeInfo_Class.compare(const(void*), const(void*))

ulong object.TypeInfo_Class.getHash(const(void*))

bool object.TypeInfo_Class.opEquals(Object)

Uses:

• _adEq2
• _d_dynamic_cast

immutable(char)[] object.TypeInfo_Class.toString()

pure nothrow @property TypeInfo object.TypeInfo_Class.typeinfo()

pure nothrow void[] object.TypeInfo_Const.init()

pure nothrow @property TypeInfo object.TypeInfo_Const.next()

void object.TypeInfo_Const.swap(void*, void*)

pure nothrow @property uint object.TypeInfo_Const.flags()

pure nothrow @property ulong object.TypeInfo_Const.tsize()

bool object.TypeInfo_Const.equals(const(void*), const(void*))

pure nothrow @property ulong object.TypeInfo_Const.talign()

int object.TypeInfo_Const.compare(const(void*), const(void*))

ulong object.TypeInfo_Const.getHash(const(void*))

int object.TypeInfo_Const.argTypes(out TypeInfo, out TypeInfo)

bool object.TypeInfo_Const.opEquals(Object)

Uses:

• bool object.opEquals(TypeInfo, TypeInfo)
• _d_dynamic_cast

immutable(char)[] object.TypeInfo_Const.toString()

Uses:

• _d_arraycatnT

immutable(char)[] object.TypeInfo_Inout.toString()

Uses:

• _d_arraycatnT

void object.TypeInfo_Tuple.swap(void*, void*)

pure nothrow @property ulong object.TypeInfo_Tuple.tsize()

bool object.TypeInfo_Tuple.equals(const(void*), const(void*))

pure nothrow @property ulong object.TypeInfo_Tuple.talign()

int object.TypeInfo_Tuple.compare(const(void*), const(void*))

void object.TypeInfo_Tuple.destroy(void*)

ulong object.TypeInfo_Tuple.getHash(const(void*))

int object.TypeInfo_Tuple.argTypes(out TypeInfo, out TypeInfo)

bool object.TypeInfo_Tuple.opEquals(Object)

Uses:

• bool object.opEquals(TypeInfo, TypeInfo)
• _d_dynamic_cast

void object.TypeInfo_Tuple.postblit(void*)

immutable(char)[] object.TypeInfo_Tuple.toString()

Uses:

• _d_arrayappendcTX
• _d_arrayappendT

extern (C) void object._checkModCtors().bool printCycle(object.ModuleInfo*, object.ModuleInfo*, bool)

Used by:

• extern (C) void object._checkModCtors().bool _checkModCtors2(object.ModuleInfo*)

Uses:

• pure nothrow @property object.ModuleInfo*[] object.ModuleInfo.importedModules()
• pure nothrow @property immutable(char)[] object.ModuleInfo.name()
• extern (C) void object._checkModCtors().void println(immutable(char)[][]...)

extern (C) void object._checkModCtors().bool _checkModCtors2(object.ModuleInfo*)

Used by:

• extern (C) void object._checkModCtors().void _checkModCtors3()

Uses:

• __alloca
• rt.util.console.Console rt.util.console.Console.opCall(const(char[]))
• Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• extern (C) void object._checkModCtors().bool printCycle(object.ModuleInfo*, object.ModuleInfo*, bool)
• extern (C) void object._checkModCtors().ulong _findDependencies(object.ModuleInfo*, bool)
• _d_newclass
• _moduleinfo_array
• pure nothrow @property immutable(char)[] object.ModuleInfo.name()
• extern (C) void object._checkModCtors().void println(immutable(char)[][]...)
• _d_throwc

extern (C) void object._checkModCtors().void _checkModCtors3()

Used by:

• _checkModCtors

Uses:

• extern (C) void object._checkModCtors().bool _checkModCtors2(object.ModuleInfo*)
• _moduleinfo_array

extern (C) void object._checkModCtors().ulong _findDependencies(object.ModuleInfo*, bool)

Used by:

• extern (C) void object._checkModCtors().bool _checkModCtors2(object.ModuleInfo*)

Uses:

• pure nothrow @property object.ModuleInfo*[] object.ModuleInfo.importedModules()

extern (C) void object._checkModCtors().void println(immutable(char)[][]...)

Used by:

• extern (C) void object._checkModCtors().bool printCycle(object.ModuleInfo*, object.ModuleInfo*, bool)
• extern (C) void object._checkModCtors().bool _checkModCtors2(object.ModuleInfo*)

Uses:

• rt.util.console.Console rt.util.console.Console.opCall(const(char[]))

immutable(char)[] object.TypeInfo_Shared.toString()

Uses:

• _d_arraycatnT

pure nothrow void[] object.TypeInfo_Struct.init()

pure nothrow @property uint object.TypeInfo_Struct.flags()

pure nothrow @property ulong object.TypeInfo_Struct.tsize()

bool object.TypeInfo_Struct.equals(const(void*), const(void*))

Uses:

• memcmp@plt

pure nothrow @property ulong object.TypeInfo_Struct.talign()

int object.TypeInfo_Struct.compare(const(void*), const(void*))

Uses:

• memcmp@plt

void object.TypeInfo_Struct.destroy(void*)

ulong object.TypeInfo_Struct.getHash(const(void*))

Uses:

• ulong rt.util.hash.hashOf(const(void)*, ulong, ulong)

int object.TypeInfo_Struct.argTypes(out TypeInfo, out TypeInfo)

bool object.TypeInfo_Struct.opEquals(Object)

Uses:

• _adEq2
• _d_dynamic_cast

void object.TypeInfo_Struct.postblit(void*)

immutable(char)[] object.TypeInfo_Struct.toString()

void object.__unittest_fail(int)

Uses:

• _d_unittestm

pure nothrow @property immutable(char)[] object.MemberInfo_field.name()

pure nothrow @property ulong object.MemberInfo_field.offset()

pure nothrow @property TypeInfo object.MemberInfo_field.typeInfo()

pure nothrow @property TypeInfo object.TypeInfo_Pointer.next()

void object.TypeInfo_Pointer.swap(void*, void*)

pure nothrow @property uint object.TypeInfo_Pointer.flags()

pure nothrow @property ulong object.TypeInfo_Pointer.tsize()

bool object.TypeInfo_Pointer.equals(const(void*), const(void*))

int object.TypeInfo_Pointer.compare(const(void*), const(void*))

ulong object.TypeInfo_Pointer.getHash(const(void*))

bool object.TypeInfo_Pointer.opEquals(Object)

Uses:

• bool object.opEquals(TypeInfo, TypeInfo)
• _d_dynamic_cast

immutable(char)[] object.TypeInfo_Pointer.toString()

Uses:

• _d_arraycatT

pure nothrow void[] object.TypeInfo_Typedef.init()

pure nothrow @property TypeInfo object.TypeInfo_Typedef.next()

void object.TypeInfo_Typedef.swap(void*, void*)

pure nothrow @property uint object.TypeInfo_Typedef.flags()

pure nothrow @property ulong object.TypeInfo_Typedef.tsize()

bool object.TypeInfo_Typedef.equals(const(void*), const(void*))

pure nothrow @property ulong object.TypeInfo_Typedef.talign()

int object.TypeInfo_Typedef.compare(const(void*), const(void*))

ulong object.TypeInfo_Typedef.getHash(const(void*))

int object.TypeInfo_Typedef.argTypes(out TypeInfo, out TypeInfo)

bool object.TypeInfo_Typedef.opEquals(Object)

Uses:

• _adEq2
• bool object.opEquals(TypeInfo, TypeInfo)
• _d_dynamic_cast

immutable(char)[] object.TypeInfo_Typedef.toString()

pure nothrow @property uint object.TypeInfo_Delegate.flags()

pure nothrow @property ulong object.TypeInfo_Delegate.tsize()

pure nothrow @property ulong object.TypeInfo_Delegate.talign()

int object.TypeInfo_Delegate.argTypes(out TypeInfo, out TypeInfo)

bool object.TypeInfo_Delegate.opEquals(Object)

Uses:

• _adEq2
• _d_dynamic_cast

immutable(char)[] object.TypeInfo_Delegate.toString()

Uses:

• _d_arraycatT

pure nothrow @property ulong object.TypeInfo_Function.tsize()

bool object.TypeInfo_Function.opEquals(Object)

Uses:

• _adEq2
• _d_dynamic_cast

immutable(char)[] object.TypeInfo_Function.toString()

Uses:

• _d_arraycatT

object.ModuleInfo*[] object._moduleinfo_dtors

Used by:

• _checkModCtors
• _moduleDtor
• _moduleCtor

pure nothrow @property uint object.TypeInfo_Interface.flags()

pure nothrow @property ulong object.TypeInfo_Interface.tsize()

bool object.TypeInfo_Interface.equals(const(void*), const(void*))

Uses:

• bool object.opEquals(Object, Object)

int object.TypeInfo_Interface.compare(const(void*), const(void*))

Uses:

• bool object.opEquals(Object, Object)

ulong object.TypeInfo_Interface.getHash(const(void*))

bool object.TypeInfo_Interface.opEquals(Object)

Uses:

• _adEq2
• _d_dynamic_cast

immutable(char)[] object.TypeInfo_Interface.toString()

immutable(char)[] object.TypeInfo_Invariant.toString()

Uses:

• _d_arraycatnT

pure nothrow @property void* object.MemberInfo_function.fp()

pure nothrow @property immutable(char)[] object.MemberInfo_function.name()

pure nothrow @property uint object.MemberInfo_function.flags()

pure nothrow @property TypeInfo object.MemberInfo_function.typeInfo()

ulong object._moduleinfo_dtors_i

Used by:

• _checkModCtors
• _moduleDtor
• _moduleCtor

pure nothrow void[] object.TypeInfo_StaticArray.init()

pure nothrow @property TypeInfo object.TypeInfo_StaticArray.next()

void object.TypeInfo_StaticArray.swap(void*, void*)

Uses:

• _d_newarrayT
• _d_delmemory
• memcpy@plt

pure nothrow @property uint object.TypeInfo_StaticArray.flags()

pure nothrow @property ulong object.TypeInfo_StaticArray.tsize()

bool object.TypeInfo_StaticArray.equals(const(void*), const(void*))

pure nothrow @property ulong object.TypeInfo_StaticArray.talign()

int object.TypeInfo_StaticArray.compare(const(void*), const(void*))

void object.TypeInfo_StaticArray.destroy(void*)

ulong object.TypeInfo_StaticArray.getHash(const(void*))

int object.TypeInfo_StaticArray.argTypes(out TypeInfo, out TypeInfo)

bool object.TypeInfo_StaticArray.opEquals(Object)

Uses:

• bool object.opEquals(TypeInfo, TypeInfo)
• _d_dynamic_cast

void object.TypeInfo_StaticArray.postblit(void*)

immutable(char)[] object.TypeInfo_StaticArray.toString()

Uses:

• char[] rt.util.string.intToString(char[], ulong)
• _d_arraycatT
• _d_arraycatnT

object.ModuleInfo*[] object._moduleinfo_tlsdtors

Used by:

• _moduleTlsCtor
• _checkModCtors
• _moduleTlsDtor

ulong object._moduleinfo_tlsdtors_i

Used by:

• _moduleTlsCtor
• _checkModCtors
• _moduleTlsDtor

pure nothrow @property TypeInfo object.TypeInfo_AssociativeArray.next()

pure nothrow @property uint object.TypeInfo_AssociativeArray.flags()

pure nothrow @property ulong object.TypeInfo_AssociativeArray.tsize()

pure nothrow @property ulong object.TypeInfo_AssociativeArray.talign()

int object.TypeInfo_AssociativeArray.argTypes(out TypeInfo, out TypeInfo)

bool object.TypeInfo_AssociativeArray.opEquals(Object)

Uses:

• bool object.opEquals(TypeInfo, TypeInfo)
• _d_dynamic_cast

immutable(char)[] object.TypeInfo_AssociativeArray.toString()

Uses:

• _d_arraycatnT

int object.Object.opCmp(Object)

Uses:

• Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_arraycatT
• _d_newclass
• _d_throwc

ulong object.Object.toHash()

bool object.Object.opEquals(Object, Object)

Uses:

• bool object.opEquals(TypeInfo, TypeInfo)

bool object.Object.opEquals(Object)

immutable(char)[] object.Object.toString()

object.__array

Uses:

• _d_array_bounds

pure nothrow void[] object.TypeInfo.init()

pure nothrow @property TypeInfo object.TypeInfo.next()

void object.TypeInfo.swap(void*, void*)

pure nothrow @property uint object.TypeInfo.flags()

object.OffsetTypeInfo[] object.TypeInfo.offTi()

int object.TypeInfo.opCmp(Object)

Uses:

• _d_dynamic_cast
• int rt.util.string.dstrcmp(const(char[]), const(char[]))

pure nothrow @property ulong object.TypeInfo.tsize()

bool object.TypeInfo.equals(const(void*), const(void*))

pure nothrow @property ulong object.TypeInfo.talign()

ulong object.TypeInfo.toHash()

Uses:

• ulong rt.util.hash.hashOf(const(void)*, ulong, ulong)

int object.TypeInfo.compare(const(void*), const(void*))

void object.TypeInfo.destroy(void*)

ulong object.TypeInfo.getHash(const(void*))

int object.TypeInfo.argTypes(out TypeInfo, out TypeInfo)

bool object.TypeInfo.opEquals(Object)

Uses:

• _adEq2
• _d_dynamic_cast

void object.TypeInfo.postblit(void*)

void object.__assert(int)

Uses:

• _d_assertm

bool object.opEquals(Object, Object)

Used by:

• bool object.TypeInfo_Interface.equals(const(void*), const(void*))
• void core.thread.Thread.remove(core.thread.Thread)
• int object.TypeInfo_Interface.compare(const(void*), const(void*))

bool object.opEquals(TypeInfo, TypeInfo)

Used by:

• bool object.Object.opEquals(Object, Object)
• bool object.TypeInfo_Pointer.opEquals(Object)
• bool object.TypeInfo_Const.opEquals(Object)
• bool object.TypeInfo_StaticArray.opEquals(Object)
• bool object.TypeInfo_Typedef.opEquals(Object)
• bool object.TypeInfo_Array.opEquals(Object)
• bool object.TypeInfo_AssociativeArray.opEquals(Object)
• bool object.TypeInfo_Tuple.opEquals(Object)

Uses:

• _d_dynamic_cast

Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)

Used by:

• _d_arraycopy
• extern (C) void object._checkModCtors().bool _checkModCtors2(object.ModuleInfo*)
• std.conv.ConvException std.conv.ConvException.__ctor(immutable(char)[], immutable(char)[], ulong)
• _d_arraycast
• int object.Object.opCmp(Object)
• pure @safe void std.exception.bailOut(immutable(char)[], ulong, const(char[]))
• std.format.FormatException std.format.FormatException.__ctor()

immutable(char)[] object.Throwable.toString()

Used by:

• immutable(char)[] core.exception.InvalidMemoryOperationError.toString()
• immutable(char)[] core.exception.OutOfMemoryError.toString()
• immutable(char)[] std.utf.UTFException.toString()

Uses:

• char[] rt.util.string.intToString(char[], ulong)
• _d_arraycatnT
• _d_arraycatT
• _d_arrayappendT

immutable(char)[] object.Throwable.toString().int __foreachbody217(ref char[])

Uses:

• _d_arraycatT
• _d_arrayappendT

_DYNAMIC

Used by:

• thread_attachThis
• @property rt.lifetime.BlkInfo* rt.lifetime.__blkcache()
• call_gmon_start
• core.thread.Thread core.thread.Thread.__ctor()
• rt_lifetimeInit
• void rt.lifetime._staticDtor9()
• rt.lifetime.BlkInfo* rt.lifetime.__getBlkInfo(void*)
• void rt.lifetime.__insertBlkInfoCache(rt.lifetime.BlkInfo, rt.lifetime.BlkInfo*)
• _d_throwc

_Dmain

Used by:

• extern (C) int rt.dmain2.main(int, char**).void runMain()

Uses:

• void std.stdio.writeln!(immutable(char)[]).writeln(immutable(char)[])

_Dmodule_ref

Used by:

• _moduleCtor

_STD_critical_term

Used by:

• main

Uses:

• rt.critical_.D_CRITICAL_SECTION* rt.critical_.dcs_list
• pthread_mutex_destroy@plt

_STD_monitor_staticdtor

Used by:

• main

Uses:

• pthread_mutex_destroy@plt
• int rt.monitor_.inited
• pthread_mutexattr_destroy@plt

_STI_critical_init

Used by:

• main

Uses:

• rt.critical_.D_CRITICAL_SECTION* rt.critical_.dcs_list
• pthread_mutexattr_init@plt
• pthread_mutexattr_settype@plt
• pthread_mutex_init@plt

_STI_monitor_staticctor

Used by:

• main

Uses:

• pthread_mutexattr_init@plt
• pthread_mutexattr_settype@plt
• pthread_mutex_init@plt
• int rt.monitor_.inited

_TMP249

_TMP250

_TMP251

_TMP407

_TMP408

__CTOR_LIST__

Used by:

• __do_global_ctors_aux

__JCR_END__

Used by:

• frame_dummy

__alloca

Used by:

• _checkModCtors
• extern (C) void object._checkModCtors().bool _checkModCtors2(object.ModuleInfo*)
• void std.outbuffer.OutBuffer.vprintf(immutable(char)[], void*)

__daylight@@GLIBC_2.2.5

Used by:

• const(nothrow @property bool function()) std.datetime.LocalTime.hasDST

__do_global_ctors_aux

Uses:

• __CTOR_LIST__

__do_global_dtors_aux

Used by:

• _fini

Uses:

• completed.6458
• dtor_idx.6460

__init_array_end

Used by:

• __libc_csu_init

__init_array_start

Used by:

• __libc_csu_init

__libc_csu_fini

__libc_csu_init

Uses:

• __init_array_start
• __init_array_end

__libc_stack_end@@GLIBC_2.2.5

Used by:

• rt_stackBottom

__libc_start_main@plt

Used by:

• _start

__tzname@@GLIBC_2.2.5

Used by:

• const(nothrow @property immutable(char)[] function()) std.datetime.LocalTime.stdName
• const(nothrow @property immutable(char)[] function()) std.datetime.LocalTime.dstName

_adDupT

Used by:

• immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint)
• immutable(char)[] std.outbuffer.OutBuffer.toString()
• immutable(char)[] std.conv.toImpl!(immutable(char)[], char[]).toImpl(char[])
• pure @safe void std.exception.bailOut(immutable(char)[], ulong, const(char[]))
• immutable(char)[] std.conv.toImpl!(immutable(char)[], const(char)*).toImpl(const(char)*)

Uses:

• bool rt.lifetime.__setArrayAllocLength(ref rt.lifetime.BlkInfo, ulong, bool, ulong)
• void rt.lifetime.__doPostblit(void*, ulong, TypeInfo)
• gc_qalloc
• memcpy@plt

_adEq2

Used by:

• bool object.TypeInfo_Delegate.opEquals(Object)
• bool object.TypeInfo_Typedef.opEquals(Object)
• bool object.TypeInfo_Function.opEquals(Object)
• bool object.TypeInfo_Interface.opEquals(Object)
• bool object.TypeInfo.opEquals(Object)
• bool object.TypeInfo_Class.opEquals(Object)
• bool object.TypeInfo_Struct.opEquals(Object)

_checkModCtors

Used by:

• _moduleCtor

Uses:

• __alloca
• pure nothrow @property void function()* object.ModuleInfo.dtor()
• ulong object._moduleinfo_tlsdtors_i
• _d_newarrayT
• ulong object._moduleinfo_dtors_i
• pure nothrow @property void function()* object.ModuleInfo.tlsctor()
• object.ModuleInfo*[] object._moduleinfo_dtors
• extern (C) void object._checkModCtors().void _checkModCtors3()
• pure nothrow @property void function()* object.ModuleInfo.tlsdtor()
• _moduleinfo_array
• pure nothrow @property void function()* object.ModuleInfo.ctor()
• object.ModuleInfo*[] object._moduleinfo_tlsdtors

_d_array_bounds

Used by:

• src.object_.d.207.__array
• std.algorithm.__array
• rt.lifetime.__array
• std.array.__array
• std.typetuple.__array
• core.thread.__array
• gc.gc.__array
• std.datetime.__array
• std.format.__array
• rt.typeinfo.ti_ubyte.__array
• src.rt.typeinfo.ti_Ag.d.1410.__array
• std.path.__array
• std.container.__array
• std.regex.__array
• core.time.__array
• std.outbuffer.__array
• std.typecons.__array
• std.stdiobase.__array
• std.stdio.__array
• std.ascii.__array
• src.core.atomic.d.212.__array
• rt.dmain2.__array
• std.exception.__array
• core.exception.__array
• std.traits.d.1741.__array
• core.demangle.__array
• object.__array
• rt.util.console.__array
• std.bitmanip.__array
• std.utf.__array
• src.core.atomic.d.215.__array
• src.core.atomic.d.211.__array
• std.math.__array
• rt.typeinfo.ti_char.__array
• std.file.__array
• std.string.__array
• rt.typeinfo.ti_byte.__array
• std.conv.__array
• rt.typeinfo.ti_void.__array
• rt.monitor_.__array
• std.range.__array
• rt.typeinfo.ti_Ag.__array
• gc.gcx.__array
• core.sync.exception.__array
• src.core.atomic.d.214.__array
• rt.deh2.__array
• core.runtime.__array
• std.process.__array
• std.traits.__array
• src.object_.d.168.__array
• core.sync.mutex.__array
• std.functional.__array
• rt.critical_.__array

Uses:

• onRangeError
• pure nothrow @property immutable(char)[] object.ModuleInfo.name()

_d_arrayappendT

Used by:

• immutable(char)[] object.TypeInfo_Tuple.toString()
• immutable(char)[] object.Throwable.toString()
• immutable(char)[] std.utf.UTFException.toString()
• immutable(char)[] object.Throwable.toString().int __foreachbody217(ref char[])
• core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo8toStringMFZAya16__foreachbody266MFKmKAaZi

Uses:

• void rt.lifetime.__doPostblit(void*, ulong, TypeInfo)
• _d_arrayappendcTX
• memcpy@plt

_d_arrayappendcTX

Used by:

• immutable(char)[] object.TypeInfo_Tuple.toString()
• _d_arrayappendT

Uses:

• bool rt.lifetime.__setArrayAllocLength(ref rt.lifetime.BlkInfo, ulong, bool, ulong)
• gc_query
• ulong rt.lifetime.newCapacity(ulong, ulong)
• gc_extend
• void rt.lifetime.__doPostblit(void*, ulong, TypeInfo)
• rt.lifetime.BlkInfo* rt.lifetime.__getBlkInfo(void*)
• void rt.lifetime.__insertBlkInfoCache(rt.lifetime.BlkInfo, rt.lifetime.BlkInfo*)
• gc_qalloc
• memcpy@plt

_d_arraycast

Used by:

• void std.outbuffer.OutBuffer.write(const(wchar[]))
• void std.outbuffer.OutBuffer.write(const(dchar)[])

Uses:

• Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_newclass
• _d_throwc

_d_arraycatT

Used by:

• immutable(char)[] core.exception.FinalizeError.toString()
• immutable(char)[] object.TypeInfo_Pointer.toString()
• immutable(char)[] object.Throwable.toString()
• immutable(char)[] object.TypeInfo_StaticArray.toString()
• immutable(char)[] object.TypeInfo_Delegate.toString()
• immutable(char)[] std.utf.UTFException.toString()
• int object.Object.opCmp(Object)
• immutable(char)[] object.TypeInfo_Array.toString()
• immutable(char)[] object.TypeInfo_Function.toString()
• immutable(char)[] object.Throwable.toString().int __foreachbody217(ref char[])
• core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo8toStringMFZAya16__foreachbody266MFKmKAaZi

Uses:

• bool rt.lifetime.__setArrayAllocLength(ref rt.lifetime.BlkInfo, ulong, bool, ulong)
• void rt.lifetime.__doPostblit(void*, ulong, TypeInfo)
• gc_qalloc
• memcpy@plt

_d_arraycatnT

Used by:

• immutable(char)[] object.TypeInfo_AssociativeArray.toString()
• immutable(char)[] object.TypeInfo_Invariant.toString()
• immutable(char)[] object.TypeInfo_Shared.toString()
• immutable(char)[] object.TypeInfo_Const.toString()
• immutable(char)[] object.Throwable.toString()
• immutable(char)[] object.TypeInfo_StaticArray.toString()
• immutable(char)[] object.TypeInfo_Inout.toString()

Uses:

• bool rt.lifetime.__setArrayAllocLength(ref rt.lifetime.BlkInfo, ulong, bool, ulong)
• void rt.lifetime.__doPostblit(void*, ulong, TypeInfo)
• gc_qalloc
• memcpy@plt

_d_arraycopy

Used by:

• pure nothrow @safe std.utf.UTFException std.utf.UTFException.setSequence(uint[]...)

Uses:

• Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_newclass
• _d_throwc
• memcpy@plt

_d_arraysetlengthT

Used by:

• void std.outbuffer.OutBuffer.reserve(ulong)

Uses:

• bool rt.lifetime.__setArrayAllocLength(ref rt.lifetime.BlkInfo, ulong, bool, ulong)
• gc_query
• gc_extend
• void rt.lifetime.__doPostblit(void*, ulong, TypeInfo)
• onOutOfMemoryError
• rt.lifetime.BlkInfo* rt.lifetime.__getBlkInfo(void*)
• void rt.lifetime.__insertBlkInfoCache(rt.lifetime.BlkInfo, rt.lifetime.BlkInfo*)
• gc_qalloc
• memcpy@plt

_d_arraysetlengthiT

Used by:

• char[] core.demangle.Demangle.opCall()
• char[] core.demangle.Demangle.append(const(char)[])

Uses:

• bool rt.lifetime.__setArrayAllocLength(ref rt.lifetime.BlkInfo, ulong, bool, ulong)
• gc_query
• gc_extend
• void rt.lifetime.__doPostblit(void*, ulong, TypeInfo)
• onOutOfMemoryError
• rt.lifetime.BlkInfo* rt.lifetime.__getBlkInfo(void*)
• void rt.lifetime.__insertBlkInfoCache(rt.lifetime.BlkInfo, rt.lifetime.BlkInfo*)
• gc_qalloc
• memcpy@plt

_d_assertm

Used by:

• src.core.atomic.d.211.__assert.FiZv
• src.object_.d.207.__assert.FiZv
• void std.range.__assert(int)
• src.core.atomic.d.214.__assert.FiZv
• void std.array.__assert(int)
• void object.__assert(int)
• void rt.typeinfo.ti_byte.__assert(int)
• void rt.dmain2.__assert(int)
• void rt.monitor_.__assert(int)
• void std.stdiobase.__assert(int)
• void rt.util.console.__assert(int)
• void core.runtime.__assert(int)
• src.rt.typeinfo.ti_Ag.d.1410.__assert.FiZv
• void rt.critical_.__assert(int)
• std.traits.d.1741.__assert.FiZv
• void gc.gcx.__assert(int)
• void std.conv.__assert(int)
• void std.format.__assert(int)
• void std.utf.__assert(int)
• void std.path.__assert(int)
• void std.stdio.__assert(int)
• void std.math.__assert(int)
• void gc.gc.__assert(int)
• void rt.typeinfo.ti_ubyte.__assert(int)
• void rt.typeinfo.ti_Ag.__assert(int)
• void std.traits.__assert(int)
• src.object_.d.168.__assert.FiZv
• void core.thread.__assert(int)
• void rt.typeinfo.ti_char.__assert(int)
• void core.demangle.__assert(int)
• void rt.lifetime.__assert(int)
• void std.container.__assert(int)
• void std.functional.__assert(int)
• void core.time.__assert(int)
• void core.sync.mutex.__assert(int)
• void std.typecons.__assert(int)
• void std.string.__assert(int)
• void rt.typeinfo.ti_void.__assert(int)
• src.core.atomic.d.212.__assert.FiZv
• void std.algorithm.__assert(int)
• src.core.atomic.d.215.__assert.FiZv
• void std.bitmanip.__assert(int)
• void rt.deh2.__assert(int)
• void std.exception.__assert(int)
• void std.regex.__assert(int)
• void std.process.__assert(int)
• void core.exception.__assert(int)
• void std.outbuffer.__assert(int)
• void std.typetuple.__assert(int)
• void std.datetime.__assert(int)
• void core.sync.exception.__assert(int)
• void std.file.__assert(int)
• void std.ascii.__assert(int)

Uses:

• pure nothrow @property immutable(char)[] object.ModuleInfo.name()
• onAssertError

_d_createTrace

Used by:

• _d_throwc

Uses:

• _d_traceContext

_d_delmemory

Used by:

• void object.TypeInfo_StaticArray.swap(void*, void*)

Uses:

• gc_free

_d_dynamic_cast

Used by:

• bool object.TypeInfo_Function.opEquals(Object)
• bool object.TypeInfo_Const.opEquals(Object)
• bool object.opEquals(TypeInfo, TypeInfo)
• bool object.TypeInfo_Array.opEquals(Object)
• bool object.TypeInfo_Pointer.opEquals(Object)
• void rt.lifetime.__doPostblit(void*, ulong, TypeInfo)
• int object.TypeInfo.opCmp(Object)
• _d_throwc
• bool object.TypeInfo_Struct.opEquals(Object)
• bool object.TypeInfo_Class.opEquals(Object)
• bool object.TypeInfo_Tuple.opEquals(Object)
• bool object.TypeInfo_Typedef.opEquals(Object)
• bool object.TypeInfo.opEquals(Object)
• bool object.TypeInfo_Interface.opEquals(Object)
• bool object.TypeInfo_AssociativeArray.opEquals(Object)
• bool object.TypeInfo_StaticArray.opEquals(Object)
• extern (C) int rt.dmain2.main(int, char**).void tryExec(scope void delegate()).void print(object.Throwable)
• bool object.TypeInfo_Delegate.opEquals(Object)

Uses:

• _d_isbaseof2

_d_isbaseof

Used by:

• _d_throwc

_d_isbaseof2

Used by:

• _d_dynamic_cast

_d_monitor_create

Used by:

• _d_monitorenter

Uses:

• pthread_mutex_lock@plt
• pthread_mutex_init@plt
• pthread_mutex_unlock@plt
• calloc@plt

_d_monitor_destroy

Used by:

• _d_monitordelete

Uses:

• free@plt
• pthread_mutex_destroy@plt

_d_monitor_devt

Used by:

• _d_monitordelete

Uses:

• _d_monitorenter
• free@plt
• _d_monitorexit

_d_monitor_lock

Used by:

• _d_monitorenter

Uses:

• pthread_mutex_lock@plt

_d_monitor_unlock

Used by:

• _d_monitorexit

Uses:

• pthread_mutex_unlock@plt

_d_monitordelete

Used by:

• rt_finalize

Uses:

• _d_monitor_devt
• shared(ulong) core.atomic.atomicOp!("-=", shared(ulong), ulong).atomicOp(ref shared(ulong), ulong)
• _d_monitor_destroy

_d_monitorenter

Used by:

• void* gc.gcx.GC.malloc(ulong, uint, ulong*)
• ulong gc.gcx.GC.sizeOf(void*)
• bool rt.lifetime.__setArrayAllocLength(ref rt.lifetime.BlkInfo, ulong, bool, ulong)
• @property int delegate(int delegate(ref void*)) gc.gcx.GC.rootIter()
• void gc.gcx.GC.disable()
• uint gc.gcx.GC.setAttr(void*, uint)
• uint gc.gcx.GC.getAttr(void*)
• void* gc.gcx.GC.realloc(void*, ulong, uint, ulong*)
• void gc.gcx.GC.removeRoot(void*)
• void gc.gcx.GC.check(void*)
• int core.thread.Thread.opApply(scope int delegate(ref core.thread.Thread))
• void core.thread.Thread.remove(core.thread.Thread)
• void* gc.gcx.GC.calloc(ulong, uint, ulong*)
• void gc.gcx.GC.fullCollectNoStack()
• void core.thread.Thread.remove(core.thread.Thread.Context*)
• uint gc.gcx.GC.clrAttr(void*, uint)
• void gc.gcx.GC.enable()
• void gc.gcx.GC.removeRange(void*)
• @property bool core.thread.Thread.isDaemon()
• void gc.gcx.GC.free(void*)
• void gc.gcx.GC.getStats(out gc.gcstats.GCStats)
• void core.thread.Thread.add(core.thread.Thread.Context*)
• ulong gc.gcx.GC.extend(void*, ulong, ulong)
• void* gc.gcx.GC.reallocNoSync(void*, ulong, uint, ulong*)
• gc.gcx.BlkInfo gc.gcx.GC.query(void*)
• void* gc.gcx.GC.addrOf(void*)
• ulong gc.gcx.GC.fullCollect()
• void gc.gcx.GC.minimize()
• void gc.gcx.GC.addRoot(void*)
• _d_monitor_devt
• ulong gc.gcx.GC.reserve(ulong)
• void gc.gcx.GC.addRange(void*, ulong)
• @property int delegate(int delegate(ref gc.gcx.Range)) gc.gcx.GC.rangeIter()
• void core.thread.Thread.add(core.thread.Thread)

Uses:

• _d_monitor_lock
• _d_monitor_create

_d_monitorexit

Used by:

• void* gc.gcx.GC.malloc(ulong, uint, ulong*)
• ulong gc.gcx.GC.sizeOf(void*)
• bool rt.lifetime.__setArrayAllocLength(ref rt.lifetime.BlkInfo, ulong, bool, ulong)
• @property int delegate(int delegate(ref void*)) gc.gcx.GC.rootIter()
• void gc.gcx.GC.disable()
• uint gc.gcx.GC.setAttr(void*, uint)
• uint gc.gcx.GC.getAttr(void*)
• void* gc.gcx.GC.realloc(void*, ulong, uint, ulong*)
• void gc.gcx.GC.removeRoot(void*)
• void gc.gcx.GC.check(void*)
• int core.thread.Thread.opApply(scope int delegate(ref core.thread.Thread))
• void core.thread.Thread.remove(core.thread.Thread)
• void* gc.gcx.GC.calloc(ulong, uint, ulong*)
• void gc.gcx.GC.fullCollectNoStack()
• void core.thread.Thread.remove(core.thread.Thread.Context*)
• uint gc.gcx.GC.clrAttr(void*, uint)
• void gc.gcx.GC.enable()
• void gc.gcx.GC.removeRange(void*)
• @property bool core.thread.Thread.isDaemon()
• void gc.gcx.GC.free(void*)
• void gc.gcx.GC.getStats(out gc.gcstats.GCStats)
• void core.thread.Thread.add(core.thread.Thread.Context*)
• ulong gc.gcx.GC.extend(void*, ulong, ulong)
• void* gc.gcx.GC.reallocNoSync(void*, ulong, uint, ulong*)
• gc.gcx.BlkInfo gc.gcx.GC.query(void*)
• void* gc.gcx.GC.addrOf(void*)
• ulong gc.gcx.GC.fullCollect()
• void gc.gcx.GC.minimize()
• void gc.gcx.GC.addRoot(void*)
• _d_monitor_devt
• ulong gc.gcx.GC.reserve(ulong)
• void gc.gcx.GC.addRange(void*, ulong)
• @property int delegate(int delegate(ref gc.gcx.Range)) gc.gcx.GC.rangeIter()
• void core.thread.Thread.add(core.thread.Thread)

Uses:

• _d_monitor_unlock

_d_newarrayT

Used by:

• void object.TypeInfo_StaticArray.swap(void*, void*)
• _checkModCtors
• _moduleCtor

Uses:

• bool rt.lifetime.__setArrayAllocLength(ref rt.lifetime.BlkInfo, ulong, bool, ulong)
• memset@plt
• onOutOfMemoryError
• gc_qalloc

_d_newarrayiT

Used by:

• pure nothrow immutable(char)* std.string.toStringz(const(char)[])

Uses:

• bool rt.lifetime.__setArrayAllocLength(ref rt.lifetime.BlkInfo, ulong, bool, ulong)
• memset@plt
• onOutOfMemoryError
• gc_qalloc
• memcpy@plt

_d_newclass

Used by:

• onFinalizeError
• void core.sync.mutex.Mutex.lock()
• int object.Object.opCmp(Object)
• thread_attachThis
• void std.datetime.UTC._sharedStaticCtor8()
• object.Throwable.TraceInfo core.runtime.defaultTraceHandler(void*)
• @property @trusted core.time.TickDuration core.time.TickDuration.currSystemTick()
• immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint).object.Throwable __dgliteral2800()
• pure @safe void std.exception.bailOut(immutable(char)[], ulong, const(char[]))
• Object object.TypeInfo_Class.create()
• void std.datetime.LocalTime._sharedStaticCtor7()
• object.Throwable core.thread.Thread.join(bool)
• _d_arraycopy
• onRangeError
• extern (C) void object._checkModCtors().bool _checkModCtors2(object.ModuleInfo*)
• onAssertErrorMsg
• core.sync.mutex.Mutex core.sync.mutex.Mutex.__ctor()
• extern (C) void core.thread.thread_resumeAll().void resume(core.thread.Thread)
• extern (C) void core.thread.thread_suspendAll().void suspend(core.thread.Thread)
• _d_arraycast
• void core.sync.mutex.Mutex.unlock()
• onAssertError

Uses:

• malloc@plt
• onOutOfMemoryError
• gc_malloc
• memcpy@plt

_d_throwc

Used by:

• onFinalizeError
• void core.sync.mutex.Mutex.lock()
• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy object.Throwable)
• char[] core.demangle.Demangle.parseTypeFunction(char[], core.demangle.Demangle.IsDelegate)
• int object.Object.opCmp(Object)
• void core.demangle.Demangle.parseTemplateInstanceName()
• onOutOfMemoryError
• void core.demangle.Demangle.error(immutable(char)[])
• @property @trusted core.time.TickDuration core.time.TickDuration.currSystemTick()
• pure @safe void std.exception.bailOut(immutable(char)[], ulong, const(char[]))
• object.Throwable core.thread.Thread.join(bool)
• _d_arraycopy
• onRangeError
• void core.demangle.Demangle.overflow(immutable(char)[])
• extern (C) void object._checkModCtors().bool _checkModCtors2(object.ModuleInfo*)
• onInvalidMemoryOperationError
• onAssertErrorMsg
• core.sync.mutex.Mutex core.sync.mutex.Mutex.__ctor()
• extern (C) void core.thread.thread_resumeAll().void resume(core.thread.Thread)
• extern (C) void core.thread.thread_suspendAll().void suspend(core.thread.Thread)
• _d_arraycast
• void core.sync.mutex.Mutex.unlock()
• onAssertError

Uses:

• _DYNAMIC
• _d_isbaseof
• ulong rt.deh2.__eh_find_caller(ulong, ulong*)
• rt.deh2.DHandlerTable* rt.deh2.__eh_finddata(void*)
• _d_dynamic_cast
• _d_createTrace

_d_traceContext

Used by:

• _d_createTrace

Uses:

• object.Throwable.TraceInfo function(void*)* object.traceHandler

_d_unittestm

Used by:

• void core.sync.exception.__unittest_fail(int)
• src.rt.typeinfo.ti_Ag.d.1410.__unittest_fail.FiZv
• void std.regex.__unittest_fail(int)
• void std.ascii.__unittest_fail(int)
• void std.algorithm.__unittest_fail(int)
• void rt.typeinfo.ti_byte.__unittest_fail(int)
• void rt.deh2.__unittest_fail(int)
• void rt.lifetime.__unittest_fail(int)
• void std.stdio.__unittest_fail(int)
• void std.bitmanip.__unittest_fail(int)
• void std.path.__unittest_fail(int)
• void object.__unittest_fail(int)
• void core.runtime.__unittest_fail(int)
• void std.typetuple.__unittest_fail(int)
• void rt.typeinfo.ti_char.__unittest_fail(int)
• src.core.atomic.d.211.__unittest_fail.FiZv
• void gc.gcx.__unittest_fail(int)
• void core.thread.__unittest_fail(int)
• src.object_.d.168.__unittest_fail.FiZv
• void core.time.__unittest_fail(int)
• void gc.gc.__unittest_fail(int)
• src.core.atomic.d.215.__unittest_fail.FiZv
• src.object_.d.207.__unittest_fail.FiZv
• void std.traits.__unittest_fail(int)
• void std.stdiobase.__unittest_fail(int)
• void std.functional.__unittest_fail(int)
• void std.math.__unittest_fail(int)
• void rt.util.console.__unittest_fail(int)
• src.core.atomic.d.214.__unittest_fail.FiZv
• void std.typecons.__unittest_fail(int)
• void rt.critical_.__unittest_fail(int)
• std.traits.d.1741.__unittest_fail.FiZv
• void std.array.__unittest_fail(int)
• void rt.monitor_.__unittest_fail(int)
• void std.utf.__unittest_fail(int)
• void std.range.__unittest_fail(int)
• void rt.dmain2.__unittest_fail(int)
• void core.exception.__unittest_fail(int)
• void std.exception.__unittest_fail(int)
• void std.file.__unittest_fail(int)
• void rt.typeinfo.ti_void.__unittest_fail(int)
• src.core.atomic.d.212.__unittest_fail.FiZv
• void core.demangle.__unittest_fail(int)
• void std.string.__unittest_fail(int)
• void std.format.__unittest_fail(int)
• void std.process.__unittest_fail(int)
• void std.outbuffer.__unittest_fail(int)
• void std.conv.__unittest_fail(int)
• void core.sync.mutex.__unittest_fail(int)
• void std.datetime.__unittest_fail(int)
• void rt.typeinfo.ti_Ag.__unittest_fail(int)
• void rt.typeinfo.ti_ubyte.__unittest_fail(int)
• void std.container.__unittest_fail(int)

Uses:

• onUnittestErrorMsg
• pure nothrow @property immutable(char)[] object.ModuleInfo.name()

_fini

Uses:

• __do_global_dtors_aux

_init

_moduleCtor

Used by:

• extern (C) int rt.dmain2.main(int, char**).void runAll()

Uses:

• _moduleIndependentCtors
• _Dmodule_ref
• _d_newarrayT
• ulong object._moduleinfo_dtors_i
• _checkModCtors
• object.ModuleInfo*[] object._moduleinfo_dtors
• _moduleinfo_array
• pure nothrow @property void function()* object.ModuleInfo.ctor()

_moduleDtor

Used by:

• extern (C) int rt.dmain2.main(int, char**).void runAll()

Uses:

• pure nothrow @property void function()* object.ModuleInfo.dtor()
• ulong object._moduleinfo_dtors_i
• object.ModuleInfo*[] object._moduleinfo_dtors

_moduleIndependentCtors

Used by:

• _moduleCtor

Uses:

• pure nothrow @property void function()* object.ModuleInfo.ictor()
• _moduleinfo_array

_moduleTlsCtor

Used by:

• extern (C) int rt.dmain2.main(int, char**).void runAll()

Uses:

• ulong object._moduleinfo_tlsdtors_i
• pure nothrow @property void function()* object.ModuleInfo.tlsctor()
• object.ModuleInfo*[] object._moduleinfo_tlsdtors

_moduleTlsDtor

Used by:

• extern (C) int rt.dmain2.main(int, char**).void runAll()

Uses:

• ulong object._moduleinfo_tlsdtors_i
• pure nothrow @property void function()* object.ModuleInfo.tlsdtor()
• object.ModuleInfo*[] object._moduleinfo_tlsdtors

_moduleinfo_array

Used by:

• _moduleIndependentCtors
• _checkModCtors
• extern (C) void object._checkModCtors().bool _checkModCtors2(object.ModuleInfo*)
• extern (C) void object._checkModCtors().void _checkModCtors3()
• int object.ModuleInfo.opApply(scope int delegate(ref object.ModuleInfo*))
• _moduleCtor

_start

Uses:

• __libc_start_main@plt

backtrace@plt

Used by:

• extern (C) bool core.runtime.runModuleUnitTests().extern (C) void unittestSegvHandler(int, core.sys.posix.signal.siginfo_t*, void*)

backtrace_symbols@plt

Used by:

• core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo6__ctorMFZC4core7runtime19defaultTraceHandlerFPvZC6object9Throwable9TraceInfo16DefaultTraceInfo

backtrace_symbols_fd@plt

Used by:

• extern (C) bool core.runtime.runModuleUnitTests().extern (C) void unittestSegvHandler(int, core.sys.posix.signal.siginfo_t*, void*)

call_gmon_start

Uses:

• _DYNAMIC

calloc@plt

Used by:

• void gc.gcx.GC.initialize()
• gc.gcx.Pool* gc.gcx.Gcx.newPool(ulong, bool)
• void gc.gcx.Gcx.setBits(gc.gcx.Pool*, ulong, uint)
• void gc.gcx.Pool.initialize(ulong, bool)
• _d_monitor_create

clock_getres@plt

Used by:

• @trusted void core.time.TickDuration._sharedStaticCtor7()

clock_gettime@plt

Used by:

• @property @trusted core.time.TickDuration core.time.TickDuration.currSystemTick()

completed.6458

Used by:

• __do_global_dtors_aux

dtor_idx.6460

Used by:

• __do_global_dtors_aux

fprintf@plt

Used by:

• void std.stdio.writeln!(immutable(char)[]).writeln(immutable(char)[])

frame_dummy

Uses:

• __JCR_END__

free@plt

Used by:

• void gc.gcx.GC.Dtor()
• void gc.gcx.Gcx.minimize()
• gc.gcx.Pool* gc.gcx.Gcx.newPool(ulong, bool)
• main
• void gc.gcx.Gcx.Dtor()
• void gc.gcx.Gcx.addRoot(void*)
• void gc.gcx.Gcx.addRange(void*, void*)
• void gc.gcx.Pool.Dtor()
• void rt.lifetime._staticDtor9()
• _d_monitor_devt
• core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo6__dtorMFZv
• void gc.gcbits.GCBits.Dtor()
• _d_monitor_destroy

free@plt-0x10

gc_addRange

Used by:

• void rt.memory.initStaticDataGC()

Uses:

• gc.gcx.GC gc.gc._gc
• gc.gc.Proxy* gc.gc.proxy

gc_addRoot

Uses:

• gc.gcx.GC gc.gc._gc
• gc.gc.Proxy* gc.gc.proxy

gc_addrOf

Uses:

• gc.gcx.GC gc.gc._gc
• gc.gc.Proxy* gc.gc.proxy

gc_calloc

Uses:

• gc.gcx.GC gc.gc._gc
• gc.gc.Proxy* gc.gc.proxy

gc_clrAttr

Used by:

• uint core.memory.GC.clrAttr(const(void*), uint)

Uses:

• gc.gcx.GC gc.gc._gc
• gc.gc.Proxy* gc.gc.proxy

gc_collect

Uses:

• gc.gcx.GC gc.gc._gc
• gc.gc.Proxy* gc.gc.proxy

gc_disable

Used by:

• thread_attachThis

Uses:

• gc.gcx.GC gc.gc._gc
• gc.gc.Proxy* gc.gc.proxy

gc_enable

Used by:

• thread_attachThis

Uses:

• gc.gcx.GC gc.gc._gc
• gc.gc.Proxy* gc.gc.proxy

gc_extend

Used by:

• _d_arraysetlengthiT
• _d_arrayappendcTX
• _d_arraysetlengthT

Uses:

• gc.gcx.GC gc.gc._gc
• gc.gc.Proxy* gc.gc.proxy

gc_free

Used by:

• _d_delmemory

Uses:

• gc.gcx.GC gc.gc._gc
• gc.gc.Proxy* gc.gc.proxy

gc_getAttr

Uses:

• gc.gcx.GC gc.gc._gc
• gc.gc.Proxy* gc.gc.proxy

gc_init

Used by:

• extern (C) int rt.dmain2.main(int, char**).void runAll()

Uses:

• malloc@plt
• gc.gcx.GC.__Class
• gc.gcx.GC gc.gc._gc
• thread_init
• gc.gc.Proxy gc.gc.pthis
• memcpy@plt

gc_isCollecting

Used by:

• rt_processGCMarks

Uses:

• gc.gcx.GC gc.gc._gc
• gc.gc.Proxy* gc.gc.proxy

gc_malloc

Used by:

• void* core.memory.GC.malloc(ulong, uint)
• _d_newclass

Uses:

• gc.gcx.GC gc.gc._gc
• gc.gc.Proxy* gc.gc.proxy

gc_minimize

Uses:

• gc.gcx.GC gc.gc._gc
• gc.gc.Proxy* gc.gc.proxy

gc_qalloc

Used by:

• _d_arraysetlengthiT
• _d_newarrayT
• _d_arraycatT
• _d_arraycatnT
• _d_arrayappendcTX
• _d_newarrayiT
• _adDupT
• _d_arraysetlengthT

Uses:

• gc.gcx.GC gc.gc._gc
• gc.gc.Proxy* gc.gc.proxy

gc_query

Used by:

• _d_arraysetlengthiT
• _d_arrayappendcTX
• _d_arraysetlengthT

Uses:

• gc.gcx.GC gc.gc._gc
• gc.gc.Proxy* gc.gc.proxy

gc_realloc

Uses:

• gc.gcx.GC gc.gc._gc
• gc.gc.Proxy* gc.gc.proxy

gc_removeRange

Uses:

• gc.gcx.GC gc.gc._gc
• gc.gc.Proxy* gc.gc.proxy

gc_removeRoot

Uses:

• gc.gcx.GC gc.gc._gc
• gc.gc.Proxy* gc.gc.proxy

gc_reserve

Uses:

• gc.gcx.GC gc.gc._gc
• gc.gc.Proxy* gc.gc.proxy

gc_setAttr

Uses:

• gc.gcx.GC gc.gc._gc
• gc.gc.Proxy* gc.gc.proxy

gc_sizeOf

Uses:

• gc.gcx.GC gc.gc._gc
• gc.gc.Proxy* gc.gc.proxy

gc_term

Used by:

• extern (C) int rt.dmain2.main(int, char**).void runAll()

Uses:

• gc.gcx.GC gc.gc._gc

localtime@plt

Used by:

• const(nothrow long function(long)) std.datetime.LocalTime.tzToUTC
• const(nothrow long function(long)) std.datetime.LocalTime.utcToTZ
• const(nothrow bool function(long)) std.datetime.LocalTime.dstInEffect

main

Uses:

• malloc@plt
• strlen@plt
• immutable(char)[][] rt.dmain2._d_args
• free@plt
• _STI_monitor_staticctor
• _STD_critical_term
• _STD_monitor_staticdtor
• _STI_critical_init
• rt_trapExceptions
• extern (C) int rt.dmain2.main(int, char**).void tryExec(scope void delegate())

malloc@plt

Used by:

• @property rt.lifetime.BlkInfo* rt.lifetime.__blkcache()
• main
• _d_newclass
• void gc.gcx.Gcx.addRoot(void*)
• void gc.gcx.Gcx.addRange(void*, void*)
• @property core.sync.mutex.Mutex core.thread.Thread.slock()
• gc_init
• void gc.gcx.Pool.initialize(ulong, bool)

memchr@plt

Used by:

• core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo7fixlineMFAaZAa

memcmp@plt

Used by:

• bool rt.typeinfo.ti_Ag.TypeInfo_Ag.equals(const(void*), const(void*))
• bool object.TypeInfo_Struct.equals(const(void*), const(void*))
• int object.TypeInfo_Struct.compare(const(void*), const(void*))
• int rt.util.string.dstrcmp(const(char[]), const(char[]))

memcpy@plt

Used by:

• char[] core.demangle.Demangle.opCall()
• _d_arraycatT
• _d_arraysetlengthT
• _d_arrayappendcTX
• core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo7fixlineMFAaZAa
• void std.outbuffer.OutBuffer.write(const(ubyte)[])
• ulong gc.gcx.Gcx.fullcollect(void*)
• _d_arraycatnT
• void gc.gcx.Gcx.addRange(void*, void*)
• _d_arraycopy
• gc_init
• pure nothrow immutable(char)* std.string.toStringz(const(char)[])
• _d_arrayappendT
• @property core.sync.mutex.Mutex core.thread.Thread.slock()
• char[] core.demangle.Demangle.append(const(char)[])
• void* gc.gcx.GC.reallocNoSync(void*, ulong, uint, ulong*)
• _adDupT
• _d_newclass
• rt_finalize
• _d_newarrayiT
• void object.TypeInfo_StaticArray.swap(void*, void*)
• _d_arraysetlengthiT
• void gc.gcx.Gcx.addRoot(void*)

memmove@plt

Used by:

• void gc.gcx.Gcx.minimize()
• gc.gcx.Pool* gc.gcx.Gcx.newPool(ulong, bool)
• void gc.gcx.Gcx.removeRange(void*)
• void gc.gcx.Gcx.removeRoot(void*)

memset@plt

Used by:

• void* gc.gcx.GC.calloc(ulong, uint, ulong*)
• void gc.gcx.GC.getStatsNoSync(out gc.gcstats.GCStats)
• @property rt.lifetime.BlkInfo* rt.lifetime.__blkcache()
• _d_newarrayT
• ulong gc.gcx.GC.extendNoSync(void*, ulong, ulong)
• void* gc.gcx.Gcx.bigAlloc(ulong, gc.gcx.Pool**, ulong*)
• ulong gc.gcx.Pool.extendPagesUpTo(ulong)
• void* gc.gcx.GC.reallocNoSync(void*, ulong, uint, ulong*)
• ulong gc.gcx.Gcx.fullcollect(void*)
• _d_newarrayiT
• void* gc.gcx.GC.mallocNoSync(ulong, uint, ulong*)
• void gc.gcx.Pool.initialize(ulong, bool)
• ulong gc.gcx.Pool.extendPages(ulong)

mmap64@plt

Used by:

• void gc.gcx.Pool.initialize(ulong, bool)

munmap@plt

Used by:

• void core.thread.Fiber.__dtor()
• void gc.gcx.Pool.Dtor()

onAssertError

Used by:

• _d_assertm

Uses:

• void function(immutable(char)[], ulong, immutable(char)[])* core.exception.assertHandler
• _d_newclass
• core.exception.AssertError core.exception.AssertError.__ctor(immutable(char)[], ulong)
• _d_throwc

onAssertErrorMsg

Used by:

• onUnittestErrorMsg

Uses:

• void function(immutable(char)[], ulong, immutable(char)[])* core.exception.assertHandler
• _d_newclass
• core.exception.AssertError core.exception.AssertError.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throwc

onFinalizeError

Used by:

• rt_finalize

Uses:

• core.exception.FinalizeError core.exception.FinalizeError.__ctor(TypeInfo_Class, immutable(char)[], ulong, object.Throwable)
• _d_newclass
• _d_throwc

onInvalidMemoryOperationError

Used by:

• ulong gc.gcx.GC.extendNoSync(void*, ulong, ulong)
• void* gc.gcx.GC.reallocNoSync(void*, ulong, uint, ulong*)
• ulong gc.gcx.GC.reserve(ulong)
• void gc.gcx.GC.freeNoSync(void*)
• ulong gc.gcx.Gcx.fullcollect(void*)
• void* gc.gcx.GC.mallocNoSync(ulong, uint, ulong*)

Uses:

• core.exception.InvalidMemoryOperationError.__Class
• _d_throwc

onOutOfMemoryError

Used by:

• void gc.gcx.GC.initialize()
• _d_arraysetlengthiT
• _d_newarrayT
• _d_newclass
• void gc.gcx.Gcx.addRoot(void*)
• void gc.gcx.Gcx.addRange(void*, void*)
• _d_newarrayiT
• void* gc.gcx.GC.mallocNoSync(ulong, uint, ulong*)
• void gc.gcx.Gcx.setBits(gc.gcx.Pool*, ulong, uint)
• void gc.gcx.Pool.initialize(ulong, bool)
• _d_arraysetlengthT

Uses:

• core.exception.OutOfMemoryError.__Class
• _d_throwc

onRangeError

Used by:

• _d_array_bounds

Uses:

• core.exception.RangeError core.exception.RangeError.__ctor(immutable(char)[], ulong, object.Throwable)
• _d_newclass
• _d_throwc

onUnittestErrorMsg

Used by:

• _d_unittestm

Uses:

• onAssertErrorMsg

pthread_detach@plt

Used by:

• void core.thread.Thread.__dtor()

pthread_getschedparam@plt

Used by:

• void core.thread.Thread._sharedStaticCtor3()

pthread_getspecific@plt

Used by:

• thread_suspendAll
• thread_stackBottom
• thread_resumeAll
• thread_scanAll
• thread_suspendHandler

pthread_join@plt

Used by:

• object.Throwable core.thread.Thread.join(bool)

pthread_key_create@plt

Used by:

• thread_init

pthread_kill@plt

Used by:

• extern (C) void core.thread.thread_suspendAll().void suspend(core.thread.Thread)
• extern (C) void core.thread.thread_resumeAll().void resume(core.thread.Thread)

pthread_mutex_destroy@plt

Used by:

• _STD_monitor_staticdtor
• _STD_critical_term
• void core.sync.mutex.Mutex.__dtor()
• _d_monitor_destroy

pthread_mutex_init@plt

Used by:

• _STI_monitor_staticctor
• _STI_critical_init
• core.sync.mutex.Mutex core.sync.mutex.Mutex.__ctor()
• _d_monitor_create

pthread_mutex_lock@plt

Used by:

• _d_monitor_lock
• void core.sync.mutex.Mutex.lock()
• _d_monitor_create

pthread_mutex_trylock@plt

Used by:

• bool core.sync.mutex.Mutex.tryLock()

pthread_mutex_unlock@plt

Used by:

• void core.sync.mutex.Mutex.unlock()
• _d_monitor_create
• _d_monitor_unlock

pthread_mutexattr_destroy@plt

Used by:

• _STD_monitor_staticdtor
• core.sync.mutex.Mutex core.sync.mutex.Mutex.__ctor()

pthread_mutexattr_init@plt

Used by:

• _STI_monitor_staticctor
• _STI_critical_init
• core.sync.mutex.Mutex core.sync.mutex.Mutex.__ctor()

pthread_mutexattr_settype@plt

Used by:

• _STI_monitor_staticctor
• _STI_critical_init
• core.sync.mutex.Mutex core.sync.mutex.Mutex.__ctor()

pthread_self@plt

Used by:

• void core.thread.Thread._sharedStaticCtor3()
• thread_attachThis
• extern (C) void core.thread.thread_suspendAll().void suspend(core.thread.Thread)
• extern (C) void core.thread.thread_resumeAll().void resume(core.thread.Thread)

pthread_setspecific@plt

Used by:

• thread_attachThis

realloc@plt

Used by:

• gc.gcx.Pool* gc.gcx.Gcx.newPool(ulong, bool)

rt_finalize

Used by:

• ulong gc.gcx.Gcx.fullcollect(void*)

Uses:

• bool function(Object)* rt.lifetime.collectHandler
• _d_monitordelete
• memcpy@plt
• onFinalizeError

rt_lifetimeInit

Used by:

• extern (C) int rt.dmain2.main(int, char**).void runAll()

Uses:

• _DYNAMIC
• ulong rt.lifetime.__blkcache_offset

rt_processGCMarks

Used by:

• thread_processGCMarks

Uses:

• ulong rt.lifetime.__blkcache_offset
• gc_isCollecting

rt_setTraceHandler

Used by:

• void core.runtime._staticCtor2()

Uses:

• object.Throwable.TraceInfo function(void*)* object.traceHandler

rt_stackBottom

Used by:

• void gc.gcx.GC.initialize()
• thread_attachThis
• thread_stackBottom

Uses:

• __libc_stack_end@@GLIBC_2.2.5

rt_stackTop

Used by:

• extern (C) void core.thread.thread_suspendAll().void suspend(core.thread.Thread)
• thread_suspendHandler

rt_trapExceptions

Used by:

• main

runModuleUnitTests

Used by:

• extern (C) int rt.dmain2.main(int, char**).void runAll()

Uses:

• sigfillset@plt
• bool function()* core.runtime.Runtime.sm_moduleUnitTester
• int object.ModuleInfo.opApply(scope int delegate(ref object.ModuleInfo*))
• sigaction@plt

sched_get_priority_max@plt

Used by:

• void core.thread.Thread._sharedStaticCtor3()

sched_get_priority_min@plt

Used by:

• void core.thread.Thread._sharedStaticCtor3()

sched_yield@plt

Used by:

• void core.thread.Thread.add(core.thread.Thread.Context*)
• void core.thread.Thread.add(core.thread.Thread)

sem_init@plt

Used by:

• thread_init

sem_post@plt

Used by:

• thread_suspendHandler

sem_wait@plt

Used by:

• extern (C) void core.thread.thread_suspendAll().void suspend(core.thread.Thread)

sigaction@plt

Used by:

• thread_init
• runModuleUnitTests

sigdelset@plt

Used by:

• thread_suspendHandler

sigfillset@plt

Used by:

• thread_init
• runModuleUnitTests
• thread_suspendHandler

sigsuspend@plt

Used by:

• thread_suspendHandler

snprintf@plt

Used by:

• void core.demangle.Demangle.parseReal()

std_stdio_static_this

Used by:

• void std.stdiobase._sharedStaticCtor28()

Uses:

• extern (C) void std.stdio.std_stdio_static_this().std.stdio.File.Impl stdinImpl
• stdout@@GLIBC_2.2.5
• std.stdio.File std.stdio.stderr
• std.stdio.File std.stdio.stdin
• extern (C) void std.stdio.std_stdio_static_this().std.stdio.File.Impl stdoutImpl
• std.stdio.File std.stdio.stdout
• stderr@@GLIBC_2.2.5
• extern (C) void std.stdio.std_stdio_static_this().std.stdio.File.Impl stderrImpl
• stdin@@GLIBC_2.2.5

stderr@@GLIBC_2.2.5

Used by:

• std_stdio_static_this

stdin@@GLIBC_2.2.5

Used by:

• std_stdio_static_this

stdout@@GLIBC_2.2.5

Used by:

• std_stdio_static_this

strlen@plt

Used by:

• main
• core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo7opApplyMFMDFKmKAaZiZi
• pure nothrow @property immutable(char)[] object.ModuleInfo.name()
• immutable(char)[] std.conv.toImpl!(immutable(char)[], const(char)*).toImpl(const(char)*)

strtold@plt

Used by:

• void core.demangle.Demangle.parseReal()

sysconf@plt

Used by:

• void core.thread._sharedStaticCtor5()

thread_attachThis

Used by:

• thread_init

Uses:

• _DYNAMIC
• bool core.thread.multiThreadedFlag
• gc_disable
• core.thread.Thread core.thread.Thread.__ctor()
• pthread_self@plt
• uint core.thread.Thread.sm_this
• core.thread.Thread core.thread.Thread.sm_main
• _d_newclass
• rt_stackBottom
• void core.thread.Thread.add(core.thread.Thread)
• void core.thread.Thread.add(core.thread.Thread.Context*)
• gc_enable
• pthread_setspecific@plt

thread_init

Used by:

• gc_init

Uses:

• sem_init@plt
• thread_attachThis
• pthread_key_create@plt
• core.thread.Thread core.thread.Thread.sm_main
• sigfillset@plt
• sigaction@plt

thread_joinAll

Used by:

• extern (C) int rt.dmain2.main(int, char**).void runAll()

Uses:

• int core.thread.Thread.opApply(scope int delegate(ref core.thread.Thread))
• object.Throwable core.thread.Thread.join(bool)

thread_needLock

Used by:

• ulong gc.gcx.GC.sizeOf(void*)
• @property int delegate(int delegate(ref void*)) gc.gcx.GC.rootIter()
• void gc.gcx.GC.disable()
• uint gc.gcx.GC.setAttr(void*, uint)
• uint gc.gcx.GC.getAttr(void*)
• void gc.gcx.GC.removeRoot(void*)
• void gc.gcx.GC.check(void*)
• uint gc.gcx.GC.clrAttr(void*, uint)
• void gc.gcx.GC.enable()
• void gc.gcx.GC.removeRange(void*)
• void gc.gcx.GC.free(void*)
• void gc.gcx.GC.getStats(out gc.gcstats.GCStats)
• ulong gc.gcx.GC.extend(void*, ulong, ulong)
• gc.gcx.BlkInfo gc.gcx.GC.query(void*)
• void* gc.gcx.GC.addrOf(void*)
• void gc.gcx.GC.minimize()
• void gc.gcx.GC.addRoot(void*)
• void gc.gcx.GC.addRange(void*, ulong)
• ulong gc.gcx.GC.reserve(ulong)
• @property int delegate(int delegate(ref gc.gcx.Range)) gc.gcx.GC.rangeIter()

Uses:

• bool core.thread.multiThreadedFlag

thread_processGCMarks

Used by:

• ulong gc.gcx.Gcx.fullcollect(void*)

Uses:

• core.thread.Thread core.thread.Thread.sm_tbeg
• rt_processGCMarks

thread_resumeAll

Used by:

• ulong gc.gcx.Gcx.fullcollect(void*)

Uses:

• bool core.thread.multiThreadedFlag
• core.thread.Thread core.thread.Thread.sm_tbeg
• uint core.thread.suspendDepth
• uint core.thread.Thread.sm_this
• extern (C) void core.thread.thread_resumeAll().void resume(core.thread.Thread)
• @property core.sync.mutex.Mutex core.thread.Thread.slock()
• pthread_getspecific@plt

thread_resumeHandler

thread_scanAll

Used by:

• ulong gc.gcx.Gcx.fullcollect(void*)

Uses:

• core.thread.Thread core.thread.Thread.sm_tbeg
• uint core.thread.Thread.sm_this
• pthread_getspecific@plt
• core.thread.Thread.Context* core.thread.Thread.sm_cbeg

thread_stackBottom

Used by:

• core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo6__ctorMFZC4core7runtime19defaultTraceHandlerFPvZC6object9Throwable9TraceInfo16DefaultTraceInfo

Uses:

• uint core.thread.Thread.sm_this
• rt_stackBottom
• pthread_getspecific@plt

thread_suspendAll

Used by:

• ulong gc.gcx.Gcx.fullcollect(void*)

Uses:

• bool core.thread.multiThreadedFlag
• core.thread.Thread core.thread.Thread.sm_tbeg
• uint core.thread.suspendDepth
• uint core.thread.Thread.sm_this
• extern (C) void core.thread.thread_suspendAll().void suspend(core.thread.Thread)
• @property bool core.thread.Thread.isRunning()
• @property core.sync.mutex.Mutex core.thread.Thread.slock()
• void core.thread.Thread.remove(core.thread.Thread)
• pthread_getspecific@plt

thread_suspendHandler

Uses:

• sigdelset@plt
• sem_post@plt
• uint core.thread.Thread.sm_this
• rt_stackTop
• sigfillset@plt
• pthread_getspecific@plt
• sigsuspend@plt

tzset@plt

Used by:

• void std.datetime.LocalTime._sharedStaticCtor7()

vsnprintf@plt

Used by:

• void std.outbuffer.OutBuffer.vprintf(immutable(char)[], void*)

write@plt

Used by:

• rt.util.console.Console rt.util.console.Console.opCall(const(char[]))
• rt.util.console.Console rt.util.console.Console.opCall(ulong)
• core.runtime.runModuleUnitTests.UZb7Console6opCallMFxAaZSrunModuleUnitTests7Console
• extern (C) bool core.runtime.runModuleUnitTests().int __foreachbody265(ref object.ModuleInfo*)