public void SetCommandAtIndex(int index, RelCommand cmd) { if (index >= Relocations.Count || index < 0) { return; } if (Relocations[index].Command != null) { Relocations[index].Command.Remove(); } Relocations[index].Command = cmd; RelCommand c = GetCommandBefore(index); if (c != null) { cmd.InsertAfter(c); } else { c = GetCommandAfter(index); if (c != null) { cmd.InsertBefore(c); } } GetFirstCommand(); }
public void SetCommand(int index, RelCommand cmd) { if (_reference != null) { _reference._manager.SetCommand(index + _referenceIndex, cmd); return; } if (_commands.ContainsKey(index)) { if (cmd != null) { LinkCommand(index, false); _commands[index] = cmd; LinkCommand(index, true); } else { LinkCommand(index, false); _commands.Remove(index); } } else if (cmd != null) { _commands.Add(index, cmd); LinkCommand(index, true); } }
public void ClearCommands() { RelCommand c = _firstCommand; while (c != null) { c._parentRelocation.Command = null; c = c._next; } }
public void Remove() { if (_next != null) { _next._prev = _prev; } if (_prev != null) { _prev._next = _next; } _next = _prev = null; }
private void SetCommand(RelCommand command) { if (_command == command) { return; } if (_command != null) { SetTarget(null); _command._parentRelocation = null; } if ((_command = command) != null) { _command._parentRelocation = this; SetTarget(_command.GetTargetRelocation()); } }
public SectionEditor(ModuleSectionNode section) { InitializeComponent(); ppcDisassembler1._editor = this; if ((_section = section) != null) { _section._linkedEditor = this; Relocation[] temp = new Relocation[_section._relocations.Count]; _section._relocations.CopyTo(temp); _relocations = temp.ToList(); _firstCommand = _section._firstCommand; } _openedSections.Add(this); Text = String.Format("Module Section Editor - {0}", _section.Name); hexBox1.SectionEditor = this; chkCodeSection.Checked = _section._isCodeSection; chkBSSSection.Checked = _section._isBSSSection; if (section.Root is RELNode) { RELNode r = (RELNode)section.Root; if (r._prologReloc != null && r._prologReloc._section == section) _prologReloc = r._prologReloc; if (r._epilogReloc != null && r._epilogReloc._section == section) _epilogReloc = r._epilogReloc; if (r._unresReloc != null && r._unresReloc._section == section) _unresReloc = r._unresReloc; //if (r._nameReloc != null && r._nameReloc._section == section) // _nameReloc = r._nameReloc; } panel5.Enabled = true; }
public void GenerateImports() { _imports.Clear(); Dictionary <uint, ImportData> data = new Dictionary <uint, ImportData>(); foreach (ModuleSectionNode s in _sections) { foreach (ImportData e in data.Values) { e._first = true; e._lastOffset = 0; } uint i = 0; uint offset = 0; List <RELLink> cmds; foreach (Relocation loc in s._relocations) { if (loc.Command != null) { RelCommand cmd = loc.Command; ImportData d; uint id = cmd._moduleID; if (_imports.ContainsKey(id)) { cmds = _imports[id]; d = data[id]; } else { _imports.Add(id, cmds = new List <RELLink>()); data.Add(id, d = new ImportData() { _first = true, _lastOffset = 0 }); } if (d._first) { cmds.Add(new RELLink() { _type = RELLinkType.Section, _section = (byte)s.Index }); d._first = false; } offset = i * 4 + (cmd.IsHalf ? 2u : 0); uint diff = offset - d._lastOffset; while (offset - d._lastOffset > 0xFFFF) { d._lastOffset += 0xFFFF; cmds.Add(new RELLink() { _type = RELLinkType.IncrementOffset, _section = 0, _value = 0, _prevOffset = 0xFFFF }); } byte targetSection = (byte)cmd._targetSectionId; RELLinkType type = (RELLinkType)cmd._command; uint val = cmd._addend; cmds.Add(new RELLink() { _type = type, _section = targetSection, _value = val, _prevOffset = (ushort)diff }); d._lastOffset = offset; } i++; } } foreach (List <RELLink> cmds in _imports.Values) { cmds.Add(new RELLink() { _type = RELLinkType.End }); } }
private unsafe RELObjectNode ParseObject(ref int rel) { RelCommand cmd = Manager.GetCommand(rel); RelocationTarget target = cmd?.GetTargetRelocation(); if (target == null || target._sectionID != _objectSection.Index) { return(null); } if (!_types.TryGetValue(target._index, out RELType declaration) || declaration.Inherited) { return(null); } RELObjectNode obj = null; foreach (RELObjectNode node in _objects) { if (node._name == declaration.FullName) { obj = node; break; } } if (obj == null) { obj = new RELObjectNode(declaration) { _parent = _objectSection }; _objectSection._children.Add(obj); new RELGroupNode { _name = "Inheritance" }.Parent = obj; foreach (InheritanceItemNode n in declaration.Inheritance) { n.Parent = obj.Children[0]; } new RELGroupNode { _name = "Functions" }.Parent = obj; } int baseRel = rel; RelCommand baseCmd = Manager.GetCommand(baseRel); int methodIndex = 0; int setIndex = 0; //Read object methods. while ((cmd = Manager.GetCommand(rel)) != null) { RelocationTarget t = cmd.GetTargetRelocation(); if (cmd.Apply(Manager.GetUint(rel), 0) != baseCmd.Apply(Manager.GetUint(baseRel), 0)) { string methodName = $"Function[{setIndex}][{methodIndex}]"; VoidPtr addr = null; if (t != null && t._moduleID == (_objectSection.Root as ModuleNode).ID) { addr = _objectSection.Root.Children[t._sectionID].WorkingUncompressed.Address + t._index * 4; } new RELMethodNode { _name = methodName, _cmd = cmd } .Initialize(obj.Children[1], addr, 0); methodIndex++; } else { if (Manager.GetUint(rel + 1) != 0) { setIndex++; } methodIndex = 0; rel++; } rel++; } Manager.AddTag(baseRel, obj.Type.FullName); _objects.Add(obj); return(obj); }
public void InsertAfter(RelCommand cmd) { _prev = cmd; _next = cmd._next; cmd._next = this; }
public void InsertBefore(RelCommand cmd) { _next = cmd; _prev = cmd._prev; cmd._prev = this; }
public void GenerateImports() { _imports.Clear(); Dictionary <uint, ImportData> tempImports = new Dictionary <uint, ImportData>(); foreach (ModuleSectionNode s in _sections) { foreach (ImportData e in tempImports.Values) { e._newSection = true; e._lastOffset = 0; } uint offset = 0; List <RELLink> links; //Iterate through each command in the section var commands = s._manager.GetCommands(); foreach (var r in commands) { RelCommand command = r.Value; int index = r.Key; ImportData impData; uint moduleID = command._moduleID; //Check if an import has been created for the target module. if (_imports.ContainsKey(moduleID)) { //An import already exists, so we'll add to it. links = _imports[moduleID]; impData = tempImports[moduleID]; } else { //An import does not exist, so it must be made. _imports.Add(moduleID, links = new List <RELLink>()); //Create new temporary import data tempImports.Add(moduleID, impData = new ImportData() { _newSection = true, _lastOffset = 0 }); } //This is true when a new section is being evaluated. if (impData._newSection) { links.Add(new RELLink() { _type = RELLinkType.Section, _section = (byte)s.Index }); impData._newSection = false; } //Get the offset of the command within the section. offset = (uint)index * 4 + (command.IsHalf ? 2u : 0); //Get the offset to this address relative to the last written link offset. uint diff = offset - impData._lastOffset; //If the difference is greater than ushort allows, //add increment links until the difference works while (diff > 0xFFFF) { impData._lastOffset += 0xFFFF; diff = offset - impData._lastOffset; links.Add(new RELLink() { _type = RELLinkType.IncrementOffset, _section = 0, _value = 0, _prevOffset = 0xFFFF }); } //Gather the link information byte targetSection = (byte)command._targetSectionId; RELLinkType type = (RELLinkType)command._command; uint val = command._addend; //Write command link links.Add(new RELLink() { _type = type, _section = targetSection, _value = val, _prevOffset = (ushort)diff }); //Don't bother adding the difference, //just set the exact offset as the last offset impData._lastOffset = offset; } } foreach (List <RELLink> cmds in _imports.Values) { cmds.Add(new RELLink() { _type = RELLinkType.End }); } }
public void Remove() { if (_next != null) _next._prev = _prev; if (_prev != null) _prev._next = _next; _next = _prev = null; }
public void SetCommandAtOffset(int offset, RelCommand cmd) { SetCommandAtIndex(offset.RoundDown(4) / 4, cmd); }
public void GetFirstCommand() { _firstCommand = GetCommandAfter(-1); }
public void SetCommandAtIndex(int index, RelCommand cmd) { if (index >= _relocations.Count || index < 0) return; if (_relocations[index].Command != null) _relocations[index].Command.Remove(); _relocations[index].Command = cmd; RelCommand c = GetCommandBefore(index); if (c != null) cmd.InsertAfter(c); else { c = GetCommandAfter(index); if (c != null) cmd.InsertBefore(c); } GetFirstCommand(); }
private unsafe RELType ParseDeclaration(int index) { if (_types.TryGetValue(index, out RELType type)) { return(type); } RelCommand cmd = Manager.GetCommand(index); RelocationTarget target = cmd?.GetTargetRelocation(); if (target == null || target._sectionID != _objectSection.Index) { return(null); } uint relOffset = cmd.Apply(Manager.GetUint(index), 0); if (relOffset > _objectSection._dataOffset + _objectSection._dataSize) { return(null); } string name = new string((sbyte *)(_objectSection.Header + relOffset)); if (string.IsNullOrWhiteSpace(name)) { return(null); } type = new RELType(name); //Get inheritances, if any. cmd = Manager.GetCommand(index + 1); if (cmd != null) { for (RelocationTarget r = cmd.GetTargetRelocation(); r != null && (cmd = Manager.GetCommand(r._index)) != null; r._index += 2) { RelocationTarget inheritTarget = cmd.GetTargetRelocation(); RELType inheritance = ParseDeclaration(inheritTarget._index); if (inheritance != null) { InheritanceItemNode typeNode = new InheritanceItemNode(inheritance, Manager.GetUint(r._index + 1)); typeNode.Initialize(null, _objectSection.Header + r._index * 4, 0); type.Inheritance.Add(typeNode); inheritance.Inherited = true; } else { break; } } } Manager.AddTag(index, type.FormalName + " Declaration"); Manager.AddTag(index + 1, type.FormalName + "->Inheritances"); _types.Add(index, type); return(type); }
private void SetCommand(RelCommand command) { if (_command == command) return; if (_command != null) { SetTarget(null); _command._parentRelocation = null; } if ((_command = command) != null) { _command._parentRelocation = this; SetTarget(_command.GetTargetRelocation()); } }