private static void DoAllocation(Code c, Stack <StackItem> stack, target.Target t)
{
long alloced = 0;
int stack_loc = 0;
foreach (var si in stack)
{
if (si.ct == Opcode.ct_vt)
{
si.reg = t.AllocateValueType(c, si.ts, ref alloced, ref stack_loc);
}
else if (si.has_address_taken)
{
int size = 0;
if (si.ts.IsValueType)
{
size = layout.Layout.GetTypeSize(si.ts, t, false);
}
else
{
size = t.GetPointerSize();
}
si.reg = t.AllocateStackLocation(c, size, ref stack_loc);
}
else
{
DoAllocation(c, si, t, ref alloced, ref stack_loc);
}
if (si.reg != null)
{
c.regs_used |= si.reg.mask;
}
}
}
public static int GetArrayFieldOffset(ArrayField af, target.Target t)
{
switch (af)
{
case ArrayField.VtblPointer:
return(0);
case ArrayField.MutexLock:
return(1 * t.GetPointerSize());
case ArrayField.ElemTypeVtblPointer:
return(2 * t.GetPointerSize());
case ArrayField.LoboundsPointer:
return(3 * t.GetPointerSize());
case ArrayField.SizesPointer:
return(4 * t.GetPointerSize());
case ArrayField.DataArrayPointer:
return(5 * t.GetPointerSize());
case ArrayField.Rank:
return(6 * t.GetPointerSize());
case ArrayField.ElemTypeSize:
return(7 * t.GetPointerSize());
default:
throw new NotSupportedException();
}
}
public static int GetTypeSize(metadata.TypeSpec ts,
target.Target t, bool is_static = false)
{
switch (ts.stype)
{
case TypeSpec.SpecialType.None:
if (ts.Equals(ts.m.SystemRuntimeTypeHandle) ||
ts.Equals(ts.m.SystemRuntimeMethodHandle) ||
ts.Equals(ts.m.SystemRuntimeFieldHandle))
{
return(is_static ? 0 : (t.GetPointerSize()));
}
if (ts.m.classlayouts[ts.tdrow] != 0 && ts.IsGeneric == false && ts.IsGenericTemplate == false)
{
var size = ts.m.GetIntEntry(metadata.MetadataStream.tid_ClassLayout,
ts.m.classlayouts[ts.tdrow],
1);
if (size != 0)
{
return((int)size);
}
}
return(GetFieldOffset(ts, (string)null, t, out var is_tls, is_static));
case TypeSpec.SpecialType.SzArray:
case TypeSpec.SpecialType.Array:
if (is_static)
{
return(0);
}
return(GetArrayObjectSize(t));
case TypeSpec.SpecialType.Boxed:
if (is_static)
{
return(0);
}
return(GetTypeSize(ts.m.SystemObject, t) +
GetTypeSize(ts.Unbox, t));
default:
throw new NotImplementedException();
}
}
private static void OutputVirtualMethods(TypeSpec decl_ts,
IBinaryFile of, ISection os,
IList <byte> d, ref ulong offset, target.Target t,
TysilaState s)
{
var vmeths = GetVirtualMethodDeclarations(decl_ts);
ImplementVirtualMethods(decl_ts, vmeths);
foreach (var vmeth in vmeths)
{
var impl_ms = vmeth.impl_meth;
string impl_target = (impl_ms == null) ? "__cxa_pure_virtual" : impl_ms.MethodReferenceAlias;
var impl_sym = of.CreateSymbol();
impl_sym.Name = impl_target;
impl_sym.ObjectType = SymbolObjectType.Function;
var impl_reloc = of.CreateRelocation();
impl_reloc.Addend = 0;
impl_reloc.DefinedIn = os;
impl_reloc.Offset = offset;
impl_reloc.References = impl_sym;
impl_reloc.Type = t.GetDataToCodeReloc();
of.AddRelocation(impl_reloc);
for (int i = 0; i < t.GetPointerSize(); i++, offset++)
{
d.Add(0);
}
if (impl_ms != null)
{
s.r.MethodRequestor.Request(impl_ms);
}
}
}
public static void OutputStaticFields(metadata.TypeSpec ts,
target.Target t, binary_library.IBinaryFile of,
MetadataStream base_m = null,
binary_library.ISection os = null,
binary_library.ISection tlsos = null)
{
// Don't compile if not for this architecture
if (!t.IsTypeValid(ts))
{
return;
}
int align = 1;
if (ts.SimpleType == 0)
{
align = GetTypeAlignment(ts, t, true);
}
if (os == null)
{
os = of.GetDataSection();
}
os.Align(t.GetPointerSize());
os.Align(align);
ulong offset = (ulong)os.Data.Count;
ulong tl_offset = 0;
if (tlsos != null)
{
tl_offset = (ulong)tlsos.Data.Count;
}
int cur_offset = 0;
int cur_tloffset = 0;
/* is_initialized */
for (int i = 0; i < t.psize; i++)
{
os.Data.Add(0);
}
cur_offset += t.psize;
/* Iterate through methods looking for requested
* one */
var first_fdef = ts.m.GetIntEntry(MetadataStream.tid_TypeDef,
ts.tdrow, 4);
var last_fdef = ts.m.GetLastFieldDef(ts.tdrow);
for (uint fdef_row = first_fdef; fdef_row < last_fdef; fdef_row++)
{
// Ensure field is static or not as required
var flags = ts.m.GetIntEntry(MetadataStream.tid_Field,
(int)fdef_row, 0);
if ((flags & 0x10) == 0x10)
{
// Increment by type size
var fsig = (int)ts.m.GetIntEntry(MetadataStream.tid_Field,
(int)fdef_row, 2);
var ft = ts.m.GetFieldType(ref fsig, ts.gtparams, null);
var ft_size = t.GetSize(ft);
ft_size = util.util.align(ft_size, align);
bool is_tls = ts.m.thread_local_fields[(int)fdef_row];
ISection cur_os = os;
if (is_tls)
{
if (tlsos == null)
{
throw new NotSupportedException("No thread-local section provided");
}
cur_os = tlsos;
}
/* See if there is any data defined as an rva */
var rva = ts.m.fieldrvas[(int)fdef_row];
if (rva != 0)
{
var rrva = (int)ts.m.ResolveRVA(rva);
for (int i = 0; i < ft_size; i++)
{
cur_os.Data.Add(ts.m.file.ReadByte(rrva++));
}
}
else
{
for (int i = 0; i < ft_size; i++)
{
cur_os.Data.Add(0);
}
}
/* Output any additional defined symbols */
foreach (var alias in ts.m.GetFieldAliases((int)fdef_row))
{
var asym = of.CreateSymbol();
asym.Name = alias;
asym.Offset = offset + (ulong)cur_offset;
asym.Type = binary_library.SymbolType.Global;
asym.ObjectType = binary_library.SymbolObjectType.Object;
cur_os.AddSymbol(asym);
asym.Size = ft_size;
if (base_m != null && ts.m != base_m)
{
asym.Type = binary_library.SymbolType.Weak;
}
}
if (is_tls)
{
cur_tloffset += ft_size;
}
else
{
cur_offset += ft_size;
}
}
}
if (cur_offset > 0)
{
/* Add symbol */
var sym = of.CreateSymbol();
sym.Name = ts.m.MangleType(ts) + "S";
sym.Offset = offset;
sym.Type = binary_library.SymbolType.Global;
sym.ObjectType = binary_library.SymbolObjectType.Object;
os.AddSymbol(sym);
sym.Size = os.Data.Count - (int)offset;
if (base_m != null && ts.m != base_m)
{
sym.Type = binary_library.SymbolType.Weak;
}
}
if (cur_tloffset > 0)
{
/* Add thread local symbol */
var sym = of.CreateSymbol();
sym.Name = ts.m.MangleType(ts) + "ST";
sym.Offset = tl_offset;
sym.Type = binary_library.SymbolType.Global;
sym.ObjectType = binary_library.SymbolObjectType.Object;
tlsos.AddSymbol(sym);
sym.Size = tlsos.Data.Count - (int)tl_offset;
if (base_m != null && ts.m != base_m)
{
sym.Type = binary_library.SymbolType.Weak;
}
}
}
public static int GetFieldOffset(metadata.TypeSpec ts,
string fname, target.Target t, out bool is_tls, bool is_static = false,
List <TypeSpec> field_types = null, List <string> field_names = null,
List <int> field_offsets = null)
{
int align = 1;
is_tls = false;
if (ts.SimpleType == 0) // class
{
align = GetTypeAlignment(ts, t, is_static);
}
if (ts.SimpleType == 0xe && !is_static) // string
{
align = t.GetPointerSize();
}
if (ts.Equals(ts.m.SystemString) && !is_static)
{
/* System.String has a special layout in dotnet clr because the fields
* length and firstchar are reversed */
if (field_names != null)
{
field_names.Add("__vtbl");
field_names.Add("__mutex_lock");
field_names.Add("m_stringLength");
field_names.Add("m_firstChar");
}
if (field_types != null)
{
field_types.Add(ts.m.SystemIntPtr);
field_types.Add(ts.m.SystemInt64);
field_types.Add(ts.m.SystemInt32);
field_types.Add(ts.m.SystemChar);
}
if (field_offsets != null)
{
field_offsets.Add(0);
field_offsets.Add(GetArrayFieldOffset(ArrayField.MutexLock, t));
field_offsets.Add(GetTypeSize(ts.m.SystemObject, t));
field_offsets.Add(GetTypeSize(ts.m.SystemObject, t) + t.GetPointerSize());
}
if (fname == null)
{
// size = sizeof(Object) + sizeof(int length), aligned to pointer size
return(GetTypeSize(ts.m.SystemObject, t) + t.GetPointerSize());
}
else
{
if (fname == "length" || fname == "m_stringLength")
{
return(GetTypeSize(ts.m.SystemObject, t));
}
else if (fname == "start_char" || fname == "m_firstChar")
{
return(GetTypeSize(ts.m.SystemObject, t) + t.GetPointerSize());
}
else
{
throw new NotSupportedException();
}
}
}
/* Iterate through methods looking for requested
* one */
var first_fdef = ts.m.GetIntEntry(MetadataStream.tid_TypeDef,
ts.tdrow, 4);
var last_fdef = ts.m.GetLastFieldDef(ts.tdrow);
int cur_offset = 0;
int cur_tl_offset = 0;
if (is_static == false && !ts.IsValueType)
{
if (ts.GetExtends() == null)
{
// Add a vtable entry
if (field_offsets != null)
{
field_offsets.Add(cur_offset);
}
cur_offset += t.GetCTSize(ir.Opcode.ct_object);
cur_offset = util.util.align(cur_offset, align);
if (field_types != null)
{
field_types.Add(ts.m.SystemIntPtr);
}
if (field_names != null)
{
field_names.Add("__vtbl");
}
// Add a mutex lock entry
if (field_offsets != null)
{
field_offsets.Add(cur_offset);
}
cur_offset += t.GetCTSize(ir.Opcode.ct_int64);
cur_offset = util.util.align(cur_offset, align);
if (field_types != null)
{
field_types.Add(ts.m.SystemInt64);
}
if (field_names != null)
{
field_names.Add("__mutex_lock");
}
}
else
{
cur_offset = GetFieldOffset(ts.GetExtends(), (string)null, t,
out is_tls,
is_static, field_types, field_names, field_offsets);
cur_offset = util.util.align(cur_offset, align);
}
}
else if (is_static)
{
// Add an is_initalized field
cur_offset += t.GetCTSize(ir.Opcode.ct_intptr);
cur_offset = util.util.align(cur_offset, align);
}
for (uint fdef_row = first_fdef; fdef_row < last_fdef; fdef_row++)
{
// Ensure field is static if requested
var flags = ts.m.GetIntEntry(MetadataStream.tid_Field,
(int)fdef_row, 0);
if (((flags & 0x10) == 0x10 && is_static == true) ||
((flags & 0x10) == 0 && is_static == false))
{
// Check on name if we are looking for a particular field
bool f_is_tls = ts.m.thread_local_fields[fdef_row];
if (fname != null)
{
var ffname = ts.m.GetIntEntry(MetadataStream.tid_Field,
(int)fdef_row, 1);
if (MetadataStream.CompareString(ts.m, ffname, fname))
{
if (f_is_tls)
{
is_tls = true;
return(cur_tl_offset);
}
else
{
is_tls = false;
return(cur_offset);
}
}
}
// Increment by type size
var fsig = (int)ts.m.GetIntEntry(MetadataStream.tid_Field,
(int)fdef_row, 2);
var ft = ts.m.GetFieldType(ref fsig, ts.gtparams, null);
var ft_size = t.GetSize(ft);
if (field_types != null)
{
field_types.Add(ft);
}
if (field_names != null)
{
var cur_fname = ts.m.GetStringEntry(MetadataStream.tid_Field,
(int)fdef_row, 1);
field_names.Add(cur_fname);
}
if (field_offsets != null)
{
if (f_is_tls)
{
field_offsets.Add(cur_tl_offset);
}
else
{
field_offsets.Add(cur_offset);
}
}
if (f_is_tls)
{
cur_tl_offset += ft_size;
cur_tl_offset = util.util.align(cur_tl_offset, align);
}
else
{
cur_offset += ft_size;
cur_offset = util.util.align(cur_offset, align);
}
}
}
// Shouldn't get here if looking for a specific field
if (fname != null)
{
throw new MissingFieldException();
}
// Else return size of complete type
return(cur_offset);
}
public static int GetArrayObjectSize(target.Target t)
{
// round up to 8x intptr size so size is aligned to word size
return(8 * t.GetPointerSize());
}