protected virtual Reg GetRegLoc(ir.Param csite,
ref int stack_loc,
int cc_next,
int ct,
metadata.TypeSpec ts,
string cc)
{
throw new NotSupportedException("Architecture does not support ct: " + Opcode.ct_names[ct]);
}
internal static unsafe void *JitCompile(metadata.TypeSpec ts)
{
var s = InitTysilaState();
// Add the new vtable to the requestor
((JitRequestor)s.r).VTableRequestor.Request(ts);
// Compile all needed bits
JitProcess.ProcessRequestedItems(s, Program.stab);
// Add everything from the current state to output sections
return(CopyToOutput(s, RDataSection)); // First VTable requested will be at start of RData section
}
internal static int GetCTFromType(metadata.TypeSpec ts)
{
if (ts == null)
{
return(ct_unknown);
}
switch (ts.stype)
{
case metadata.TypeSpec.SpecialType.None:
if (ts.m.is_corlib && ts.m.simple_type_idx[ts.tdrow] != -1)
{
return(GetCTFromType(ts.m.simple_type_idx[ts.tdrow]));
}
if (ts.IsEnum)
{
return(GetCTFromType(ts.UnderlyingType));
}
if (ts.IsValueType)
{
return(ct_vt);
}
return(ct_object);
case metadata.TypeSpec.SpecialType.SzArray:
case metadata.TypeSpec.SpecialType.Array:
return(ct_object);
case metadata.TypeSpec.SpecialType.MPtr:
return(ct_ref);
case metadata.TypeSpec.SpecialType.Ptr:
return(ct_intptr);
case metadata.TypeSpec.SpecialType.Boxed:
return(ct_object);
default:
throw new NotSupportedException();
}
}
public virtual bool IsTypeValid(metadata.TypeSpec ts)
{
if (ts == null)
{
return(true);
}
if (ts.HasCustomAttribute("_ZN14libsupcs#2Edll8libsupcs19Bits32OnlyAttribute_7#2Ector_Rv_P1u1t") &&
GetPointerSize() != 4)
{
return(false);
}
if (ts.HasCustomAttribute("_ZN14libsupcs#2Edll8libsupcs19Bits64OnlyAttribute_7#2Ector_Rv_P1u1t") &&
GetPointerSize() != 8)
{
return(false);
}
bool is_arch_dependent = false;
bool is_required_arch = false;
foreach (var idx in ts.CustomAttributes("_ZN14libsupcs#2Edll8libsupcs22ArchDependentAttribute_7#2Ector_Rv_P2u1tu1S"))
{
var sig_idx = ts.m.GetCustomAttrSigIdx(idx);
var arch = ts.m.ReadCustomAttrString(ref sig_idx);
is_arch_dependent = true;
if (arch.Equals(name))
{
is_required_arch = true;
}
}
if (is_arch_dependent && !is_required_arch)
{
return(false);
}
return(true);
}
internal int GetSize(metadata.TypeSpec ts)
{
switch (ts.stype)
{
case metadata.TypeSpec.SpecialType.None:
if (ts.m.is_corlib)
{
var simple = ts.m.simple_type_idx[ts.tdrow];
if (simple != -1)
{
return(GetSTypeSize(simple));
}
}
if (ts.IsValueType)
{
return(layout.Layout.GetTypeSize(ts, this, false));
}
return(GetCTSize(Opcode.ct_object));
default:
return(GetCTSize(Opcode.ct_object));
}
}
internal List <MCInst> handle_external(Target t,
List <cil.CilNode.IRNode> nodes,
int start, int count, Code c, string func_name)
{
var n = nodes[start];
var lastn = nodes[start + count - 1];
metadata.TypeSpec[] p;
if (n.ct != ir.Opcode.ct_unknown)
{
var ats = ir.Opcode.GetTypeFromCT(n.ct, c.ms.m);
if (n.ct2 != ir.Opcode.ct_unknown)
{
var bts = ir.Opcode.GetTypeFromCT(n.ct, c.ms.m);
p = new metadata.TypeSpec[] { ats, bts };
}
else
{
p = new metadata.TypeSpec[] { ats }
};
}
else
{
p = new metadata.TypeSpec[] { }
};
var rts = ir.Opcode.GetTypeFromCT(lastn.ctret, c.ms.m);
/* If we are compressing lots of ir into a single call,
* make sure the call instuction is aware of the end stack
* state */
if (n != lastn)
{
n.stack_after = lastn.stack_after;
}
var msig = c.special_meths.CreateMethodSignature(rts, p);
n.imm_ms = new metadata.MethodSpec {
mangle_override = func_name, m = c.special_meths, msig = msig
};
n.opcode = ir.Opcode.oc_call;
/* Now locate the call instruction */
var call_handler = instrs.GetValue(nodes, start, 1);
if (call_handler == null)
{
throw new Exception("Unable to locate call handler");
}
var r = call_handler(t, nodes, start, 1, c);
if (r == null)
{
throw new Exception("Unable to invoke call handler to handle external call");
}
return(r);
}
}
public void AllocateLocalVarsArgs(Code c)
{
/* Generate list of locations of local vars */
var m = c.ms.m;
var ms = c.ms;
int idx = c.lvar_sig_tok;
int lv_count = m.GetLocalVarCount(ref idx);
int[] lv_locs = new int[lv_count];
c.lv_locs = new Reg[lv_count];
c.lv_sizes = new int[lv_count];
c.lv_types = new metadata.TypeSpec[lv_count];
int cur_loc = GetCCStackReserve(c.ms.CallingConvention);
for (int i = 0; i < lv_count; i++)
{
var type = m.GetTypeSpec(ref idx, c.ms.gtparams,
c.ms.gmparams);
int t_size = GetSize(type);
lv_locs[i] = cur_loc;
t_size = util.util.align(t_size, GetPointerSize());
c.lv_sizes[i] = t_size;
c.lv_types[i] = type;
c.lv_locs[i] = GetLVLocation(cur_loc, t_size, c);
cur_loc += t_size;
// align to pointer size
int diff = cur_loc % GetPointerSize();
if (diff != 0)
{
cur_loc = cur_loc - diff + GetPointerSize();
}
}
/* Do the same for local args */
int la_count = m.GetMethodDefSigParamCountIncludeThis(
c.ms.msig);
int[] la_locs = new int[la_count];
c.la_locs = new Reg[la_count];
c.la_needs_assign = new bool[la_count];
int la_count2 = m.GetMethodDefSigParamCount(
c.ms.msig);
int laidx = 0;
//cur_loc = 0;
var cc = cc_map[c.ms.CallingConvention];
var cc_class_map = cc_classmap[c.ms.CallingConvention];
bool has_hidden = ir.Opcode.GetCTFromType(c.ret_ts) == ir.Opcode.ct_vt;
int stack_loc = 0;
metadata.TypeSpec hidden_ts = null;
if (has_hidden)
{
hidden_ts = m.SystemIntPtr;
}
var la_phys_locs = GetRegLocs(new ir.Param
{
m = m,
ms = c.ms,
}, ref stack_loc, cc, cc_class_map,
c.ms.CallingConvention,
out c.la_sizes, out c.la_types,
hidden_ts);
if (has_hidden)
{
// Strip hidden argument off the values we return
Reg[] la_phys_locs_new = new Reg[la_phys_locs.Length - 1];
for (int i = 0; i < la_phys_locs_new.Length; i++)
{
la_phys_locs_new[i] = la_phys_locs[i + 1];
}
la_phys_locs = la_phys_locs_new;
int[] la_sizes = new int[la_phys_locs.Length];
for (int i = 0; i < la_phys_locs_new.Length; i++)
{
la_sizes[i] = c.la_sizes[i + 1];
}
c.la_sizes = la_sizes;
metadata.TypeSpec[] la_types = new metadata.TypeSpec[la_phys_locs.Length];
for (int i = 0; i < la_phys_locs_new.Length; i++)
{
la_types[i] = c.la_types[i + 1];
}
c.la_types = la_types;
}
c.incoming_args = la_phys_locs;
if (la_count != la_count2)
{
var this_size = GetCTSize(ir.Opcode.ct_object);
c.la_locs[laidx] = GetLALocation(cur_loc, this_size, c);
c.la_sizes[laidx] = this_size;
// value type methods have mptr to type as their this pointer
if (ms.type.IsValueType)
{
c.la_types[laidx] = ms.type.ManagedPointer;
}
else
{
c.la_types[laidx] = ms.type;
}
la_locs[laidx] = cur_loc;
//cur_loc += this_size;
laidx++;
}
idx = m.GetMethodDefSigRetTypeIndex(
ms.msig);
// pass by rettype
m.GetTypeSpec(ref idx, c.ms.gtparams, c.ms.gmparams);
for (int i = 0; i < la_count; i++)
{
var mreg = la_phys_locs[i];
metadata.TypeSpec type = m.SystemObject;
if (i > 0 || !m.GetMethodDefSigHasNonExplicitThis(c.ms.msig))
{
type = m.GetTypeSpec(ref idx, c.ms.gtparams, c.ms.gmparams);
}
if (mreg.type == rt_stack)
{
la_phys_locs[i] = GetLALocation(mreg.stack_loc, util.util.align(c.la_sizes[i], GetPointerSize()), c);
c.la_locs[i] = la_phys_locs[i];
c.la_needs_assign[i] = false;
}
else if (mreg.type == rt_contents)
{
c.la_locs[i] = la_phys_locs[i];
c.la_needs_assign[i] = false;
}
else
{
c.la_needs_assign[i] = true;
var la_size = util.util.align(GetSize(type), GetPointerSize());
c.la_locs[i] = GetLVLocation(cur_loc, la_size, c);
la_locs[i] = cur_loc;
cur_loc += la_size;
}
}
if (has_hidden)
{
cur_loc += psize;
}
c.lv_total_size = cur_loc;
}
protected internal virtual int GetCTFromTypeForCC(metadata.TypeSpec t)
{
return(ir.Opcode.GetCTFromType(t));
}
public DwarfDIE GetTypeDie(metadata.TypeSpec ts, bool add_ns = true)
{
DwarfTypeDIE ret;
if (type_dies.TryGetValue(ts, out ret))
{
return(ret);
}
if (ts.SimpleType != 0)
{
DwarfDIE dret;
if (basetype_dies.TryGetValue(ts.SimpleType, out dret))
{
return(dret);
}
}
ret = new DwarfTypeDIE();
ret.ts = ts;
ret.t = t;
ret.dcu = this;
type_dies[ts] = ret;
if (add_ns)
{
// Generate namespace too
var ns = GetNSDie(ts.Namespace);
ns.Children.Add(ret);
}
// Ensure base classes etc are referenced
if (ts.GetExtends() != null)
{
GetTypeDie(ts.GetExtends());
}
switch (ts.stype)
{
case metadata.TypeSpec.SpecialType.Array:
case metadata.TypeSpec.SpecialType.SzArray:
case metadata.TypeSpec.SpecialType.MPtr:
case metadata.TypeSpec.SpecialType.Ptr:
if (ts.other != null)
{
GetTypeDie(ts.other);
}
break;
}
// Ensure field types are referenced
if (ts.SimpleType == 0x1c || // Object
ts.SimpleType == 0x0e || // String
(ts.SimpleType == 0 &&
ts.stype == metadata.TypeSpec.SpecialType.None &&
ts.m == m)) // Class/struct in current module
{
bool is_tls;
List <metadata.TypeSpec> fld_types = new List <metadata.TypeSpec>();
List <string> fnames = new List <string>();
List <int> foffsets = new List <int>();
layout.Layout.GetFieldOffset(ts, null, t, out is_tls,
false, fld_types, fnames, foffsets);
for (int i = 0; i < fld_types.Count; i++)
{
var ft = fld_types[i];
var fdie = new DwarfMemberDIE();
fdie.dcu = dcu;
fdie.Name = fnames[i];
fdie.FieldOffset = foffsets[i];
fdie.FieldType = GetTypeDie(ft);
fdie.t = t;
ret.Children.Add(fdie);
}
layout.Layout.GetFieldOffset(ts, null, t, out is_tls,
true, fld_types);
foreach (var ft in fld_types)
{
GetTypeDie(ft);
}
}
return(ret);
}
static void Main(string[] args)
{
if (args.Length != 4)
{
disp_usage();
return;
}
libtysila5.libtysila.AssemblyLoader al = new libtysila5.libtysila.AssemblyLoader(
new tysila4.FileSystemFileLoader());
tysila4.Program.search_dirs.Add(args[0]);
tysila4.Program.search_dirs.Add(new System.IO.FileInfo(args[2]).DirectoryName);
/* Load up all types in corefx files */
Dictionary <string, string> map = new Dictionary <string, string>();
var indir = new System.IO.DirectoryInfo(args[0]);
var files = indir.GetFiles(args[1]);
foreach (var fi in files)
{
var m = al.GetAssembly(fi.FullName);
for (int i = 1; i <= m.table_rows[metadata.MetadataStream.tid_TypeDef]; i++)
{
var flags = m.GetIntEntry(metadata.MetadataStream.tid_TypeDef, i, 0);
metadata.TypeSpec ts = new metadata.TypeSpec {
m = m, tdrow = i
};
if ((flags & 0x7) == 0x1 || (flags & 0x7) == 0x2)
{
// public
var nspace = ts.Namespace;
var name = ts.Name;
var fullname = nspace + "." + name;
map[fullname] = fi.Name;
}
}
}
/* Generate a mapping from type name/namespaces to the files they are contained in */
var infiledi = al.LoadAssembly(args[2]);
var infile = new metadata.PEFile().Parse(infiledi, al, false);
var o = new System.IO.StreamWriter(args[3]);
for (int i = 1; i <= infile.table_rows[metadata.MetadataStream.tid_TypeDef]; i++)
{
var flags = infile.GetIntEntry(metadata.MetadataStream.tid_TypeDef, i, 0);
metadata.TypeSpec ts = new metadata.TypeSpec {
m = infile, tdrow = i
};
if ((flags & 0x7) == 0x1 || (flags & 0x7) == 0x2)
{
// public
var nspace = ts.Namespace;
var name = ts.Name;
var fullname = nspace + "." + name;
if (map.ContainsKey(fullname))
{
o.WriteLine(infile.AssemblyName + "!" + fullname + "=" + map[fullname]);
}
}
}
for (int i = 1; i <= infile.table_rows[metadata.MetadataStream.tid_ExportedType]; i++)
{
var nspace = infile.GetStringEntry(metadata.MetadataStream.tid_ExportedType, i, 3);
var name = infile.GetStringEntry(metadata.MetadataStream.tid_ExportedType, i, 2);
var fullname = nspace + "." + name;
if (map.ContainsKey(fullname))
{
o.WriteLine(infile.AssemblyName + "!" + fullname + "=" + map[fullname]);
}
}
o.Close();
}
public virtual Reg AllocateValueType(Code c, metadata.TypeSpec ts, ref long alloced, ref int cur_stack)
{
return(AllocateStackLocation(c, GetSize(ts), ref cur_stack));
}
protected internal virtual Reg[] GetRegLocs(ir.Param csite,
ref int stack_loc,
Dictionary <int, int[]> cc,
Dictionary <int, int> cc_classmap,
string cc_name,
out int[] la_sizes,
out metadata.TypeSpec[] la_types,
metadata.TypeSpec has_hidden = null)
{
var m = csite.m;
var idx = (int)csite.v2;
metadata.TypeSpec[] gtparams = null;
metadata.TypeSpec[] gmparams = null;
if (csite.ms != null)
{
idx = csite.ms.msig;
m = csite.ms.m;
gtparams = csite.ms.gtparams;
gmparams = csite.ms.gmparams;
}
Dictionary <int, int> cc_next = new Dictionary <int, int>(
new GenericEqualityComparer <int>());
var act_pcount = m.GetMethodDefSigParamCount(idx);
var pcount = act_pcount;
bool has_this = m.GetMethodDefSigHasNonExplicitThis(idx);
idx = m.GetMethodDefSigRetTypeIndex(idx);
if (has_this)
{
pcount++;
}
if (has_hidden != null)
{
pcount++;
}
// Skip rettype
bool is_req;
uint token;
while (m.GetRetTypeCustomMod(ref idx, out is_req, out token))
{
;
}
m.GetTypeSpec(ref idx, gtparams, gmparams);
// Read types of parameters
Target.Reg[] ret = new Target.Reg[pcount];
la_sizes = new int[pcount];
la_types = new metadata.TypeSpec[pcount];
List <metadata.TypeSpec> la_locs = new List <metadata.TypeSpec>();
if (has_hidden != null)
{
la_locs.Add(has_hidden);
}
if (has_this)
{
// value type methods have mptr to type as their this pointer
if (csite.ms.type.IsValueType)
{
la_locs.Add(csite.ms.type.ManagedPointer);
}
else
{
la_locs.Add(csite.ms.type);
}
}
for (int i = 0; i < act_pcount; i++)
{
while (m.GetRetTypeCustomMod(ref idx, out is_req, out token))
{
;
}
la_locs.Add(m.GetTypeSpec(ref idx, gtparams, gmparams));
}
for (int i = 0; i < pcount; i++)
{
metadata.TypeSpec v = la_locs[i];
la_types[i] = v;
var size = GetSize(v);
la_sizes[i] = size;
var ct = GetCTFromTypeForCC(v); ir.Opcode.GetCTFromType(v);
if (cc_classmap.ContainsKey(ct))
{
ct = cc_classmap[ct];
}
else
{
ct = GetCCClassFromCT(ct, size, v, cc_name);
}
Reg r = null;
int cur_cc_next;
if (cc_next.TryGetValue(ct, out cur_cc_next) == false)
{
cur_cc_next = 0;
}
int[] cc_map;
if (cc.TryGetValue(ct, out cc_map))
{
if (cur_cc_next >= cc_map.Length)
{
cur_cc_next = cc_map.Length - 1;
}
var reg_id = cc_map[cur_cc_next];
if (regs[reg_id].type == rt_stack)
{
Reg rstack = new Reg()
{
type = rt_stack,
id = regs[reg_id].id,
size = size,
stack_loc = stack_loc,
name = regs[reg_id].name,
mask = regs[reg_id].mask
};
stack_loc += size;
var diff = stack_loc % size;
if (diff != 0)
{
stack_loc = stack_loc + size - diff;
}
r = rstack;
}
else
{
r = regs[reg_id];
}
}
else
{
r = GetRegLoc(csite, ref stack_loc,
cur_cc_next, ct, v, cc_name);
}
cc_next[ct] = cur_cc_next + 1;
ret[i] = r;
}
return(ret);
}
public virtual int GetCCClassFromCT(int ct, int size, metadata.TypeSpec ts, string cc)
{
return(ct);
}
static void Main(string[] args)
{
var argc = args.Length;
char c;
var go = new XGetoptCS.XGetopt();
var arg_str = "t:L:f:e:o:d:qDC:H:m:i";
string target = "x86";
string debug_file = null;
string output_file = null;
string epoint = null;
string cfile = null;
string hfile = null;
bool quiet = false;
bool require_metadata_version_match = true;
bool interactive = false;
string act_epoint = null;
Dictionary <string, object> opts = new Dictionary <string, object>();
while ((c = go.Getopt(argc, args, arg_str)) != '\0')
{
switch (c)
{
case 't':
target = go.Optarg;
break;
case 'L':
new_search_dirs.Add(go.Optarg);
break;
case 'd':
debug_file = go.Optarg;
break;
case 'o':
output_file = go.Optarg;
break;
case 'e':
epoint = go.Optarg;
break;
case 'q':
quiet = true;
break;
case 'D':
require_metadata_version_match = false;
break;
case 'C':
cfile = go.Optarg;
break;
case 'H':
hfile = go.Optarg;
break;
case 'f':
parse_f_option(go);
break;
case 'i':
interactive = true;
break;
case 'g':
do_dwarf = true;
break;
case 'm':
{
var opt = go.Optarg;
object optval = true;
if (opt.Contains("="))
{
var optvals = opt.Substring(opt.IndexOf("=") + 1);
opt = opt.Substring(0, opt.IndexOf("="));
int intval;
if (optvals.ToLower() == "false" || optvals.ToLower() == "off" || optvals.ToLower() == "no")
{
optval = false;
}
else if (optvals.ToLower() == "true" || optvals.ToLower() == "on" || optvals.ToLower() == "yes")
{
optval = true;
}
else if (int.TryParse(optvals, out intval))
{
optval = intval;
}
else
{
optval = optvals;
}
}
else if (opt.StartsWith("no-"))
{
opt = opt.Substring(3);
optval = false;
}
opts[opt] = optval;
}
break;
}
}
var fname = go.Optarg;
if (fname == String.Empty)
{
Console.WriteLine("No input file specified");
return;
}
// Insert library directories specified on the command line before the defaults
search_dirs.InsertRange(0, new_search_dirs);
if (cfile != null && hfile == null)
{
Console.WriteLine("-H must be used if -C is used");
return;
}
libtysila5.libtysila.AssemblyLoader al = new libtysila5.libtysila.AssemblyLoader(
new FileSystemFileLoader());
/* Load up type forwarders */
foreach (var libdir in search_dirs)
{
try
{
var di = new DirectoryInfo(libdir);
if (di.Exists)
{
foreach (var tfw_file in di.GetFiles("*.tfw"))
{
var tfr = new StreamReader(tfw_file.OpenRead());
while (!tfr.EndOfStream)
{
var tfr_line = tfr.ReadLine();
var tfr_lsplit = tfr_line.Split('=');
al.TypeForwarders[tfr_lsplit[0]] = tfr_lsplit[1];
}
tfr.Close();
}
}
}
catch (Exception) { }
}
//search_dirs.Add(@"..\mono\corlib");
al.RequireVersionMatch = require_metadata_version_match;
// add containing directory of input to search dirs
var ifi = new FileInfo(fname);
search_dirs.Add(ifi.DirectoryName);
var m = al.GetAssembly(fname);
if (m == null)
{
Console.WriteLine("Input file " + fname + " not found");
throw new Exception(fname + " not found");
}
t = libtysila5.target.Target.targets[target];
// try and set target options
foreach (var kvp in opts)
{
if (!t.Options.TrySet(kvp.Key, kvp.Value))
{
Console.WriteLine("Unable to set target option " + kvp.Key + " to " + kvp.Value.ToString());
return;
}
}
if (interactive)
{
if (new Interactive(m, t).DoInteractive() == false)
{
return;
}
}
libtysila5.dwarf.DwarfCU dwarf = null;
if (do_dwarf)
{
dwarf = new libtysila5.dwarf.DwarfCU(t, m);
}
libtysila5.TysilaState s = new libtysila5.TysilaState();
if (output_file != null)
{
var bf = new binary_library.elf.ElfFile(binary_library.Bitness.Bits32);
s.bf = bf;
bf.Init();
bf.Architecture = target;
var st = new libtysila5.StringTable(
m.GetStringEntry(metadata.MetadataStream.tid_Module,
1, 1), al, t);
s.st = st;
s.r = new libtysila5.CachingRequestor(m);
t.InitIntcalls();
/* for now, just assemble all public and protected
* non-generic methods in public types, plus the
* entry point */
StringBuilder debug = new StringBuilder();
for (int i = 1; i <= m.table_rows[metadata.MetadataStream.tid_MethodDef]; i++)
{
metadata.MethodSpec ms = new metadata.MethodSpec
{
m = m,
mdrow = i,
msig = 0
};
ms.type = new metadata.TypeSpec
{
m = m,
tdrow = m.methoddef_owners[ms.mdrow]
};
var mflags = m.GetIntEntry(metadata.MetadataStream.tid_MethodDef,
i, 2);
var tflags = m.GetIntEntry(metadata.MetadataStream.tid_TypeDef,
ms.type.tdrow, 0);
mflags &= 0x7;
tflags &= 0x7;
ms.msig = (int)m.GetIntEntry(metadata.MetadataStream.tid_MethodDef,
i, 4);
/* See if this is the entry point */
int tid, row;
m.InterpretToken(m.entry_point_token, out tid, out row);
if (tid == metadata.MetadataStream.tid_MethodDef)
{
if (row == i)
{
if (epoint != null)
{
ms.aliases = new List <string> {
epoint
}
}
;
mflags = 6;
tflags = 1;
ms.AlwaysCompile = true;
act_epoint = ms.MangleMethod();
}
}
/* See if we have an always compile attribute */
if (ms.HasCustomAttribute("_ZN14libsupcs#2Edll8libsupcs22AlwaysCompileAttribute_7#2Ector_Rv_P1u1t") ||
ms.type.HasCustomAttribute("_ZN14libsupcs#2Edll8libsupcs22AlwaysCompileAttribute_7#2Ector_Rv_P1u1t"))
{
mflags = 6;
tflags = 1;
ms.AlwaysCompile = true;
}
if (ms.type.IsGenericTemplate == false &&
ms.IsGenericTemplate == false &&
(mflags == 0x4 || mflags == 0x5 || mflags == 0x6) &&
tflags != 0)
{
s.r.MethodRequestor.Request(ms);
}
}
/* Also assemble all public non-generic type infos */
for (int i = 1; i <= m.table_rows[metadata.MetadataStream.tid_TypeDef]; i++)
{
var flags = (int)m.GetIntEntry(metadata.MetadataStream.tid_TypeDef,
i, 0);
if (((flags & 0x7) != 0x1) &&
((flags & 0x7) != 0x2))
{
continue;
}
var ts = new metadata.TypeSpec {
m = m, tdrow = i
};
if (ts.IsGeneric)
{
continue;
}
s.r.StaticFieldRequestor.Request(ts);
s.r.VTableRequestor.Request(ts.Box);
}
/* If corlib, add in the default equality comparers so we don't have to jit these
* commonly used classes */
if (m.is_corlib)
{
s.r.MethodRequestor.Request(m.GetMethodSpec(m.GetTypeSpec("System.Collections.Generic", "GenericEqualityComparer`1", new metadata.TypeSpec[] { m.SystemByte }), ".ctor"));
s.r.MethodRequestor.Request(m.GetMethodSpec(m.GetTypeSpec("System.Collections.Generic", "GenericEqualityComparer`1", new metadata.TypeSpec[] { m.SystemInt8 }), ".ctor"));
s.r.MethodRequestor.Request(m.GetMethodSpec(m.GetTypeSpec("System.Collections.Generic", "GenericEqualityComparer`1", new metadata.TypeSpec[] { m.SystemInt16 }), ".ctor"));
s.r.MethodRequestor.Request(m.GetMethodSpec(m.GetTypeSpec("System.Collections.Generic", "GenericEqualityComparer`1", new metadata.TypeSpec[] { m.SystemUInt16 }), ".ctor"));
s.r.MethodRequestor.Request(m.GetMethodSpec(m.GetTypeSpec("System.Collections.Generic", "GenericEqualityComparer`1", new metadata.TypeSpec[] { m.SystemInt32 }), ".ctor"));
s.r.MethodRequestor.Request(m.GetMethodSpec(m.GetTypeSpec("System.Collections.Generic", "GenericEqualityComparer`1", new metadata.TypeSpec[] { m.SystemUInt32 }), ".ctor"));
s.r.MethodRequestor.Request(m.GetMethodSpec(m.GetTypeSpec("System.Collections.Generic", "GenericEqualityComparer`1", new metadata.TypeSpec[] { m.SystemInt64 }), ".ctor"));
s.r.MethodRequestor.Request(m.GetMethodSpec(m.GetTypeSpec("System.Collections.Generic", "GenericEqualityComparer`1", new metadata.TypeSpec[] { m.SystemUInt64 }), ".ctor"));
s.r.MethodRequestor.Request(m.GetMethodSpec(m.GetTypeSpec("System.Collections.Generic", "GenericEqualityComparer`1", new metadata.TypeSpec[] { m.SystemString }), ".ctor"));
s.r.MethodRequestor.Request(m.GetMethodSpec(m.GetTypeSpec("System.Collections.Generic", "GenericEqualityComparer`1", new metadata.TypeSpec[] { m.SystemObject }), ".ctor"));
s.r.VTableRequestor.Request(m.GetTypeSpec("System.Collections.Generic", "GenericEqualityComparer`1", new metadata.TypeSpec[] { m.SystemByte }));
s.r.VTableRequestor.Request(m.GetTypeSpec("System.Collections.Generic", "GenericEqualityComparer`1", new metadata.TypeSpec[] { m.SystemInt8 }));
s.r.VTableRequestor.Request(m.GetTypeSpec("System.Collections.Generic", "GenericEqualityComparer`1", new metadata.TypeSpec[] { m.SystemInt16 }));
s.r.VTableRequestor.Request(m.GetTypeSpec("System.Collections.Generic", "GenericEqualityComparer`1", new metadata.TypeSpec[] { m.SystemUInt16 }));
s.r.VTableRequestor.Request(m.GetTypeSpec("System.Collections.Generic", "GenericEqualityComparer`1", new metadata.TypeSpec[] { m.SystemInt32 }));
s.r.VTableRequestor.Request(m.GetTypeSpec("System.Collections.Generic", "GenericEqualityComparer`1", new metadata.TypeSpec[] { m.SystemUInt32 }));
s.r.VTableRequestor.Request(m.GetTypeSpec("System.Collections.Generic", "GenericEqualityComparer`1", new metadata.TypeSpec[] { m.SystemInt64 }));
s.r.VTableRequestor.Request(m.GetTypeSpec("System.Collections.Generic", "GenericEqualityComparer`1", new metadata.TypeSpec[] { m.SystemUInt64 }));
s.r.VTableRequestor.Request(m.GetTypeSpec("System.Collections.Generic", "GenericEqualityComparer`1", new metadata.TypeSpec[] { m.SystemString }));
s.r.VTableRequestor.Request(m.GetTypeSpec("System.Collections.Generic", "GenericEqualityComparer`1", new metadata.TypeSpec[] { m.SystemObject }));
}
/* Generate a thread-local data section. We may not use it. */
var tlsos = bf.CreateContentsSection();
tlsos.Name = ".tdata";
tlsos.IsAlloc = true;
tlsos.IsExecutable = false;
tlsos.IsWriteable = true;
tlsos.IsThreadLocal = true;
while (!s.r.Empty)
{
if (!s.r.MethodRequestor.Empty)
{
var ms = s.r.MethodRequestor.GetNext();
ISection tsect = null;
ISection datasect = null;
if (func_sects && !ms.ms.AlwaysCompile)
{
tsect = get_decorated_section(bf, bf.GetTextSection(), "." + ms.ms.MangleMethod());
datasect = get_decorated_section(bf, bf.GetDataSection(), "." + ms.ms.MangleMethod() + "_SignatureTable");
}
else if (class_sects && !ms.ms.AlwaysCompile)
{
tsect = get_decorated_section(bf, bf.GetTextSection(), "." + ms.ms.type.MangleType());
datasect = get_decorated_section(bf, bf.GetDataSection(), "." + ms.ms.type.MangleType() + "_SignatureTable");
}
libtysila5.libtysila.AssembleMethod(ms.ms,
bf, t, s, debug, m, ms.c, tsect, datasect, dwarf);
if (!quiet)
{
Console.WriteLine(ms.ms.m.MangleMethod(ms.ms));
}
}
else if (!s.r.StaticFieldRequestor.Empty)
{
var sf = s.r.StaticFieldRequestor.GetNext();
ISection tsect = null;
if (data_sects && !sf.AlwaysCompile)
{
tsect = get_decorated_section(bf, bf.GetDataSection(), "." + sf.MangleType() + "S");
}
else if (class_sects && !sf.AlwaysCompile)
{
tsect = get_decorated_section(bf, bf.GetDataSection(), "." + sf.MangleType() + "S");
}
libtysila5.layout.Layout.OutputStaticFields(sf,
t, bf, m, tsect, tlsos);
if (!quiet)
{
Console.WriteLine(sf.MangleType() + "S");
}
}
else if (!s.r.EHRequestor.Empty)
{
var eh = s.r.EHRequestor.GetNext();
ISection tsect = null;
if (func_sects && !eh.ms.AlwaysCompile)
{
tsect = get_decorated_section(bf, bf.GetRDataSection(), "." + eh.ms.MangleMethod() + "EH");
}
else if (class_sects && !eh.ms.AlwaysCompile)
{
tsect = get_decorated_section(bf, bf.GetRDataSection(), "." + eh.ms.type.MangleType() + "EH");
}
libtysila5.layout.Layout.OutputEHdr(eh,
t, bf, s, m, tsect);
if (!quiet)
{
Console.WriteLine(eh.ms.MangleMethod() + "EH");
}
}
else if (!s.r.VTableRequestor.Empty)
{
var vt = s.r.VTableRequestor.GetNext();
ISection tsect = null;
ISection data_sect = null;
if (data_sects && !vt.AlwaysCompile)
{
tsect = get_decorated_section(bf, bf.GetRDataSection(), "." + vt.MangleType());
data_sect = get_decorated_section(bf, bf.GetDataSection(), "." + vt.MangleType() + "_SignatureTable");
}
else if (class_sects && !vt.AlwaysCompile)
{
tsect = get_decorated_section(bf, bf.GetTextSection(), "." + vt.MangleType());
data_sect = get_decorated_section(bf, bf.GetDataSection(), "." + vt.MangleType() + "_SignatureTable");
}
libtysila5.layout.Layout.OutputVTable(vt,
t, bf, s, m, tsect, data_sect);
if (!quiet)
{
Console.WriteLine(vt.MangleType());
}
}
else if (!s.r.DelegateRequestor.Empty)
{
var d = s.r.DelegateRequestor.GetNext();
libtysila5.ir.ConvertToIR.CreateDelegate(d, t, s);
if (!quiet)
{
Console.WriteLine(d.MangleType() + "D");
}
}
else if (!s.r.BoxedMethodRequestor.Empty)
{
var bm = s.r.BoxedMethodRequestor.GetNext();
ISection tsect = null;
if (func_sects && !bm.ms.AlwaysCompile)
{
tsect = get_decorated_section(bf, bf.GetTextSection(), "." + bm.ms.MangleMethod());
}
else if (class_sects && !bm.ms.AlwaysCompile)
{
tsect = get_decorated_section(bf, bf.GetTextSection(), "." + bm.ms.type.MangleType());
}
libtysila5.libtysila.AssembleBoxedMethod(bm.ms,
bf, t, s, debug, tsect);
if (!quiet)
{
Console.WriteLine(bm.ms.MangleMethod());
}
}
}
if (debug_file != null)
{
string d = debug.ToString();
StreamWriter sw = new StreamWriter(debug_file);
sw.Write(d);
sw.Close();
}
if (tlsos.Length > 0)
{
bf.AddSection(tlsos);
}
/* String table */
st.WriteToOutput(bf, m, t);
/* Include original metadata */
var rdata = bf.GetRDataSection();
rdata.Align(t.GetPointerSize());
var mdsym = bf.CreateSymbol();
mdsym.Name = m.AssemblyName;
mdsym.ObjectType = binary_library.SymbolObjectType.Object;
mdsym.Offset = (ulong)rdata.Data.Count;
mdsym.Type = binary_library.SymbolType.Global;
var len = m.file.GetLength();
mdsym.Size = len;
rdata.AddSymbol(mdsym);
for (int i = 0; i < len; i++)
{
rdata.Data.Add(m.file.ReadByte(i));
}
var mdsymend = bf.CreateSymbol();
mdsymend.Name = m.AssemblyName + "_end";
mdsymend.ObjectType = binary_library.SymbolObjectType.Object;
mdsymend.Offset = (ulong)rdata.Data.Count;
mdsymend.Type = binary_library.SymbolType.Global;
mdsymend.Size = 0;
rdata.AddSymbol(mdsymend);
/* Add resource symbol if present */
if (m.GetPEFile().ResourcesSize != 0)
{
var rsym = bf.CreateSymbol();
rsym.Name = m.AssemblyName + "_resources";
rsym.ObjectType = SymbolObjectType.Object;
rsym.Offset = (ulong)m.GetPEFile().ResourcesOffset + mdsym.Offset;
rsym.Type = SymbolType.Global;
rsym.Size = m.GetPEFile().ResourcesSize;
rdata.AddSymbol(rsym);
}
/* Add comment */
var csect = bf.CreateContentsSection();
csect.IsAlloc = false;
csect.IsExecutable = false;
csect.IsWriteable = false;
csect.Name = ".comment";
var cbytes = Encoding.ASCII.GetBytes(comment);
foreach (var cbyte in cbytes)
{
csect.Data.Add(cbyte);
}
csect.Data.Add(0);
if (act_epoint != null)
{
var epbytes = Encoding.ASCII.GetBytes("entry: " +
act_epoint);
foreach (var epbyte in epbytes)
{
csect.Data.Add(epbyte);
}
csect.Data.Add(0);
}
bf.AddSection(csect);
/* Add debugger sections */
if (dwarf != null)
{
var dwarf_sects = new libtysila5.dwarf.DwarfSections(bf);
dwarf.WriteToOutput(dwarf_sects);
}
/* Write output file */
bf.Filename = output_file;
bf.Write();
}
if (hfile != null)
{
COutput.WriteHeader(m, t, hfile, cfile);
}
}
public static extern void *JitCompile(metadata.TypeSpec ts);
public virtual string GetCType(metadata.TypeSpec ts, out int bytesize)
{
switch (ts.stype)
{
case metadata.TypeSpec.SpecialType.None:
switch (ts.SimpleType)
{
case 0x02:
case 0x08:
bytesize = 4;
return("int32_t");
case 0x03:
case 0x06:
bytesize = 2;
return("int16_t");
case 0x04:
bytesize = 1;
return("int8_t");
case 0x05:
bytesize = 1;
return("uint8_t");
case 0x07:
bytesize = 2;
return("uint16_t");
case 0x09:
bytesize = 4;
return("uint32_t");
case 0x0a:
bytesize = 8;
return("int64_t");
case 0x0b:
bytesize = 8;
return("uint64_t");
case 0x0c:
bytesize = 4;
return("float");
case 0x0d:
bytesize = 8;
return("double");
case 0x18:
bytesize = GetPointerSize();
return("INTPTR");
case 0x19:
bytesize = GetPointerSize();
return("UINTPTR");
}
break;
}
bytesize = GetPointerSize();
return("INTPTR");
}
public virtual string GetCType(metadata.TypeSpec ts)
{
int b;
return(GetCType(ts, out b));
}
protected internal virtual void AddExtraVTableFields(metadata.TypeSpec ts, IList <byte> d, ref ulong offset)
{
}
