mirror of
https://github.com/danbulant/Cosmos
synced 2026-05-21 13:28:41 +00:00
304 lines
13 KiB
C#
304 lines
13 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Reflection;
|
|
using System.IO;
|
|
|
|
namespace Indy.IL2CPU.Assembler {
|
|
public class DataMember: BaseAssemblerElement, IComparable<DataMember> {
|
|
public const string IllegalIdentifierChars = "&.,+$<>{}-`\'/\\ ()[]*!=";
|
|
public static string GetStaticFieldName(FieldInfo aField) {
|
|
return FilterStringForIncorrectChars("static_field__" + MethodInfoLabelGenerator.GetFullName(aField.DeclaringType) + "." + aField.Name);
|
|
}
|
|
|
|
public static string FilterStringForIncorrectChars(string aName) {
|
|
string xTempResult = aName;
|
|
foreach (char c in IllegalIdentifierChars) {
|
|
xTempResult = xTempResult.Replace(c, '_');
|
|
}
|
|
return String.Intern(xTempResult);
|
|
}
|
|
|
|
public DataMember(string aName, Stream aData) {
|
|
Name = aName;
|
|
RawDefaultValue = new byte[aData.Length];
|
|
aData.Read(RawDefaultValue,
|
|
0,
|
|
RawDefaultValue.Length);
|
|
}
|
|
|
|
public byte[] RawDefaultValue {
|
|
get;
|
|
set;
|
|
}
|
|
public uint Alignment {
|
|
get;
|
|
set;
|
|
}
|
|
|
|
private object[] UntypedDefaultValue;
|
|
|
|
public DataMember(string aName, params object[] aDefaultValue) {
|
|
Name = aName;
|
|
UntypedDefaultValue = aDefaultValue;
|
|
}
|
|
|
|
public DataMember(string aName, byte[] aDefaultValue) {
|
|
Name = aName;
|
|
RawDefaultValue = aDefaultValue;
|
|
//UntypedDefaultValue = aDefaultValue;
|
|
}
|
|
|
|
public DataMember(string aName, short[] aDefaultValue) {
|
|
Name = aName;
|
|
RawDefaultValue = new byte[aDefaultValue.Length * 2];
|
|
for (int i = 0; i < aDefaultValue.Length; i++) {
|
|
Array.Copy(BitConverter.GetBytes(aDefaultValue[i]), 0,
|
|
RawDefaultValue, i * 2, 2);
|
|
}
|
|
//UntypedDefaultValue = aDefaultValue;
|
|
}
|
|
|
|
public DataMember(string aName, params ushort[] aDefaultValue) {
|
|
Name = aName;
|
|
RawDefaultValue = new byte[aDefaultValue.Length * 2];
|
|
for (int i = 0; i < aDefaultValue.Length; i++) {
|
|
Array.Copy(BitConverter.GetBytes(aDefaultValue[i]), 0,
|
|
RawDefaultValue, i * 2, 2);
|
|
}
|
|
//UntypedDefaultValue = aDefaultValue;
|
|
}
|
|
|
|
public DataMember(string aName, params uint[] aDefaultValue) {
|
|
Name = aName;
|
|
//RawDefaultValue = new byte[aDefaultValue.Length * 4];
|
|
//for (int i = 0; i < aDefaultValue.Length; i++) {
|
|
// Array.Copy(BitConverter.GetBytes(aDefaultValue[i]), 0,
|
|
// RawDefaultValue, i * 4, 4);
|
|
//}
|
|
UntypedDefaultValue = aDefaultValue.Cast<object>().ToArray();
|
|
}
|
|
|
|
public DataMember(string aName, params int[] aDefaultValue) {
|
|
Name = aName;
|
|
|
|
if(Name.Equals("System__DOT__Object__mscorlib__Version_2__DOT__0__DOT__0__DOT__0__Culture_neutral__PublicKeyToken_b77a5c561934e089__TYPE_ID", StringComparison.InvariantCultureIgnoreCase))
|
|
{
|
|
Console.Write("");
|
|
}
|
|
//RawDefaultValue = new byte[aDefaultValue.Length * 4];
|
|
//for (int i = 0; i < aDefaultValue.Length; i++) {
|
|
// Array.Copy(BitConverter.GetBytes(aDefaultValue[i]), 0,
|
|
// RawDefaultValue, i * 4, 4);
|
|
//}
|
|
UntypedDefaultValue = aDefaultValue.Cast<object>().ToArray();
|
|
}
|
|
|
|
public string Name {
|
|
get;
|
|
private set;
|
|
}
|
|
|
|
public override void WriteText(Assembler aAssembler, TextWriter aOutput)
|
|
{
|
|
if (RawDefaultValue != null)
|
|
{
|
|
if (RawDefaultValue.Length == 0)
|
|
{
|
|
aOutput.Write(Name);
|
|
aOutput.Write(":");
|
|
return;
|
|
}
|
|
if ((from item in RawDefaultValue
|
|
group item by item
|
|
into i
|
|
select i).Count() > 1 || RawDefaultValue.Length < 250)
|
|
{
|
|
if (IsGlobal)
|
|
{
|
|
aOutput.Write("global ");
|
|
aOutput.WriteLine(Name);
|
|
}
|
|
aOutput.Write(Name);
|
|
aOutput.Write(" db ");
|
|
for (int i = 0; i < (RawDefaultValue.Length - 1); i++)
|
|
{
|
|
aOutput.Write(RawDefaultValue[i]);
|
|
aOutput.Write(", ");
|
|
}
|
|
aOutput.Write(RawDefaultValue.Last());
|
|
}
|
|
else
|
|
{
|
|
//aOutputWriter.WriteLine("TIMES 0x50000 db 0");
|
|
aOutput.Write("global ");
|
|
aOutput.WriteLine(Name);
|
|
aOutput.Write(Name);
|
|
aOutput.Write(": TIMES ");
|
|
aOutput.Write(RawDefaultValue.Length);
|
|
aOutput.Write(" db ");
|
|
aOutput.Write(RawDefaultValue[0]);
|
|
}
|
|
return;
|
|
}
|
|
if (UntypedDefaultValue != null)
|
|
{
|
|
StringBuilder xSB = new StringBuilder();
|
|
if (IsGlobal)
|
|
{
|
|
aOutput.Write("global ");
|
|
aOutput.WriteLine(Name);
|
|
}
|
|
aOutput.Write(Name);
|
|
aOutput.Write(" dd ");
|
|
Func<object, string> xGetTextForItem = delegate(object aItem)
|
|
{
|
|
var xElementRef = aItem as ElementReference;
|
|
if (xElementRef == null)
|
|
{
|
|
return (aItem ?? 0).ToString();
|
|
}
|
|
else
|
|
{
|
|
if (xElementRef.Offset == 0)
|
|
{
|
|
return xElementRef.Name;
|
|
}
|
|
return xElementRef.Name + " + " + xElementRef.Offset;
|
|
}
|
|
};
|
|
for (int i = 0; i < (UntypedDefaultValue.Length - 1); i++)
|
|
{
|
|
aOutput.Write(xGetTextForItem(UntypedDefaultValue[i]));
|
|
aOutput.Write(", ");
|
|
}
|
|
aOutput.Write(xGetTextForItem(UntypedDefaultValue.Last()));
|
|
return;
|
|
}
|
|
throw new Exception("Situation unsupported!");
|
|
}
|
|
|
|
public int CompareTo(DataMember other) {
|
|
return String.Compare(Name, other.Name);
|
|
}
|
|
|
|
public bool IsGlobal {
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public override ulong? ActualAddress {
|
|
get {
|
|
// TODO: for now, we dont have any data alignment
|
|
return StartAddress;
|
|
}
|
|
}
|
|
|
|
public override void UpdateAddress(Assembler aAssembler, ref ulong xAddress) {
|
|
if (Alignment > 0) {
|
|
if (xAddress % Alignment != 0) {
|
|
xAddress += Alignment - (xAddress % Alignment);
|
|
}
|
|
}
|
|
base.UpdateAddress(aAssembler, ref xAddress);
|
|
if (RawDefaultValue != null) {
|
|
xAddress += (ulong)RawDefaultValue.LongLength;
|
|
}
|
|
if (UntypedDefaultValue != null) {
|
|
// TODO: what to do with 64bit target platforms? right now we only support 32bit
|
|
xAddress += (ulong)(UntypedDefaultValue.LongLength * 4);
|
|
}
|
|
}
|
|
|
|
public override bool IsComplete(Assembler aAssembler) {
|
|
if (UntypedDefaultValue != null &&
|
|
UntypedDefaultValue.LongLength>0) {
|
|
foreach (var xReference in (from item in UntypedDefaultValue
|
|
let xRef = item as ElementReference
|
|
where xRef != null
|
|
select xRef)) {
|
|
var xRef = aAssembler.TryResolveReference(xReference);
|
|
if (xRef == null) {
|
|
return false;
|
|
} else if (!xRef.IsComplete(aAssembler)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public override byte[] GetData(Assembler aAssembler) {
|
|
if (UntypedDefaultValue != null &&
|
|
UntypedDefaultValue.LongLength > 0) {
|
|
var xBuff = (byte[])Array.CreateInstance(typeof(byte), UntypedDefaultValue.LongLength * 4);
|
|
for (int i = 0; i < UntypedDefaultValue.Length; i++) {
|
|
var xRef = UntypedDefaultValue[i] as ElementReference;
|
|
byte[] xTemp;
|
|
if (xRef != null) {
|
|
var xTheRef = aAssembler.TryResolveReference(xRef);
|
|
if (xTheRef == null) {
|
|
throw new Exception("Reference not found!");
|
|
}
|
|
if (!xTheRef.ActualAddress.HasValue) {
|
|
Console.Write("");
|
|
}
|
|
xTemp = BitConverter.GetBytes(xTheRef.ActualAddress.Value);
|
|
} else {
|
|
if (UntypedDefaultValue[i] is int) {
|
|
xTemp = BitConverter.GetBytes((int)UntypedDefaultValue[i]);
|
|
} else {
|
|
if (UntypedDefaultValue[i] is uint) {
|
|
xTemp = BitConverter.GetBytes((uint)UntypedDefaultValue[i]);
|
|
} else {
|
|
throw new Exception("Invalid value inside UntypedDefaultValue");
|
|
}
|
|
}
|
|
}
|
|
Array.Copy(xTemp, 0, xBuff, i * 4, 4);
|
|
}
|
|
return xBuff;
|
|
}
|
|
return RawDefaultValue;
|
|
}
|
|
|
|
public override void WriteData(Assembler aAssembler, Stream aOutput) {
|
|
if (UntypedDefaultValue != null &&
|
|
UntypedDefaultValue.LongLength > 0) {
|
|
//var xBuff = (byte[])Array.CreateInstance(typeof(byte), UntypedDefaultValue.LongLength * 4);
|
|
for (int i = 0; i < UntypedDefaultValue.Length; i++) {
|
|
var xRef = UntypedDefaultValue[i] as ElementReference;
|
|
//byte[] xTemp;
|
|
if (xRef != null) {
|
|
var xTheRef = aAssembler.TryResolveReference(xRef);
|
|
if (xTheRef == null) {
|
|
throw new Exception("Reference not found!");
|
|
}
|
|
if (!xTheRef.ActualAddress.HasValue) {
|
|
Console.Write("");
|
|
}
|
|
aOutput.Write(BitConverter.GetBytes(xTheRef.ActualAddress.Value), 0, 4);
|
|
//xTemp = BitConverter.GetBytes();
|
|
} else {
|
|
if (UntypedDefaultValue[i] is int) {
|
|
aOutput.Write(BitConverter.GetBytes((int)UntypedDefaultValue[i]), 0, 4);
|
|
//xTemp = BitConverter.GetBytes((int)UntypedDefaultValue[i]);
|
|
} else {
|
|
if (UntypedDefaultValue[i] is uint) {
|
|
aOutput.Write(BitConverter.GetBytes((uint)UntypedDefaultValue[i]), 0, 4);
|
|
|
|
//xTemp = BitConverter.GetBytes((uint)UntypedDefaultValue[i]);
|
|
} else {
|
|
throw new Exception("Invalid value inside UntypedDefaultValue");
|
|
}
|
|
}
|
|
}
|
|
//Array.Copy(xTemp, 0, xBuff, i * 4, 4);
|
|
}
|
|
} else {
|
|
aOutput.Write(RawDefaultValue, 0, RawDefaultValue.Length);
|
|
}
|
|
}
|
|
}
|
|
}
|