public LinkerSection(SectionKind sectionKind, uint alignment)
{
SectionKind = sectionKind;
IsResolved = false;
SectionAlignment = alignment;
Size = 0;
}
internal LinkerSymbol(string name, SectionKind kind, uint alignment)
{
Name = name;
Alignment = alignment;
SectionKind = kind;
LinkRequests = new List<LinkRequest>();
}
internal LinkerSymbol(string name, SectionKind kind, uint alignment)
{
Name = name;
Alignment = alignment;
SectionKind = kind;
LinkRequests = new List <LinkRequest>();
}
public LinkerSymbol DefineSymbol(string name, SectionKind kind, int alignment, int size)
{
uint aligned = alignment != 0 ? (uint)alignment : 1;
lock (_lock)
{
if (!symbolLookup.TryGetValue(name, out LinkerSymbol symbol))
{
symbol = new LinkerSymbol(name, aligned, kind);
Symbols.Add(symbol);
symbolLookup.Add(name, symbol);
symbol.IsExternalSymbol = false;
}
symbol.Alignment = aligned;
symbol.SectionKind = kind;
symbol.Stream = (size == 0) ? new MemoryStream() : new MemoryStream(size);
if (size != 0)
{
symbol.Stream.SetLength(size);
}
return(symbol);
}
}
private uint ResolveSymbolLocation(SectionKind section, ulong VirtualAddress)
{
uint position = 0;
foreach (var symbol in Symbols)
{
if (symbol.IsReplaced)
{
continue;
}
if (symbol.SectionKind != section)
{
continue;
}
if (symbol.IsResolved)
{
continue;
}
symbol.SectionOffset = position;
symbol.VirtualAddress = VirtualAddress + position;
position += symbol.Size;
}
return(position);
}
/// <summary>
/// Allocates a symbol of the given name in the specified section.
/// </summary>
/// <param name="name">The name of the symbol.</param>
/// <param name="section">The executable section to allocate From.</param>
/// <param name="size">The number of bytes to allocate. If zero, indicates an unknown amount of memory is required.</param>
/// <param name="alignment">The alignment. A value of zero indicates the use of a default alignment for the section.</param>
/// <returns>
/// A stream, which can be used to populate the section.
/// </returns>
public virtual Stream Allocate(string name, SectionKind section, int size, int alignment)
{
try
{
Stream baseStream = Allocate(section, size, alignment);
// Create a linker symbol for the name
LinkerSymbol symbol = new LinkerSymbol(name, section, baseStream.Position);
// Save the symbol for later use
if (!symbols.ContainsKey(symbol.Name))
{
symbols.Add(symbol.Name, symbol);
}
// Wrap the stream to catch premature disposal
Stream result = new LinkerStream(symbol, baseStream, size);
return(result);
}
catch (ArgumentException argx)
{
throw new LinkerException(String.Format(@"Symbol {0} defined multiple times.", name), argx);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Elf32Section"/> class.
/// </summary>
/// <param name="kind">The kind of the section.</param>
/// <param name="name">The name.</param>
/// <param name="virtualAddress">The virtualAddress.</param>
public Elf32Section(SectionKind kind, string name, IntPtr virtualAddress)
: base(kind, name, virtualAddress)
{
_header = new Elf32SectionHeader();
_header.Name = Elf32StringTableSection.AddString(name);
_sectionStream = new System.IO.MemoryStream();
}
/// <summary>
/// Initializes a new instance of the <see cref="Elf32Section"/> class.
/// </summary>
/// <param name="kind">The kind of the section.</param>
/// <param name="name">The name.</param>
/// <param name="virtualAddress">The virtualAddress.</param>
public Elf32Section(SectionKind kind, string name, IntPtr virtualAddress)
: base(kind, name, virtualAddress)
{
_header = new Elf32SectionHeader();
_header.Name = Elf32StringTableSection.AddString(name);
_sectionStream = new System.IO.MemoryStream();
}
/// <summary>
/// Initializes a new instance of the <see cref="Section"/> class.
/// </summary>
/// <param name="kind">The kind of the section.</param>
/// <param name="name">The name.</param>
/// <param name="virtualAddress">The virtualAddress.</param>
public Section(SectionKind kind, string name, IntPtr virtualAddress)
: base(kind, name, virtualAddress)
{
header = new SectionHeader();
header.Name = StringTableSection.AddString(name);
stream = new MemoryStream();
}
public void Link(LinkType linkType, PatchType patchType, string patchSymbol, SectionKind patchKind, int patchOffset, int relativeBase, string referenceSymbol, SectionKind referenceKind, int referenceOffset)
{
var referenceObject = GetSymbol(referenceSymbol, referenceKind);
var patchObject = GetSymbol(patchSymbol, patchKind);
Link(linkType, patchType, patchObject, patchOffset, relativeBase, referenceObject, referenceOffset);
}
/// <summary>
/// Allocates memory in the specified section.
/// </summary>
/// <param name="member">The metadata member to allocate space for.</param>
/// <param name="section">The executable section to allocate From.</param>
/// <param name="size">The number of bytes to allocate. If zero, indicates an unknown amount of memory is required.</param>
/// <param name="alignment">The alignment. A value of zero indicates the use of a default alignment for the section.</param>
/// <returns>A stream, which can be used to populate the section.</returns>
public virtual Stream Allocate(RuntimeMember member, SectionKind section, int size, int alignment)
{
// Create a canonical symbol name
string name = CreateSymbolName(member);
// Create a stream
return(Allocate(name, section, size, alignment));
}
internal LinkerSymbol(string name, uint alignment = 0, SectionKind kind = SectionKind.Unknown)
{
Name = name;
Alignment = alignment;
SectionKind = kind;
LinkRequests = new List <LinkRequest>();
IsExport = false;
}
public LinkerSymbol FindSymbol(string name, SectionKind kind)
{
var section = LinkerSections[(int)kind];
Debug.Assert(section != null);
return(section.GetSymbol(name));
}
public void Read(BinaryReader reader)
{
blobIndex = reader.ReadInt32();
bankNameIndex = reader.ReadInt32();
startAddress = reader.ReadInt64();
kind = (SectionKind)reader.ReadInt16();
customSectionNameIndex = reader.ReadInt32();
accessMode = (SectionAccessMode)reader.ReadInt16();
}
public LinkerSection(SectionKind sectionKind, uint alignment)
{
SectionKind = sectionKind;
IsResolved = false;
symbolLookup = new Dictionary<string, LinkerSymbol>();
Symbols = new List<LinkerSymbol>();
SectionAlignment = alignment;
Size = 0;
}
public LinkerSection(SectionKind sectionKind, uint alignment)
{
SectionKind = sectionKind;
IsResolved = false;
symbolLookup = new Dictionary <string, LinkerSymbol>();
Symbols = new List <LinkerSymbol>();
SectionAlignment = alignment;
Size = 0;
}
void ConfigureDataSource()
{
dataSource = new UICollectionViewDiffableDataSource <NSNumber, NSNumber> (collectionView, CellProviderHandler)
{
SupplementaryViewProvider = SupplementaryViewProviderHandler
};
// initial data
var snapshot = new NSDiffableDataSourceSnapshot <NSNumber, NSNumber> ();
var idOffset = 0;
var itemsPerSection = 18;
foreach (var section in SectionKind.AllSections)
{
snapshot.AppendSections(new [] { NSNumber.FromInt32(section.EnumValue) });
var items = Enumerable.Range(idOffset, itemsPerSection).Select(i => NSNumber.FromInt32(i)).ToArray();
snapshot.AppendItems(items);
idOffset += itemsPerSection;
}
dataSource.ApplySnapshot(snapshot, false);
UICollectionViewCell CellProviderHandler(UICollectionView collectionView, NSIndexPath indexPath, NSObject obj)
{
// Get a cell of the desired kind.
var cell = collectionView.DequeueReusableCell(TextCell.Key, indexPath) as TextCell;
// Populate the cell with our item description.
cell.Label.Text = $"{indexPath.Section}, {indexPath.Row}";
cell.ContentView.BackgroundColor = UIColorExtensions.CornflowerBlue;
cell.ContentView.Layer.BorderColor = UIColor.Black.CGColor;
cell.ContentView.Layer.BorderWidth = 1;
cell.ContentView.Layer.CornerRadius = 8;
cell.Label.TextAlignment = UITextAlignment.Center;
cell.Label.Font = UIFont.GetPreferredFontForTextStyle(UIFontTextStyle.Title1);
// Return the cell.
return(cell);
}
UICollectionReusableView SupplementaryViewProviderHandler(UICollectionView collectionView, string kind, NSIndexPath indexPath)
{
var sectionKind = SectionKind.GetSectionKind(indexPath.Section);
// Get a supplementary view of the desired kind.
var header = collectionView.DequeueReusableSupplementaryView(new NSString(kind),
TitleSupplementaryView.Key, indexPath) as TitleSupplementaryView;
// Populate the view with our section's description.
header.Label.Text = $".{sectionKind}";
// Return the view.
return(header);
}
}
private uint GetSectionLength(SectionKind sectionKind)
{
LinkerSection section;
if (this.sections.TryGetValue(sectionKind, out section) == true && section.Length > 0)
{
return((uint)section.Length);
}
return(0);
}
/// <summary>
/// Initializes a new instance of the <see cref="SimLinkerSection" /> class.
/// </summary>
/// <param name="kind">The kind of the section.</param>
/// <param name="name">The name.</param>
/// <param name="address">The address.</param>
/// <param name="size">The size.</param>
/// <param name="simAdapter">The sim adapter.</param>
public SimLinkerSection(SectionKind kind, string name, uint address, uint size, ISimAdapter simAdapter)
: base(kind, name, 0)
{
Memory = new byte[size];
VirtualAddress = address;
simAdapter.SimCPU.AddMemory(address, size, 1);
stream = new MemoryStream(Memory, true);
}
private long GetSectionAddress(SectionKind sectionKind)
{
LinkerSection section;
if (this.sections.TryGetValue(sectionKind, out section) == true && section.Length > 0)
{
return((uint)section.VirtualAddress.ToInt64());
}
return(0L);
}
/// <summary>
/// Initializes a new instance of the <see cref="LinkerSymbol"/> class.
/// </summary>
/// <param name="name">The name of the symbol.</param>
/// <param name="section">The section holding the symbol.</param>
/// <param name="sectionAddress">Holds the section relative address of the symbol.</param>
/// <exception cref="T:System.ArgumentException"><paramref name="name"/> is empty.</exception>
/// <exception cref="T:System.ArgumentNullException"><paramref name="name"/> is null.</exception>
public LinkerSymbol(string name, SectionKind section, long sectionAddress)
{
Debug.Assert(!String.IsNullOrEmpty(name), @"LinkerSymbol requires a proper name.");
if (name == null)
throw new ArgumentNullException(@"name");
if (name.Length == 0)
throw new ArgumentException(@"Name can't be empty.", @"name");
this.name = name;
this.section = section;
this.sectionAddress = sectionAddress;
}
private bool ContainsKind(SectionKind kind)
{
foreach (var symbol in linker.Symbols)
{
if (symbol.SectionKind == kind)
{
return(true);
}
}
return(false);
}
private void AllocateSpace(RuntimeField field, SectionKind section, int size, int alignment)
{
using (Stream stream = linker.Allocate(field.ToString(), section, size, alignment))
{
if (field.RVA != 0)
{
InitializeStaticValueFromRVA(stream, size, field);
}
else
{
WriteDummyBytes(stream, size);
}
}
}
public LinkerSymbol CreateSymbol(string name, SectionKind kind, int alignment, int size)
{
var symbol = CreateSymbol(name, kind, (uint)alignment);
MemoryStream stream = (size == 0) ? new MemoryStream() : new MemoryStream(size);
symbol.Stream = Stream.Synchronized(stream);
if (size != 0)
{
stream.SetLength(size);
}
return symbol;
}
private void AllocateSpace(IAssemblyLinker linker, RuntimeField field, SectionKind section, int size, int alignment)
{
using (Stream stream = linker.Allocate(field, section, size, alignment))
{
if (IntPtr.Zero != field.RVA)
{
InitializeStaticValueFromRVA(stream, size, field);
}
else
{
WriteDummyBytes(stream, size);
}
}
}
private void AllocateSpace(MosaField field, SectionKind section, int size, int alignment)
{
using (var stream = Compiler.Linker.Allocate(field.FullName, section, size, alignment))
{
if (field.Data != null)
{
stream.Write(field.Data, 0, size);
}
else
{
stream.WriteZeroBytes(size);
}
}
}
private void AllocateSpace(RuntimeField field, SectionKind section, int size, int alignment)
{
using (Stream stream = linker.Allocate(field.ToString(), section, size, alignment))
{
if (field.RVA != 0)
{
InitializeStaticValueFromRVA(stream, size, field);
}
else
{
stream.WriteZeroBytes(size);
}
}
}
private Stream EmitRelocationAddendSection(SectionKind kind)
{
var stream = new MemoryStream();
var writer = new BinaryWriter(stream);
foreach (var symbol in Linker.Symbols)
{
if (symbol.IsExternalSymbol)
{
continue;
}
foreach (var patch in symbol.LinkRequests)
{
if (patch.ReferenceOffset == 0)
{
continue;
}
if (patch.ReferenceSymbol.SectionKind != kind)
{
continue;
}
if (patch.LinkType == LinkType.Size)
{
continue;
}
if (!patch.ReferenceSymbol.IsExternalSymbol) // FUTURE: include relocations for static symbols, if option selected
{
continue;
}
var relocationAddendEntry = new RelocationAddendEntry()
{
RelocationType = ConvertType(MachineType, patch.LinkType, patch.PatchType),
Symbol = symbolTableOffset[patch.ReferenceSymbol],
Offset = (ulong)(symbol.SectionOffset + patch.PatchOffset),
Addend = (ulong)patch.ReferenceOffset,
};
relocationAddendEntry.Write(LinkerFormatType, writer);
}
}
return(stream);
}
/// <summary>
/// Initializes a new instance of the <see cref="LinkerSymbol"/> class.
/// </summary>
/// <param name="name">The name of the symbol.</param>
/// <param name="section">The section holding the symbol.</param>
/// <param name="sectionAddress">Holds the section relative address of the symbol.</param>
/// <exception cref="T:System.ArgumentException"><paramref name="name"/> is empty.</exception>
/// <exception cref="T:System.ArgumentNullException"><paramref name="name"/> is null.</exception>
public LinkerSymbol(string name, SectionKind section, long sectionAddress)
{
Debug.Assert(!String.IsNullOrEmpty(name), @"LinkerSymbol requires a proper name.");
if (name == null)
{
throw new ArgumentNullException(@"name");
}
if (name.Length == 0)
{
throw new ArgumentException(@"Name can't be empty.", @"name");
}
this.name = name;
this.section = section;
this.sectionAddress = sectionAddress;
}
// +-----------------------------------------------------+
// | +---------------------------------+ +-----------+ |
// | | | | | |
// | | | | | |
// | | | | 1 | |
// | | | | | |
// | | | | | |
// | | | +-----------+ |
// | | 0 | |
// | | | +-----------+ |
// | | | | | |
// | | | | | |
// | | | | 2 | |
// | | | | | |
// | | | | | |
// | +---------------------------------+ +-----------+ |
// +-----------------------------------------------------+
UICollectionViewLayout CreateLayout()
{
var config = new UICollectionViewCompositionalLayoutConfiguration {
InterSectionSpacing = 20
};
return(new UICollectionViewCompositionalLayout(SectionProviderHandler, config));
NSCollectionLayoutSection SectionProviderHandler(nint sectionIndex, INSCollectionLayoutEnvironment layoutEnvironment)
{
var sectionKind = SectionKind.GetSectionKind(sectionIndex);
var leadingItemSize = NSCollectionLayoutSize.Create(NSCollectionLayoutDimension.CreateFractionalWidth(.7f),
NSCollectionLayoutDimension.CreateFractionalHeight(1));
var leadingItem = NSCollectionLayoutItem.Create(leadingItemSize);
leadingItem.ContentInsets = new NSDirectionalEdgeInsets(10, 10, 10, 10);
var trailingItemSize = NSCollectionLayoutSize.Create(NSCollectionLayoutDimension.CreateFractionalWidth(1),
NSCollectionLayoutDimension.CreateFractionalHeight(.3f));
var trailingItem = NSCollectionLayoutItem.Create(trailingItemSize);
trailingItem.ContentInsets = new NSDirectionalEdgeInsets(10, 10, 10, 10);
var trailingGroupSize = NSCollectionLayoutSize.Create(NSCollectionLayoutDimension.CreateFractionalWidth(.3f),
NSCollectionLayoutDimension.CreateFractionalHeight(1));
var trailingGroup = NSCollectionLayoutGroup.CreateVertical(trailingGroupSize, trailingItem, 2);
var orthogonallyScrolls = sectionKind.GetOrthogonalScrollingBehavior() != UICollectionLayoutSectionOrthogonalScrollingBehavior.None;
var containerGroupFractionalWidth = orthogonallyScrolls ? .85f : 1;
var containerGroupSize = NSCollectionLayoutSize.Create(NSCollectionLayoutDimension.CreateFractionalWidth(containerGroupFractionalWidth),
NSCollectionLayoutDimension.CreateFractionalHeight(.4f));
var containerGroup = NSCollectionLayoutGroup.CreateHorizontal(containerGroupSize, leadingItem, trailingGroup);
var section = NSCollectionLayoutSection.Create(containerGroup);
section.OrthogonalScrollingBehavior = sectionKind.GetOrthogonalScrollingBehavior();
var sectionHeaderSize = NSCollectionLayoutSize.Create(NSCollectionLayoutDimension.CreateFractionalWidth(1),
NSCollectionLayoutDimension.CreateAbsolute(44));
var sectionHeader = NSCollectionLayoutBoundarySupplementaryItem.Create(sectionHeaderSize, headerElementKind, NSRectAlignment.Top);
section.BoundarySupplementaryItems = new [] { sectionHeader };
return(section);
}
}
private void RegisterRelocationSection(SectionKind kind, bool addend)
{
var relocationSection = new Section()
{
Name = (addend ? ".rela" : ".rel") + SectionNames[(int)kind],
Type = addend ? SectionType.RelocationA : SectionType.Relocation,
Link = symbolSection,
Info = GetSection(kind),
EntrySize = addend ? RelocationAddendEntry.GetEntrySize(LinkerFormatType) : RelocationEntry.GetEntrySize(LinkerFormatType),
Emitter = () => { return(addend ? EmitRelocationAddendSection(kind) : EmitRelocationSection(kind)); }
};
RegisterSection(relocationSection);
relocationSection.AddDependency(symbolSection);
relocationSection.AddDependency(GetSection(kind));
}
protected void CreateRelocationSection(SectionKind kind, bool addend)
{
var relocationSection = new Section();
relocationSection.Name = (addend ? ".rela" : ".rel") + LinkerSectionNames[(int)kind];
relocationSection.Type = addend ? SectionType.RelocationA : SectionType.Relocation;
relocationSection.Link = symbolSection;
relocationSection.Info = GetSection(kind);
relocationSection.AddressAlignment = linker.SectionAlignment;
relocationSection.EntrySize = (uint)(addend ? RelocationAddendEntry.GetEntrySize(linkerFormatType) : RelocationEntry.GetEntrySize(linkerFormatType));
relocationSection.EmitMethod = WriteRelocationSection;
AddSection(relocationSection);
relocationSection.AddDependency(symbolSection);
relocationSection.AddDependency(GetSection(kind));
}
private void CreateRelocationSection(SectionKind kind, bool addend)
{
var relocationSection = new Section()
{
Name = (addend ? ".rela" : ".rel") + LinkerSectionNames[(int)kind],
Type = addend ? SectionType.RelocationA : SectionType.Relocation,
Link = symbolSection,
Info = GetSection(kind),
AddressAlignment = linker.SectionAlignment,
EntrySize = addend ? RelocationAddendEntry.GetEntrySize(linkerFormatType) : RelocationEntry.GetEntrySize(linkerFormatType),
EmitMethod = WriteRelocationSection
};
AddSection(relocationSection);
relocationSection.AddDependency(symbolSection);
relocationSection.AddDependency(GetSection(kind));
}
/// <summary>
/// Allocates a symbol of the given name in the specified section.
/// </summary>
/// <param name="name">The name of the symbol.</param>
/// <param name="section">The executable section to allocate from.</param>
/// <param name="size">The number of bytes to allocate. If zero, indicates an unknown amount of memory is required.</param>
/// <param name="alignment">The alignment. A value of zero indicates the use of a default alignment for the section.</param>
/// <returns>
/// A stream, which can be used to populate the section.
/// </returns>
public override Stream Allocate(string name, SectionKind section, int size, int alignment)
{
LinkerStream stream = (LinkerStream)base.Allocate(name, section, size, alignment);
try
{
VirtualMemoryStream vms = (VirtualMemoryStream)stream.BaseStream;
LinkerSymbol symbol = this.GetSymbol(name);
symbol.VirtualAddress = new IntPtr(vms.Base.ToInt64() + vms.Position);
}
catch
{
stream.Dispose();
throw;
}
return(stream);
}
public LinkerSymbol DefineExternalSymbol(string name, string externalName, SectionKind kind)
{
lock (_lock)
{
if (!symbolLookup.TryGetValue(name, out LinkerSymbol symbol))
{
symbol = new LinkerSymbol(name, 0, kind);
Symbols.Add(symbol);
symbolLookup.Add(name, symbol);
}
symbol.SectionKind = kind;
symbol.IsExport = true;
symbol.ExportName = externalName;
return(symbol);
}
}
/// <summary>
/// Allocates a symbol of the given name in the specified section.
/// </summary>
/// <param name="name">The name of the symbol.</param>
/// <param name="section">The executable section to allocate from.</param>
/// <param name="size">The number of bytes to allocate. If zero, indicates an unknown amount of memory is required.</param>
/// <param name="alignment">The alignment. A value of zero indicates the use of a default alignment for the section.</param>
/// <returns>
/// A stream, which can be used to populate the section.
/// </returns>
public override Stream Allocate(string name, SectionKind section, int size, int alignment)
{
LinkerStream stream = (LinkerStream)base.Allocate(name, section, size, alignment);
try
{
VirtualMemoryStream vms = (VirtualMemoryStream)stream.BaseStream;
LinkerSymbol symbol = GetSymbol(name);
symbol.VirtualAddress = new IntPtr(vms.Base.ToInt64() + vms.Position);
Trace.WriteLine("Symbol " + name + " located at 0x" + symbol.VirtualAddress.ToInt32().ToString("x08"));
}
catch
{
stream.Dispose();
throw;
}
return(stream);
}
/// <summary>
/// Emits the displacement operand.
/// </summary>
/// <param name="displacement">The displacement operand.</param>
private void WriteDisplacement(Operand displacement)
{
if (displacement.IsLabel)
{
// FIXME! remove assertion
Debug.Assert(displacement.Displacement == 0);
linker.Link(LinkType.AbsoluteAddress, BuiltInPatch.I4, MethodName, SectionKind.Text, (int)codeStream.Position, 0, displacement.Name, SectionKind.ROData, 0);
codeStream.WriteZeroBytes(4);
}
else if (displacement.IsField)
{
SectionKind section = displacement.Field.Data != null ? section = SectionKind.ROData : section = SectionKind.BSS;
linker.Link(LinkType.AbsoluteAddress, BuiltInPatch.I4, MethodName, SectionKind.Text, (int)codeStream.Position, 0, displacement.Field.FullName, section, (int)displacement.Displacement);
codeStream.WriteZeroBytes(4);
}
else if (displacement.IsSymbol)
{
// FIXME! remove assertion
Debug.Assert(displacement.Displacement == 0);
SectionKind section = (displacement.Method != null) ? SectionKind.Text : SectionKind.ROData;
var symbol = linker.FindSymbol(displacement.Name);
if (symbol == null)
{
symbol = linker.GetSymbol(displacement.Name, section);
}
linker.Link(LinkType.AbsoluteAddress, BuiltInPatch.I4, MethodName, SectionKind.Text, (int)codeStream.Position, 0, symbol.Name, symbol.SectionKind, 0);
codeStream.WriteZeroBytes(4);
}
else if (displacement.IsMemoryAddress && displacement.OffsetBase != null && displacement.OffsetBase.IsConstant)
{
codeStream.Write((int)(displacement.OffsetBase.ConstantSignedLongInteger + displacement.Displacement), Endianness.Little);
}
else
{
codeStream.Write((int)displacement.Displacement, Endianness.Little);
}
}
/// <summary>
/// Allocates a symbol of the given name in the specified section.
/// </summary>
/// <param name="name">The name of the symbol.</param>
/// <param name="section">The executable section to allocate From.</param>
/// <param name="size">The number of bytes to allocate. If zero, indicates an unknown amount of memory is required.</param>
/// <param name="alignment">The alignment. A value of zero indicates the use of a default alignment for the section.</param>
/// <returns>
/// A stream, which can be used to populate the section.
/// </returns>
public virtual Stream Allocate(string name, SectionKind section, int size, int alignment)
{
Stream stream = Allocate(section, size, alignment);
try
{
// Create a linker symbol for the name
LinkerSymbol symbol = new LinkerSymbol(name, section, stream.Position);
// Save the symbol for later use
_symbols.Add(symbol.Name, symbol);
// Wrap the stream to catch premature disposal
stream = new LinkerStream(symbol, stream, size);
} catch (ArgumentException argx)
{
throw new LinkerException(String.Format("Symbol {0} defined multiple times.", name), argx);
}
return(stream);
}
public LinkerSymbol GetSymbol(string name, SectionKind kind)
{
return CreateSymbol(name, kind, 0);
}
public LinkerSymbol CreateSymbol(string name, SectionKind kind, int alignment, int size)
{
var symbol = CreateSymbol(name, kind, (uint)alignment);
MemoryStream stream = (size == 0) ? new MemoryStream() : new MemoryStream(size);
symbol.Stream = Stream.Synchronized(stream);
if (size != 0)
{
stream.SetLength(size);
}
return symbol;
}
/// <summary>
/// Initializes a new instance of the <see cref="Section"/> class.
/// </summary>
/// <param name="kind">The kind of the section.</param>
/// <param name="name">The name of the section.</param>
/// <param name="virtualAddress">The virtualAddress of the section.</param>
public Section(SectionKind kind, string name, IntPtr virtualAddress)
: base(kind, name, virtualAddress)
{
stream = new MemoryStream();
}
/// <summary>
/// Allocates a symbol of the given name in the specified section.
/// </summary>
/// <param name="section">The executable section to allocate From.</param>
/// <param name="size">The number of bytes to allocate. If zero, indicates an unknown amount of memory is required.</param>
/// <param name="alignment">The alignment. A value of zero indicates the use of a default alignment for the section.</param>
/// <returns>
/// A stream, which can be used to populate the section.
/// </returns>
protected override System.IO.Stream Allocate(SectionKind section, int size, int alignment)
{
Elf64.Sections.Elf64Section linkerSection = (Elf64.Sections.Elf64Section)GetSection(section);
return linkerSection.Allocate(size, alignment);
}
/// <summary> /// Allocates a symbol of the given name in the specified section. /// </summary> /// <param name="section">The executable section to allocate From.</param> /// <param name="size">The number of bytes to allocate. If zero, indicates an unknown amount of memory is required.</param> /// <param name="alignment">The alignment. A value of zero indicates the use of a default alignment for the section.</param> /// <returns> /// A stream, which can be used to populate the section. /// </returns> protected abstract Stream Allocate(SectionKind section, int size, int alignment);
/// <summary>
/// Retrieves a linker section by its type.
/// </summary>
/// <param name="sectionKind">The type of the section to retrieve.</param>
/// <returns>The retrieved linker section.</returns>
public override LinkerSection GetSection(SectionKind sectionKind)
{
return this.sections[(int)sectionKind];
}
protected LinkerSymbol CreateSymbol(string name, SectionKind kind, uint alignment)
{
lock (mylock)
{
var section = Sections[(int)kind];
Debug.Assert(section != null);
var symbol = section.GetSymbol(name);
if (symbol == null)
{
symbol = new LinkerSymbol(name, kind, alignment);
section.AddLinkerObject(symbol);
}
symbol.Alignment = alignment != 0 ? alignment : 0;
return symbol;
}
}
private uint GetSectionLength(SectionKind sectionKind)
{
LinkerSection section;
if (this.sections.TryGetValue(sectionKind, out section) == true && section.Length > 0)
return (uint)section.Length;
return 0;
}
/// <summary>
/// Allocates memory in the specified section.
/// </summary>
/// <param name="symbol">The metadata member to allocate space for.</param>
/// <param name="section">The executable section to allocate From.</param>
/// <param name="size">The number of bytes to allocate. If zero, indicates an unknown amount of memory is required.</param>
/// <param name="alignment">The alignment. A value of zero indicates the use of a default alignment for the section.</param>
/// <returns>A stream, which can be used to populate the section.</returns>
public Stream Allocate(RuntimeMember symbol, SectionKind section, int size, int alignment)
{
CheckImplementation();
return this.implementation.Allocate(symbol, section, size, alignment);
}
/// <summary>
/// Gets the section.
/// </summary>
/// <param name="sectionKind">Kind of the section.</param>
/// <returns>The section of the requested kind.</returns>
public LinkerSection GetSection(SectionKind sectionKind)
{
CheckImplementation();
return this.implementation.GetSection(sectionKind);
}
/// <summary>
/// Allocates a symbol of the given name in the specified section.
/// </summary>
/// <param name="name">The name of the symbol.</param>
/// <param name="section">The executable section to allocate From.</param>
/// <param name="size">The number of bytes to allocate. If zero, indicates an unknown amount of memory is required.</param>
/// <param name="alignment">The alignment. A value of zero indicates the use of a default alignment for the section.</param>
/// <returns>A stream, which can be used to populate the section.</returns>
public Stream Allocate(string name, SectionKind section, int size, int alignment)
{
CheckImplementation();
return this.implementation.Allocate(name, section, size, alignment);
}
/// <summary>
/// Retrieves a linker section by its type.
/// </summary>
/// <param name="sectionKind">The type of the section to retrieve.</param>
/// <returns>The retrieved linker section.</returns>
public override LinkerSection GetSection(SectionKind sectionKind)
{
throw new NotImplementedException();
}
/// <summary>
/// Allocates a symbol of the given name in the specified section.
/// </summary>
/// <param name="section">The executable section to allocate From.</param>
/// <param name="size">The number of bytes to allocate. If zero, indicates an unknown amount of memory is required.</param>
/// <param name="alignment">The alignment. A value of zero indicates the use of a default alignment for the section.</param>
/// <returns>
/// A stream, which can be used to populate the section.
/// </returns>
protected override Stream Allocate(SectionKind section, int size, int alignment)
{
throw new NotImplementedException();
}
public void Link(LinkType linkType, PatchType patchType, string patchSymbol, SectionKind patchKind, int patchOffset, int relativeBase, string referenceSymbol, SectionKind referenceKind, int referenceOffset)
{
var referenceObject = GetSymbol(referenceSymbol, referenceKind);
var patchObject = GetSymbol(patchSymbol, patchKind);
Link(linkType, patchType, patchObject, patchOffset, relativeBase, referenceObject, referenceOffset);
}
public void Link(LinkType linkType, PatchType patchType, LinkerSymbol patchSymbol, int patchOffset, int relativeBase, string referenceSymbol, SectionKind patchRelativeBase, int referenceOffset)
{
var referenceObject = GetSymbol(referenceSymbol, patchRelativeBase);
Link(linkType, patchType, patchSymbol, patchOffset, relativeBase, referenceObject, referenceOffset);
}
/// <summary>
/// Allocates a symbol of the given name in the specified section.
/// </summary>
/// <param name="name">The name of the symbol.</param>
/// <param name="section">The executable section to allocate From.</param>
/// <param name="size">The number of bytes to allocate. If zero, indicates an unknown amount of memory is required.</param>
/// <param name="alignment">The alignment. A value of zero indicates the use of a default alignment for the section.</param>
/// <returns>
/// A stream, which can be used to populate the section.
/// </returns>
public virtual Stream Allocate(string name, SectionKind section, int size, int alignment)
{
Stream result;
Stream baseStream = Allocate(section, size, alignment);
try
{
// Create a linker symbol for the name
LinkerSymbol symbol = new LinkerSymbol(name, section, baseStream.Position);
// Save the symbol for later use
_symbols.Add(symbol.Name, symbol);
// Wrap the stream to catch premature disposal
result = new LinkerStream(symbol, baseStream, size);
}
catch (ArgumentException argx)
{
throw new LinkerException(String.Format(@"Symbol {0} defined multiple times.", name), argx);
}
return result;
}
protected LinkerSection GetSection(SectionKind kind)
{
return Sections[(int)kind];
}
/// <summary>
/// Allocates the specified member.
/// </summary>
/// <param name="member">The member.</param>
/// <param name="section">The section.</param>
/// <param name="size">The size.</param>
/// <param name="alignment">The alignment.</param>
/// <returns></returns>
public virtual Stream Allocate(RuntimeMember member, SectionKind section, int size, int alignment)
{
return null;
}
private long GetSectionAddress(SectionKind sectionKind)
{
LinkerSection section;
if (this.sections.TryGetValue(sectionKind, out section) == true && section.Length > 0)
{
return (uint)section.VirtualAddress.ToInt64();
}
return 0L;
}
/// <summary> /// Gets the section. /// </summary> /// <param name="sectionKind">Kind of the section.</param> /// <returns>The section of the requested kind.</returns> public abstract LinkerSection GetSection(SectionKind sectionKind);
/// <summary>
/// Allocates a symbol of the given name in the specified section.
/// </summary>
/// <param name="name">The name of the symbol.</param>
/// <param name="section">The executable section to allocate From.</param>
/// <param name="size">The number of bytes to allocate. If zero, indicates an unknown amount of memory is required.</param>
/// <param name="alignment">The alignment. A value of zero indicates the use of a default alignment for the section.</param>
/// <returns>
/// A stream, which can be used to populate the section.
/// </returns>
public virtual Stream Allocate(string name, SectionKind section, int size, int alignment)
{
return null;
}
/// <summary>
/// Allocates a symbol of the given name in the specified section.
/// </summary>
/// <param name="section">The executable section to allocate From.</param>
/// <param name="size">The number of bytes to allocate. If zero, indicates an unknown amount of memory is required.</param>
/// <param name="alignment">The alignment. A value of zero indicates the use of a default alignment for the section.</param>
/// <returns>
/// A stream, which can be used to populate the section.
/// </returns>
protected override Stream Allocate(SectionKind section, int size, int alignment)
{
Section linkerSection = (Section)GetSection(section);
return linkerSection.Allocate(size, alignment);
}
