D/ldc
1
0
Fork 0
mirror of https://github.com/xomboverlord/ldc.git synced 2026-01-11 18:33:14 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity
Files
d1637997581e60e4efd4403df094ad8e85a79a90
ldc/tango-0.99.9.patch
Tomas Lindquist Olsen 6861e4504f Updated Tango 0.99.9 patch!
2010-10-23 21:08:11 +02:00

949 lines
31 KiB
Diff
Raw Blame History

Index: tango/core/rt/compiler/ldc/ldc/intrinsics.di
===================================================================
--- tango/core/rt/compiler/ldc/ldc/intrinsics.di (revision 5576)
+++ tango/core/rt/compiler/ldc/ldc/intrinsics.di (working copy)
@@ -101,8 +101,16 @@
// Note that, unlike the standard libc function, the llvm.memcpy.* intrinsics do
// not return a value, and takes an extra alignment argument.
-pragma(intrinsic, "llvm.memcpy.i#")
- void llvm_memcpy(T)(void* dst, void* src, T len, uint alignment);
+version(LDC_LLVMPre28)
+{
+ pragma(intrinsic, "llvm.memcpy.i#")
+ void llvm_memcpy(T)(void* dst, void* src, T len, uint alignment);
+}
+else
+{
+ pragma(intrinsic, "llvm.memcpy.p0i8.p0i8.i#")
+ void llvm_memcpy(T)(void* dst, void* src, T len, uint alignment, bool volatile_);
+}
deprecated {
alias llvm_memcpy!(uint) llvm_memcpy_i32;
@@ -116,8 +124,16 @@
// Note that, unlike the standard libc function, the llvm.memmove.* intrinsics
// do not return a value, and takes an extra alignment argument.
-pragma(intrinsic, "llvm.memmove.i#")
- void llvm_memmove(T)(void* dst, void* src, T len, uint alignment);
+version(LDC_LLVMPre28)
+{
+ pragma(intrinsic, "llvm.memmove.i#")
+ void llvm_memmove(T)(void* dst, void* src, T len, uint alignment);
+}
+else
+{
+ pragma(intrinsic, "llvm.memmove.p0i8.p0i8.i#")
+ void llvm_memmove(T)(void* dst, void* src, T len, uint alignment, bool volatile_);
+}
deprecated {
alias llvm_memmove!(uint) llvm_memmove_i32;
@@ -130,8 +146,16 @@
// Note that, unlike the standard libc function, the llvm.memset intrinsic does
// not return a value, and takes an extra alignment argument.
-pragma(intrinsic, "llvm.memset.i#")
- void llvm_memset(T)(void* dst, ubyte val, T len, uint alignment);
+version(LDC_LLVMPre28)
+{
+ pragma(intrinsic, "llvm.memset.i#")
+ void llvm_memset(T)(void* dst, ubyte val, T len, uint alignment);
+}
+else
+{
+ pragma(intrinsic, "llvm.memset.p0i8.i#")
+ void llvm_memset(T)(void* dst, ubyte val, T len, uint alignment, bool volatile_);
+}
deprecated {
alias llvm_memset!(uint) llvm_memset_i32;
Index: tango/core/rt/compiler/ldc/rt/lifetime.d
===================================================================
--- tango/core/rt/compiler/ldc/rt/lifetime.d (revision 5576)
+++ tango/core/rt/compiler/ldc/rt/lifetime.d (working copy)
@@ -241,7 +241,7 @@
}
/**
- * As _d_newarrayT, but
+ * As _d_newarrayT, but
* for when the array has a non-zero initializer.
*/
extern (C) void* _d_newarrayiT(TypeInfo ti, size_t length)
@@ -359,7 +359,7 @@
/**
- * As _d_newarraymT, but
+ * As _d_newarraymT, but
* for when the array has a non-zero initializer.
*/
extern (C) void* _d_newarraymiT(TypeInfo ti, int ndims, size_t* dims)
@@ -483,7 +483,7 @@
// if (p)
// {
// This assert on array consistency may fail with casts or in unions.
-// This function still does something sensible even if plength && !pdata.
+// This function still does something sensible even if plength && !pdata.
// assert(!plength || pdata);
if (pdata)
@@ -505,9 +505,9 @@
}
}
-/**
- *
- */
+/**
+ *
+ */
extern (C) void _d_callinterfacefinalizer(void *p)
{
if (p)
@@ -544,9 +544,9 @@
if (p) // not necessary if called from gc
{
- if (det)
- (cast(Object)p).dispose();
-
+ if (det)
+ (cast(Object)p).dispose();
+
ClassInfo** pc = cast(ClassInfo**)p;
if (*pc)
@@ -593,7 +593,7 @@
{
assert(ti);
// This assert on array consistency may fail with casts or in unions.
-// This function still does something sensible even if plength && !pdata.
+// This function still does something sensible even if plength && !pdata.
// assert(!plength || pdata);
}
body
@@ -651,7 +651,6 @@
return newdata;
}
-
/**
* Resize arrays for non-zero initializers.
* p pointer to array lvalue to be updated
@@ -664,7 +663,7 @@
in
{
// This assert on array consistency may fail with casts or in unions.
-// This function still does something sensible even if plength && !pdata.
+// This function still does something sensible even if plength && !pdata.
// assert(!plength || pdata);
}
body
@@ -786,6 +785,7 @@
return *cast(long*)px;
}
++/
/**
*
@@ -824,8 +824,8 @@
const size_t b=0; // flatness factor, how fast the extra space decreases with array size
const size_t a=100; // allocate at most a% of the requested size as extra space (rounding will change this)
const size_t minBits=1; // minimum bit size
-
+
static size_t log2plusB(size_t c)
{
// could use the bsr bit op
@@ -847,12 +847,12 @@
return newcap;
}
-
/**
- *
+ * Appends a single element to an array.
*/
-extern (C) byte[] _d_arrayappendcT(TypeInfo ti, ref byte[] x, ...)
+extern (C) byte[] _d_arrayappendcT(TypeInfo ti, void* array, void* element)
{
+ auto x = cast(byte[]*)array;
auto sizeelem = ti.next.tsize(); // array element size
auto info = gc_query(x.ptr);
auto length = x.length;
@@ -879,18 +879,19 @@
assert(newcap >= newlength * sizeelem);
newdata = cast(byte *)gc_malloc(newcap + 1, info.attr);
memcpy(newdata, x.ptr, length * sizeelem);
- (cast(void**)(&x))[1] = newdata;
+ (cast(void**)x)[1] = newdata;
}
L1:
- byte *argp = cast(byte *)(&ti + 2);
+ byte *argp = cast(byte *)element;
- *cast(size_t *)&x = newlength;
+ *cast(size_t *)x = newlength;
x.ptr[length * sizeelem .. newsize] = argp[0 .. sizeelem];
assert((cast(size_t)x.ptr & 15) == 0);
assert(gc_sizeOf(x.ptr) > x.length * sizeelem);
- return x;
+ return *x;
}
+/+
/**
* Append dchar to char[]
@@ -1128,7 +1129,6 @@
return result;
}
-
/**
*
*/
Index: tango/core/rt/compiler/ldc/rt/arrayInit.d
===================================================================
--- tango/core/rt/compiler/ldc/rt/arrayInit.d (revision 5576)
+++ tango/core/rt/compiler/ldc/rt/arrayInit.d (working copy)
@@ -114,7 +114,10 @@
auto p = a;
auto end = a + na*nv;
while (p !is end) {
- llvm_memcpy(p,v,nv,0);
+ version(LDC_LLVMPre28)
+ llvm_memcpy(p,v,nv,0);
+ else
+ llvm_memcpy(p,v,nv,1, false);
p += nv;
}
}
@@ -164,7 +167,12 @@
if (dstlen != srclen)
throw new Exception("lengths don't match for array copy");
else if (dst+dstlen <= src || src+srclen <= dst)
- llvm_memcpy(dst, src, dstlen, 0);
+ {
+ version(LDC_LLVMPre28)
+ llvm_memcpy(dst, src, dstlen, 0);
+ else
+ llvm_memcpy(dst, src, dstlen, 1, false);
+ }
else
throw new Exception("overlapping array copy");
}
Index: tango/core/rt/compiler/ldc/rt/eh.d
===================================================================
--- tango/core/rt/compiler/ldc/rt/eh.d (revision 5576)
+++ tango/core/rt/compiler/ldc/rt/eh.d (working copy)
@@ -1,38 +1,34 @@
/**
* This module contains functions and structures required for
- * exception handling.
+ * dwarf exception handling with llvm
*/
module rt.eh;
-import ldc.cstdarg;
-import rt.compiler.util.console;
+//debug = EH_personality;
-// debug = EH_personality;
-
// current EH implementation works on x86
// if it has a working unwind runtime
version(X86) {
version(linux) version=X86_UNWIND;
version(darwin) version=X86_UNWIND;
version(solaris) version=X86_UNWIND;
- version(freebsd) version=X86_UNWIND;
}
version(X86_64) {
version(linux) version=X86_UNWIND;
version(darwin) version=X86_UNWIND;
version(solaris) version=X86_UNWIND;
- version(freebsd) version=X86_UNWIND;
}
//version = HP_LIBUNWIND;
private extern(C) void abort();
private extern(C) int printf(char*, ...);
-private extern(C) int vprintf(char*, va_list va);
+//private extern(C) int vprintf(char*, va_list va);
// D runtime functions
extern(C) {
- int _d_isbaseof(ClassInfo oc, ClassInfo c);
+// int _d_isbaseof(ClassInfo oc, ClassInfo c);
+ Object _d_dynamic_cast(Object o, ClassInfo c);
}
// libunwind headers
@@ -74,16 +70,19 @@
// interface to HP's libunwind from http://www.nongnu.org/libunwind/
version(HP_LIBUNWIND)
{
+ // Haven't checked whether and how it has _Unwind_Get{Text,Data}RelBase
+ pragma (msg, "HP_LIBUNWIND interface is out of date and untested");
+
void __libunwind_Unwind_Resume(_Unwind_Exception *);
_Unwind_Reason_Code __libunwind_Unwind_RaiseException(_Unwind_Exception *);
ptrdiff_t __libunwind_Unwind_GetLanguageSpecificData(_Unwind_Context_Ptr
context);
- ptrdiff_t __libunwind_Unwind_GetIP(_Unwind_Context_Ptr context);
+ size_t __libunwind_Unwind_GetIP(_Unwind_Context_Ptr context);
ptrdiff_t __libunwind_Unwind_SetIP(_Unwind_Context_Ptr context,
ptrdiff_t new_value);
ptrdiff_t __libunwind_Unwind_SetGR(_Unwind_Context_Ptr context, int index,
ptrdiff_t new_value);
- ptrdiff_t __libunwind_Unwind_GetRegionStart(_Unwind_Context_Ptr context);
+ size_t __libunwind_Unwind_GetRegionStart(_Unwind_Context_Ptr context);
alias __libunwind_Unwind_Resume _Unwind_Resume;
alias __libunwind_Unwind_RaiseException _Unwind_RaiseException;
@@ -94,27 +93,30 @@
alias __libunwind_Unwind_SetGR _Unwind_SetGR;
alias __libunwind_Unwind_GetRegionStart _Unwind_GetRegionStart;
}
-else version(X86_UNWIND)
+else version(X86_UNWIND)
{
void _Unwind_Resume(_Unwind_Exception*);
_Unwind_Reason_Code _Unwind_RaiseException(_Unwind_Exception*);
ptrdiff_t _Unwind_GetLanguageSpecificData(_Unwind_Context_Ptr context);
- ptrdiff_t _Unwind_GetIP(_Unwind_Context_Ptr context);
+ size_t _Unwind_GetIP(_Unwind_Context_Ptr context);
ptrdiff_t _Unwind_SetIP(_Unwind_Context_Ptr context, ptrdiff_t new_value);
ptrdiff_t _Unwind_SetGR(_Unwind_Context_Ptr context, int index,
ptrdiff_t new_value);
- ptrdiff_t _Unwind_GetRegionStart(_Unwind_Context_Ptr context);
+ size_t _Unwind_GetRegionStart(_Unwind_Context_Ptr context);
+
+ size_t _Unwind_GetTextRelBase(_Unwind_Context_Ptr);
+ size_t _Unwind_GetDataRelBase(_Unwind_Context_Ptr);
}
else
{
// runtime calls these directly
void _Unwind_Resume(_Unwind_Exception*)
{
- console("_Unwind_Resume is not implemented on this platform.\n");
+ printf("_Unwind_Resume is not implemented on this platform.\n");
}
_Unwind_Reason_Code _Unwind_RaiseException(_Unwind_Exception*)
{
- console("_Unwind_RaiseException is not implemented on this platform.\n");
+ printf("_Unwind_RaiseException is not implemented on this platform.\n");
return _Unwind_Reason_Code.FATAL_PHASE1_ERROR;
}
}
@@ -122,14 +124,161 @@
}
// error and exit
-extern(C) private void fatalerror(char[] format)
+extern(C) private void fatalerror(char* format, ...)
{
- printf("Fatal error in EH code: %.*s\n", format.length, format.ptr);
+// va_list args;
+// va_start(args, format);
+ printf("Fatal error in EH code: ");
+// vprintf(format, args);
+ printf("\n");
abort();
}
-// helpers for reading certain DWARF data
+// DWARF EH encoding enum
+// See e.g. http://refspecs.freestandards.org/LSB_3.1.1/LSB-Core-generic/LSB-Core-generic/dwarfext.html
+private enum : ubyte {
+ DW_EH_PE_omit = 0xff, // value is not present
+
+ // value format
+ DW_EH_PE_absptr = 0x00, // literal pointer
+ DW_EH_PE_uleb128 = 0x01,
+ DW_EH_PE_udata2 = 0x02, // unsigned 2-byte
+ DW_EH_PE_udata4 = 0x03,
+ DW_EH_PE_udata8 = 0x04,
+ DW_EH_PE_sleb128 = 0x09,
+ DW_EH_PE_sdata2 = 0x0a,
+ DW_EH_PE_sdata4 = 0x0b,
+ DW_EH_PE_sdata8 = 0x0c,
+
+ // value meaning
+ DW_EH_PE_pcrel = 0x10, // relative to program counter
+ DW_EH_PE_textrel = 0x20, // relative to .text
+ DW_EH_PE_datarel = 0x30, // relative to .got or .eh_frame_hdr
+ DW_EH_PE_funcrel = 0x40, // relative to beginning of function
+ DW_EH_PE_aligned = 0x50, // is an aligned void*
+
+ // value is a pointer to the actual value
+ // this is a mask on top of one of the above
+ DW_EH_PE_indirect = 0x80
+}
+
+// Helpers for reading DWARF data
+
+// Given an encoding and a context, return the base to which the encoding is
+// relative
+private size_t base_of_encoded(_Unwind_Context_Ptr context, ubyte encoding)
+{
+ if (encoding == DW_EH_PE_omit)
+ return 0;
+
+ switch (encoding & 0x70) // ignore DW_EH_PE_indirect
+ {
+ case DW_EH_PE_absptr, DW_EH_PE_pcrel, DW_EH_PE_aligned:
+ return 0;
+
+ case DW_EH_PE_textrel: return _Unwind_GetTextRelBase(context);
+ case DW_EH_PE_datarel: return _Unwind_GetDataRelBase(context);
+ case DW_EH_PE_funcrel: return _Unwind_GetRegionStart(context);
+
+ default: fatalerror("Unrecognized base for DWARF value");
+ }
+}
+
+// Only defined for fixed-size encodings
+private size_t size_of_encoded(ubyte encoding)
+{
+ if (encoding == DW_EH_PE_omit)
+ return 0;
+
+ switch (encoding & 0x07) // ignore leb128
+ {
+ case DW_EH_PE_absptr: return (void*).sizeof;
+ case DW_EH_PE_udata2: return 2;
+ case DW_EH_PE_udata4: return 4;
+ case DW_EH_PE_udata8: return 8;
+
+ default: fatalerror("Unrecognized fixed-size DWARF value encoding");
+ }
+}
+
+// Actual value readers below: read a value from the given ubyte* into the
+// output parameter and return the pointer incremented past the value.
+
+// Like read_encoded_with_base but gets the base from the given context
+private ubyte* read_encoded(_Unwind_Context_Ptr context, ubyte encoding, ubyte* p, out size_t val)
+{
+ return read_encoded_with_base(encoding, base_of_encoded(context, encoding), p, val);
+}
+
+private ubyte* read_encoded_with_base(ubyte encoding, size_t base, ubyte* p, out size_t val)
+{
+ if (encoding == DW_EH_PE_aligned)
+ {
+ auto a = cast(size_t)p;
+ a = (a + (void*).sizeof - 1) & -(void*).sizeof;
+ val = *cast(size_t*)a;
+ return cast(ubyte*)(a + (void*).sizeof);
+ }
+
+ union U
+ {
+ size_t ptr;
+ ushort udata2;
+ uint udata4;
+ ulong udata8;
+ short sdata2;
+ int sdata4;
+ long sdata8;
+ }
+
+ auto u = cast(U*)p;
+
+ size_t result;
+
+ switch (encoding & 0x0f)
+ {
+ case DW_EH_PE_absptr:
+ result = u.ptr;
+ p += (void*).sizeof;
+ break;
+
+ case DW_EH_PE_uleb128:
+ {
+ p = get_uleb128(p, result);
+ break;
+ }
+ case DW_EH_PE_sleb128:
+ {
+ ptrdiff_t sleb128;
+ p = get_sleb128(p, sleb128);
+ result = cast(size_t)sleb128;
+ break;
+ }
+
+ case DW_EH_PE_udata2: result = cast(size_t)u.udata2; p += 2; break;
+ case DW_EH_PE_udata4: result = cast(size_t)u.udata4; p += 4; break;
+ case DW_EH_PE_udata8: result = cast(size_t)u.udata8; p += 8; break;
+ case DW_EH_PE_sdata2: result = cast(size_t)u.sdata2; p += 2; break;
+ case DW_EH_PE_sdata4: result = cast(size_t)u.sdata4; p += 4; break;
+ case DW_EH_PE_sdata8: result = cast(size_t)u.sdata8; p += 8; break;
+
+ default: fatalerror("Unrecognized DWARF value encoding format");
+ }
+ if (result)
+ {
+ if ((encoding & 0x70) == DW_EH_PE_pcrel)
+ result += cast(size_t)u;
+ else
+ result += base;
+
+ if (encoding & DW_EH_PE_indirect)
+ result = *cast(size_t*)result;
+ }
+ val = result;
+ return p;
+}
+
private ubyte* get_uleb128(ubyte* addr, ref size_t res)
{
res = 0;
@@ -137,7 +286,7 @@
// read as long as high bit is set
while(*addr & 0x80) {
- res |= (*addr & 0x7f) << bitsize;
+ res |= (*addr & 0x7fU) << bitsize;
bitsize += 7;
addr += 1;
if(bitsize >= size_t.sizeof*8)
@@ -153,12 +302,12 @@
private ubyte* get_sleb128(ubyte* addr, ref ptrdiff_t res)
{
- res = 0;
+ size_t tres = 0;
size_t bitsize = 0;
// read as long as high bit is set
while(*addr & 0x80) {
- res |= (*addr & 0x7f) << bitsize;
+ tres |= (*addr & 0x7fU) << bitsize;
bitsize += 7;
addr += 1;
if(bitsize >= size_t.sizeof*8)
@@ -167,12 +316,14 @@
// read last
if(bitsize != 0 && *addr >= 1 << size_t.sizeof*8 - bitsize)
fatalerror("tried to read sleb128 that exceeded size of size_t");
- res |= (*addr) << bitsize;
+ tres |= (*addr) << bitsize;
// take care of sign
- if(bitsize < size_t.sizeof*8 && ((*addr) & 0x40))
- res |= cast(ptrdiff_t)(-1) ^ ((1 << (bitsize+7)) - 1);
+ if(bitsize < size_t.sizeof*8 && (*addr & 0x40U) != 0)
+ tres |= cast(size_t)(-1) ^ ((1 << (bitsize+7)) - 1);
+ res = cast(ptrdiff_t)tres;
+
return addr + 1;
}
@@ -190,8 +341,7 @@
// the 8-byte string identifying the type of exception
// the first 4 are for vendor, the second 4 for language
-//TODO: This may be the wrong way around
-const char[8] _d_exception_class = "LLDCD1\0\0";
+const char[8] _d_exception_class = "LDC_D_10";
//
@@ -201,118 +351,174 @@
version(X86_UNWIND)
{
+// Various stuff we need
+struct Region
+{
+ ubyte* callsite_table;
+ ubyte* action_table;
+
+ // Note: classinfo_table points past the end of the table
+ ubyte* classinfo_table;
+
+ size_t start;
+ size_t lpStart_base; // landing pad base
+
+ ubyte ttypeEnc;
+ size_t ttype_base; // typeinfo base
+
+ ubyte callSiteEnc;
+}
+
// the personality routine gets called by the unwind handler and is responsible for
// reading the EH tables and deciding what to do
extern(C) _Unwind_Reason_Code _d_eh_personality(int ver, _Unwind_Action actions, ulong exception_class, _Unwind_Exception* exception_info, _Unwind_Context_Ptr context)
{
+ debug(EH_personality) printf("Entering personality routine, context=%p\n", context);
// check ver: the C++ Itanium ABI only allows ver == 1
if(ver != 1)
+ {
+ debug(EH_personality) printf("eh version mismatch\n");
return _Unwind_Reason_Code.FATAL_PHASE1_ERROR;
+ }
// check exceptionClass
//TODO: Treat foreign exceptions with more respect
- if((cast(char*)&exception_class)[0..8] != _d_exception_class)
+ auto wanted_ec = *cast(ulong*)_d_exception_class.ptr;
+ if(exception_class != wanted_ec)
+ {
+ debug(EH_personality) printf("exception class mismatch %p vs %p\n", exception_class, wanted_ec);
return _Unwind_Reason_Code.FATAL_PHASE1_ERROR;
+ }
// find call site table, action table and classinfo table
// Note: callsite and action tables do not contain static-length
// data and will be parsed as needed
- // Note: classinfo_table points past the end of the table
- ubyte* callsite_table;
- ubyte* action_table;
- ClassInfo* classinfo_table;
- _d_getLanguageSpecificTables(context, callsite_table, action_table, classinfo_table);
- if (!callsite_table)
+
+ Region region;
+
+ _d_getLanguageSpecificTables(context, region);
+
+ // workaround. this should not happen
+ if (!region.callsite_table)
+ {
+ debug(EH_personality) printf("callsite_table is null\n");
return _Unwind_Reason_Code.CONTINUE_UNWIND;
+ }
+ debug(EH_personality) printf("yay, checking\n");
+ debug(EH_personality) printf("region.start = %p\n", region.start);
+
/*
find landing pad and action table index belonging to ip by walking
the callsite_table
*/
- ubyte* callsite_walker = callsite_table;
+ ubyte* callsite_walker = region.callsite_table;
+ debug(EH_personality) printf("callsite table at: %p\n", region.callsite_table);
+ debug(EH_personality) printf("action table at: %p\n", region.action_table);
+ debug(EH_personality) printf("rtti table at %p\n", region.classinfo_table);
// get the instruction pointer
// will be used to find the right entry in the callsite_table
// -1 because it will point past the last instruction
- ptrdiff_t ip = _Unwind_GetIP(context) - 1;
+ debug(EH_personality) printf("check1\n");
+ size_t ip = _Unwind_GetIP(context) - 1;
+ debug(EH_personality) printf("check2\n");
- // address block_start is relative to
- ptrdiff_t region_start = _Unwind_GetRegionStart(context);
-
// table entries
- uint block_start_offset, block_size;
- ptrdiff_t landing_pad;
+ size_t landing_pad;
size_t action_offset;
while(true) {
// if we've gone through the list and found nothing...
- if(callsite_walker >= action_table)
+ if(callsite_walker >= region.action_table)
+ {
+ debug(EH_personality) printf("found nothing\n");
return _Unwind_Reason_Code.CONTINUE_UNWIND;
+ }
- block_start_offset = *cast(uint*)callsite_walker;
- block_size = *(cast(uint*)callsite_walker + 1);
- landing_pad = *(cast(uint*)callsite_walker + 2);
- if(landing_pad)
- landing_pad += region_start;
- callsite_walker = get_uleb128(callsite_walker + 3*uint.sizeof, action_offset);
+ size_t block_start, block_size;
- debug(EH_personality_verbose) printf("ip=%llx %d %d %llx\n", ip, block_start_offset, block_size, landing_pad);
+ callsite_walker = read_encoded(null, region.callSiteEnc, callsite_walker, block_start);
+ callsite_walker = read_encoded(null, region.callSiteEnc, callsite_walker, block_size);
+ callsite_walker = read_encoded(null, region.callSiteEnc, callsite_walker, landing_pad);
+ callsite_walker = get_uleb128(callsite_walker, action_offset);
+ debug(EH_personality) printf("*block start offset = %p\n", block_start);
+ debug(EH_personality) printf(" block size = %p\n", block_size);
+ debug(EH_personality) printf(" landing pad = %p\n", landing_pad);
+ debug(EH_personality) printf(" ip=%p %p %p %p\n", ip, block_start, block_size, landing_pad);
+
// since the list is sorted, as soon as we're past the ip
// there's no handler to be found
- if(ip < region_start + block_start_offset)
+ if(ip < region.start + block_start)
+ {
+ debug(EH_personality) printf("found nothing2\n");
return _Unwind_Reason_Code.CONTINUE_UNWIND;
+ }
+ if(landing_pad)
+ landing_pad += region.lpStart_base;
+
// if we've found our block, exit
- if(ip < region_start + block_start_offset + block_size)
+ if(ip < region.start + block_start + block_size)
break;
}
- debug(EH_personality) printf("Found correct landing pad and actionOffset %d\n", action_offset);
+ debug(EH_personality) printf("Found correct landing pad %p and actionOffset %p\n", landing_pad, action_offset);
// now we need the exception's classinfo to find a handler
// the exception_info is actually a member of a larger _d_exception struct
// the runtime allocated. get that now
- _d_exception* exception_struct = cast(_d_exception*)(cast(ubyte*)exception_info - _d_exception.unwind_info.offsetof);
+ _d_exception* exception_struct = cast(_d_exception*)(cast(ubyte*)exception_info - size_t.sizeof); //_d_exception.unwind_info.offsetof);
// if there's no action offset and no landing pad, continue unwinding
if(!action_offset && !landing_pad)
return _Unwind_Reason_Code.CONTINUE_UNWIND;
// if there's no action offset but a landing pad, this is a cleanup handler
- else if(!action_offset && landing_pad)
- return _d_eh_install_finally_context(actions, landing_pad, exception_struct, context);
+ else if(!action_offset && landing_pad != 0)
+ {
+ debug(EH_personality) printf("installing finally context\n");
+ return _d_eh_install_finally_context(actions, cast(ptrdiff_t)landing_pad, exception_struct, context);
+ }
/*
walk action table chain, comparing classinfos using _d_isbaseof
*/
- ubyte* action_walker = action_table + action_offset - 1;
+ ubyte* action_walker = region.action_table + action_offset - 1;
- ptrdiff_t ti_offset, next_action_offset;
while(true) {
+ ptrdiff_t ti_offset, next_action_offset;
+
action_walker = get_sleb128(action_walker, ti_offset);
// it is intentional that we not modify action_walker here
// next_action_offset is from current action_walker position
get_sleb128(action_walker, next_action_offset);
// negative are 'filters' which we don't use
- if(!(ti_offset >= 0))
+ if(ti_offset < 0)
fatalerror("Filter actions are unsupported");
// zero means cleanup, which we require to be the last action
if(ti_offset == 0) {
- if(!(next_action_offset == 0))
+ if(next_action_offset != 0)
fatalerror("Cleanup action must be last in chain");
- return _d_eh_install_finally_context(actions, landing_pad, exception_struct, context);
+ return _d_eh_install_finally_context(actions, cast(ptrdiff_t)landing_pad, exception_struct, context);
}
// get classinfo for action and check if the one in the
// exception structure is a base
- ClassInfo catch_ci = *(classinfo_table - ti_offset);
- debug(EH_personality) printf("Comparing catch %s to exception %s\n", catch_ci.name.ptr, exception_struct.exception_object.classinfo.name.ptr);
- if(_d_isbaseof(exception_struct.exception_object.classinfo, catch_ci))
- return _d_eh_install_catch_context(actions, ti_offset, landing_pad, exception_struct, context);
+ size_t typeinfo;
+ auto filter = cast(size_t)ti_offset * size_of_encoded(region.ttypeEnc);
+ read_encoded_with_base(region.ttypeEnc, region.ttype_base, region.classinfo_table - filter, typeinfo);
+ debug(EH_personality)
+ printf("classinfo at %zx (enc %zx (size %zx) base %zx ptr %zx)\n", typeinfo, region.ttypeEnc, size_of_encoded(region.ttypeEnc), region.ttype_base, region.classinfo_table - filter);
+
+ auto catch_ci = *cast(ClassInfo*)&typeinfo;
+ if(_d_dynamic_cast(exception_struct.exception_object, catch_ci) !is null)
+ return _d_eh_install_catch_context(actions, ti_offset, cast(ptrdiff_t)landing_pad, exception_struct, context);
+
// we've walked through all actions and found nothing...
if(next_action_offset == 0)
return _Unwind_Reason_Code.CONTINUE_UNWIND;
@@ -356,6 +562,7 @@
}
fatalerror("reached unreachable");
+
return _Unwind_Reason_Code.FATAL_PHASE2_ERROR;
}
@@ -370,56 +577,78 @@
_Unwind_SetGR(context, eh_exception_regno, cast(ptrdiff_t)exception_struct);
_Unwind_SetGR(context, eh_selector_regno, 0);
_Unwind_SetIP(context, landing_pad);
+
return _Unwind_Reason_Code.INSTALL_CONTEXT;
}
-private void _d_getLanguageSpecificTables(_Unwind_Context_Ptr context, ref ubyte* callsite, ref ubyte* action, ref ClassInfo* ci)
+private void _d_getLanguageSpecificTables(_Unwind_Context_Ptr context, out Region region)
{
- ubyte* data = cast(ubyte*)_Unwind_GetLanguageSpecificData(context);
+ auto data = cast(ubyte*)_Unwind_GetLanguageSpecificData(context);
+
+ // workaround. this should not be 0...
if (!data)
{
- callsite = null;
- action = null;
- ci = null;
- return;
+ //printf("language specific data is null\n");
+ return;
}
- //TODO: Do proper DWARF reading here
- if(*data++ != 0xff)
- fatalerror("DWARF header has unexpected format 1");
+ region.start = _Unwind_GetRegionStart(context);
- if(*data++ != 0x00)
- fatalerror("DWARF header has unexpected format 2");
- size_t cioffset;
- data = get_uleb128(data, cioffset);
- ci = cast(ClassInfo*)(data + cioffset);
+ // Read the C++-style LSDA: this is implementation-defined by GCC but LLVM
+ // outputs the same kind of table
- if(*data++ != 0x03)
- fatalerror("DWARF header has unexpected format 3");
- size_t callsitelength;
- data = get_uleb128(data, callsitelength);
- action = data + callsitelength;
+ // Get @LPStart: landing pad offsets are relative to it
+ auto lpStartEnc = *data++;
+ if (lpStartEnc == DW_EH_PE_omit)
+ region.lpStart_base = region.start;
+ else
+ data = read_encoded(context, lpStartEnc, data, region.lpStart_base);
- callsite = data;
+ // Get @TType: the offset to the handler and typeinfo
+ region.ttypeEnc = *data++;
+ if (region.ttypeEnc == DW_EH_PE_omit)
+ // Not sure about this one...
+ fatalerror("@TType must not be omitted from DWARF header");
+
+ size_t ciOffset;
+ data = get_uleb128(data, ciOffset);
+ region.classinfo_table = data + ciOffset;
+
+ region.ttype_base = base_of_encoded(context, region.ttypeEnc);
+
+ // Get encoding and length of the call site table, which precedes the action
+ // table.
+ region.callSiteEnc = *data++;
+ if (region.callSiteEnc == DW_EH_PE_omit)
+ fatalerror("Call site table encoding must not be omitted from DWARF header");
+
+ size_t callSiteLength;
+ region.callsite_table = get_uleb128(data, callSiteLength);
+ region.action_table = region.callsite_table + callSiteLength;
}
} // end of x86 Linux specific implementation
-
-extern(C) void _d_throw_exception(Object e)
+// called to throw object
+extern(C)
+void _d_throw_exception(Object e)
{
+ //printf("throwing %p, rtti = %p\n", e, **cast(ClassRTTI***)e);
if (e !is null)
{
_d_exception* exc_struct = new _d_exception;
exc_struct.unwind_info.exception_class = *cast(ulong*)_d_exception_class.ptr;
exc_struct.exception_object = e;
_Unwind_Reason_Code ret = _Unwind_RaiseException(&exc_struct.unwind_info);
- console("_Unwind_RaiseException failed with reason code: ")(ret)("\n");
+ printf("Error: returned %d from raise exception.\n", ret);
+ //console("_Unwind_RaiseException failed with reason code: ")(ret)("\n");
}
abort();
}
-extern(C) void _d_eh_resume_unwind(_d_exception* exception_struct)
+// called to resume unwinding
+extern(C)
+void _d_eh_resume_unwind(void* exception_struct)
{
- _Unwind_Resume(&exception_struct.unwind_info);
+ _Unwind_Resume(&(cast(_d_exception*)exception_struct).unwind_info);
}
Index: tango/core/vendor/ldc/intrinsics.di
===================================================================
--- tango/core/vendor/ldc/intrinsics.di (revision 5576)
+++ tango/core/vendor/ldc/intrinsics.di (working copy)
@@ -101,8 +101,16 @@
// Note that, unlike the standard libc function, the llvm.memcpy.* intrinsics do
// not return a value, and takes an extra alignment argument.
-pragma(intrinsic, "llvm.memcpy.i#")
- void llvm_memcpy(T)(void* dst, void* src, T len, uint alignment);
+version(LDC_LLVMPre28)
+{
+ pragma(intrinsic, "llvm.memcpy.i#")
+ void llvm_memcpy(T)(void* dst, void* src, T len, uint alignment);
+}
+else
+{
+ pragma(intrinsic, "llvm.memcpy.p0i8.p0i8.i#")
+ void llvm_memcpy(T)(void* dst, void* src, T len, uint alignment, bool volatile_);
+}
deprecated {
alias llvm_memcpy!(uint) llvm_memcpy_i32;
@@ -116,8 +124,16 @@
// Note that, unlike the standard libc function, the llvm.memmove.* intrinsics
// do not return a value, and takes an extra alignment argument.
-pragma(intrinsic, "llvm.memmove.i#")
- void llvm_memmove(T)(void* dst, void* src, T len, uint alignment);
+version(LDC_LLVMPre28)
+{
+ pragma(intrinsic, "llvm.memmove.i#")
+ void llvm_memmove(T)(void* dst, void* src, T len, uint alignment);
+}
+else
+{
+ pragma(intrinsic, "llvm.memmove.p0i8.p0i8.i#")
+ void llvm_memmove(T)(void* dst, void* src, T len, uint alignment, bool volatile_);
+}
deprecated {
alias llvm_memmove!(uint) llvm_memmove_i32;
@@ -130,8 +146,16 @@
// Note that, unlike the standard libc function, the llvm.memset intrinsic does
// not return a value, and takes an extra alignment argument.
-pragma(intrinsic, "llvm.memset.i#")
- void llvm_memset(T)(void* dst, ubyte val, T len, uint alignment);
+version(LDC_LLVMPre28)
+{
+ pragma(intrinsic, "llvm.memset.i#")
+ void llvm_memset(T)(void* dst, ubyte val, T len, uint alignment);
+}
+else
+{
+ pragma(intrinsic, "llvm.memset.p0i8.i#")
+ void llvm_memset(T)(void* dst, ubyte val, T len, uint alignment, bool volatile_);
+}
deprecated {
alias llvm_memset!(uint) llvm_memset_i32;
Reference in New Issue View Git Blame Copy Permalink