public Instruction(Mnemonic mnemonic, Operand? operand, byte opcode, int length)
{
this.Mnemonic = mnemonic;
this.Operand = operand;
this.Opcode = opcode;
this.Length = length;
}
public Instruction(Mnemonic mnemonic, int length, byte[] opcode, params Operand[] operands)
{
Mnemonic = mnemonic;
Length = length;
Opcode = opcode;
Operands = operands;
}
public Instruction(string mnemonic, string arg1, string arg2, string arg3)
{
this.mnemonic = (Mnemonic)Enum.Parse(typeof(Mnemonic), mnemonic.ToUpper());
this.arg1 = arg1;
this.arg2 = arg2;
this.arg3 = arg3;
}
public Instruction(Mnemonic mnemonic, Operand[] operands, byte[] opcode, int length)
{
this.Mnemonic = mnemonic;
this.Operands = operands;
this.Opcode = opcode;
this.Length = length;
}
private Instruction TryCompile(Mnemonic mnemonic, params Argument[] arguments)
{
File.WriteAllText(inputFile.Name, GetSourceCode(mnemonic, arguments));
if (File.Exists(outputFile.Name)) File.Delete(outputFile.Name);
Process.Start(processStartInfo).WaitForExit();
if (!File.Exists(outputFile.Name)) return null;
return ParseInstruction(mnemonic, arguments);
}
public Instruction(BitArray machine_code ,bool isAlias = false)
{
this.machine_code = machine_code;
this.mnemonic = Mnemonic.NULL;
this.isAlias = isAlias;
this.arg1 = string.Empty;
this.arg2 = string.Empty;
this.arg3 = string.Empty;
}
private string GetSourceCode(Mnemonic mnemonic, params Argument[] arguments)
{
var builder = new StringBuilder()
.AppendLine("cpu 8086")
.Append(mnemonic);
for (int i = 0; i < arguments.Length; i++)
{
if (i > 0) builder.Append(",");
builder.Append(" ").Append(arguments[i].Text);
}
return builder.ToString();
}
private Instruction ParseInstruction(Mnemonic mnemonic, params Argument[] arguments)
{
var byteCode = File.ReadAllBytes(outputFile.Name).ToList();
var length = byteCode.Count;
foreach (var argument in arguments.Reverse())
{
if (!argument.Check(byteCode)) return null;
argument.Read(byteCode);
}
return new Instruction(mnemonic,
length,
byteCode.ToArray(),
arguments.Select(x => x.Operand).ToArray());
}
public IEnumerable<Instruction> Compile(Mnemonic mnemonic)
{
yield return TryCompile(mnemonic);
foreach (var argument in Reflection.CreateSubClasses<Argument>())
{
yield return TryCompile(mnemonic, argument);
}
foreach (var left in Reflection.CreateSubClasses<Argument>())
{
foreach (var right in Reflection.CreateSubClasses<Argument>())
{
yield return TryCompile(mnemonic, left, right);
}
}
}
public PICInstructionMem2Mem(Mnemonic mnemonic, byte srcidx, uint dstaddr)
: base(mnemonic,
new PICOperandFSRIndexation(Constant.Byte(srcidx)),
new PICOperandDataMemoryAddress(dstaddr))
{
}
public PICInstructionMemF(Mnemonic mnemonic, ushort memaddr)
: base(mnemonic, new PICOperandBankedMemory(memaddr))
{
}
public PICInstructionImmedByte(Mnemonic mnemonic, ushort imm)
: base(mnemonic, new PICOperandImmediate(imm, PrimitiveType.Byte))
{
}
public override void Render(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
writer.WriteMnemonic(Mnemonic.ToString());
writer.Tab();
Operands[0].Write(writer, options);
}
public Expression(Mnemonic expression) : base(null)
{
this.SubExpression = expression;
}
public Immed8Decoder(Mnemonic mnemonic)
{
this.mnemonic = mnemonic;
}
public void RunRule_ProvenHeadersActive_And_ValidProvenHeader_NoErrorsAreThrown()
{
// Setup private key.
var mnemonic = new Mnemonic(Wordlist.English, WordCount.Twelve);
Key privateKey = mnemonic.DeriveExtKey().PrivateKey;
// Setup previous chained header.
PosBlock prevPosBlock = new PosBlockBuilder(this.network, privateKey).Build();
ProvenBlockHeader prevProvenBlockHeader = new ProvenBlockHeaderBuilder(prevPosBlock, this.network).Build();
var previousChainedHeader = new ChainedHeader(prevProvenBlockHeader, prevProvenBlockHeader.GetHash(), null);
previousChainedHeader.SetPrivatePropertyValue("Height", this.provenHeadersActivationHeight + 1);
// Setup proven header with valid coinstake.
PosBlock posBlock = new PosBlockBuilder(this.network, privateKey).Build();
posBlock.UpdateMerkleRoot();
posBlock.Header.HashPrevBlock = prevProvenBlockHeader.GetHash();
posBlock.Header.Bits = 16777216;
// Update signature.
ECDSASignature signature = privateKey.Sign(posBlock.Header.GetHash());
posBlock.BlockSignature = new BlockSignature {
Signature = signature.ToDER()
};
ProvenBlockHeader provenBlockHeader = new ProvenBlockHeaderBuilder(posBlock, this.network).Build(prevProvenBlockHeader);
provenBlockHeader.HashPrevBlock = prevProvenBlockHeader.GetHash();
if (provenBlockHeader.Coinstake is IPosTransactionWithTime posTrx)
{
posTrx.Time = provenBlockHeader.Time;
}
// Set invalid coinstake script pub key
provenBlockHeader.Coinstake.Outputs[1].ScriptPubKey = privateKey.PubKey.ScriptPubKey;
// Setup chained header and move it to the height higher than proven header activation height.
this.ruleContext.ValidationContext.ChainedHeaderToValidate = new ChainedHeader(provenBlockHeader, provenBlockHeader.GetHash(), previousChainedHeader);
this.ruleContext.ValidationContext.ChainedHeaderToValidate.SetPrivatePropertyValue("Height", this.provenHeadersActivationHeight + 2);
// Setup coinstake transaction with a valid stake age.
uint unspentOutputsHeight = (uint)this.provenHeadersActivationHeight + 10;
var res = new FetchCoinsResponse();
var unspentOutputs = new UnspentOutput(prevPosBlock.Transactions[1].Inputs[0].PrevOut,
new Coins(unspentOutputsHeight, new TxOut(new Money(100), privateKey.PubKey), false));
res.UnspentOutputs.Add(unspentOutputs.OutPoint, unspentOutputs);
this.coinView
.Setup(m => m.FetchCoins(It.IsAny <OutPoint[]>()))
.Returns(res);
// Setup stake validator to pass stake age check.
this.stakeValidator
.Setup(m => m.IsConfirmedInNPrevBlocks(It.IsAny <UnspentOutput>(), It.IsAny <ChainedHeader>(), It.IsAny <long>()))
.Returns(false);
// Setup stake validator to pass signature validation.
this.stakeValidator
.Setup(m => m.VerifySignature(It.IsAny <UnspentOutput>(), It.IsAny <Transaction>(), It.IsAny <int>(), It.IsAny <ScriptVerify>()))
.Returns(true);
// Setup stake validator to pass stake kernel hash validation.
this.stakeChain.Setup(m => m.Get(It.IsAny <uint256>())).Returns(new BlockStake());
this.stakeValidator
.Setup(m => m.CheckStakeKernelHash(It.IsAny <PosRuleContext>(), It.IsAny <uint>(), It.IsAny <uint256>(), It.IsAny <UnspentOutput>(), It.IsAny <OutPoint>(), It.IsAny <uint>())).Returns(true);
// When we run the validation rule, we should not hit any errors.
Action ruleValidation = () => this.consensusRules.RegisterRule <ProvenHeaderCoinstakeRule>().Run(this.ruleContext);
ruleValidation.Should().NotThrow();
}
protected Safe(string password, string walletFilePath, Network network, DateTimeOffset creationTime, Mnemonic mnemonic = null)
{
Network = network;
WalletFilePath = walletFilePath;
CreationTime = creationTime > EarliestPossibleCreationTime ? creationTime : EarliestPossibleCreationTime;
if (mnemonic != null)
{
SetSeed(password, mnemonic);
}
}
public void RunRule_ProvenHeadersActive_And_InvalidCoinstakeKernelSignature_BadBlockSignatureErrorIsThrown()
{
// Setup private key.
var mnemonic = new Mnemonic(Wordlist.English, WordCount.Twelve);
Key privateKey = mnemonic.DeriveExtKey().PrivateKey;
// Setup previous chained header.
PosBlock prevPosBlock = new PosBlockBuilder(this.network, privateKey).Build();
ProvenBlockHeader prevProvenBlockHeader = new ProvenBlockHeaderBuilder(prevPosBlock, this.network).Build();
var previousChainedHeader = new ChainedHeader(prevProvenBlockHeader, prevProvenBlockHeader.GetHash(), null);
previousChainedHeader.SetPrivatePropertyValue("Height", this.provenHeadersActivationHeight + 1);
// Setup proven header with valid coinstake.
PosBlock posBlock = new PosBlockBuilder(this.network, privateKey).Build();
posBlock.UpdateMerkleRoot();
ProvenBlockHeader provenBlockHeader = new ProvenBlockHeaderBuilder(posBlock, this.network).Build(prevProvenBlockHeader);
provenBlockHeader.HashPrevBlock = prevProvenBlockHeader.GetHash();
if (provenBlockHeader.Coinstake is IPosTransactionWithTime posTrx)
{
posTrx.Time = provenBlockHeader.Time;
}
// Set invalid coinstake script pub key.
provenBlockHeader.Coinstake.Outputs[1].ScriptPubKey = new Script("03cdac179a3391d96cf4957fa0255e4aa8055a993e92df7146e740117885b184ea OP_CHECKSIG");
// Setup chained header and move it to the height higher than proven header activation height.
this.ruleContext.ValidationContext.ChainedHeaderToValidate = new ChainedHeader(provenBlockHeader, provenBlockHeader.GetHash(), previousChainedHeader);
this.ruleContext.ValidationContext.ChainedHeaderToValidate.SetPrivatePropertyValue("Height", this.provenHeadersActivationHeight + 2);
// Setup coinstake transaction with a valid stake age.
uint unspentOutputsHeight = (uint)this.provenHeadersActivationHeight + 10;
var res = new FetchCoinsResponse();
var unspentOutputs = new UnspentOutput(prevPosBlock.Transactions[1].Inputs[0].PrevOut,
new Coins(unspentOutputsHeight, new TxOut(new Money(100), privateKey.PubKey), false));
res.UnspentOutputs.Add(unspentOutputs.OutPoint, unspentOutputs);
this.coinView
.Setup(m => m.FetchCoins(It.IsAny <OutPoint[]>()))
.Returns(res);
// Setup stake validator to pass signature validation.
this.stakeValidator
.Setup(m => m.VerifySignature(It.IsAny <UnspentOutput>(), It.IsAny <Transaction>(), It.IsAny <int>(), It.IsAny <ScriptVerify>()))
.Returns(true);
// Setup stake validator to pass stake kernel hash validation.
this.stakeChain.Setup(m => m.Get(It.IsAny <uint256>())).Returns(new BlockStake());
this.stakeValidator
.Setup(m => m.CheckStakeKernelHash(It.IsAny <PosRuleContext>(), It.IsAny <uint>(), It.IsAny <uint256>(), It.IsAny <UnspentOutput>(), It.IsAny <OutPoint>(), It.IsAny <uint>())).Returns(true);
// Setup stake validator to pass stake age check.
this.stakeValidator
.Setup(m => m.IsConfirmedInNPrevBlocks(It.IsAny <UnspentOutput>(), It.IsAny <ChainedHeader>(), It.IsAny <long>()))
.Returns(false);
// When we run the validation rule, we should hit bad merkle proof error.
Action ruleValidation = () => this.consensusRules.RegisterRule <ProvenHeaderCoinstakeRule>().Run(this.ruleContext);
ruleValidation.Should().Throw <ConsensusErrorException>()
.And.ConsensusError
.Should().Be(ConsensusErrors.BadBlockSignature);
}
public TargetAbs11Decoder(Mnemonic mnemonic)
{
this.mnemonic = mnemonic;
}
public MoviIncDecDecoder(Mnemonic mnemonic)
{
this.mnemonic = mnemonic;
}
public FSRIndexedDecoder(Mnemonic mnemonic)
{
this.mnemonic = mnemonic;
}
private void LoadRegularData(string filename)
{
//AsmDudeToolsStatic.Output_INFO("MnemonicStore:loadRegularData: filename=" + filename);
try
{
System.IO.StreamReader file = new System.IO.StreamReader(filename);
string line;
while ((line = file.ReadLine()) != null)
{
if ((line.Length > 0) && (!line.StartsWith(";")))
{
string[] columns = line.Split('\t');
if (columns.Length == 4)
{ // general description
#region
Mnemonic mnemonic = AsmSourceTools.ParseMnemonic(columns[1]);
if (mnemonic == Mnemonic.NONE)
{
// ignore the unknown mnemonic
//AsmDudeToolsStatic.Output_WARNING("MnemonicStore:loadRegularData: unknown mnemonic in line: " + line);
}
else
{
if (!this._description.ContainsKey(mnemonic))
{
this._description.Add(mnemonic, columns[2]);
}
else
{
// this happens when the mnemonic is defined in multiple files, using the data from the first file
//AsmDudeToolsStatic.Output_WARNING("MnemonicStore:loadRegularData: mnemonic " + mnemonic + " already has a description");
}
if (!this._htmlRef.ContainsKey(mnemonic))
{
this._htmlRef.Add(mnemonic, columns[3]);
}
else
{
// this happens when the mnemonic is defined in multiple files, using the data from the first file
//AsmDudeToolsStatic.Output_WARNING("MnemonicStore:loadRegularData: mnemonic " + mnemonic + " already has a html ref");
}
}
#endregion
}
else if ((columns.Length == 5) || (columns.Length == 6))
{ // signature description, ignore an old sixth column
#region
Mnemonic mnemonic = AsmSourceTools.ParseMnemonic(columns[0]);
if (mnemonic == Mnemonic.NONE)
{
AsmDudeToolsStatic.Output_WARNING("MnemonicStore:loadRegularData: unknown mnemonic in line: " + line);
}
else
{
AsmSignatureElement se = new AsmSignatureElement(mnemonic, columns[1], columns[2], columns[3], columns[4]);
if (this.Add(se))
{
AsmDudeToolsStatic.Output_WARNING("MnemonicStore:loadRegularData: signature already exists" + se.ToString());
}
}
#endregion
}
else
{
AsmDudeToolsStatic.Output_WARNING("MnemonicStore:loadRegularData: s.Length=" + columns.Length + "; funky line" + line);
}
}
}
file.Close();
#region Fill Arch
foreach (KeyValuePair <Mnemonic, IList <AsmSignatureElement> > pair in this._data)
{
ISet <Arch> archs = new HashSet <Arch>();
foreach (AsmSignatureElement signatureElement in pair.Value)
{
foreach (Arch arch in signatureElement.Arch)
{
if (arch == Arch.ARCH_NONE)
{
AsmDudeToolsStatic.Output_WARNING("MnemonicStore:loadRegularData: found ARCH NONE.");
}
else
{
archs.Add(arch);
}
}
}
IList <Arch> list = new List <Arch>();
foreach (Arch a in archs)
{
list.Add(a);
}
this._arch[pair.Key] = list;
}
#endregion
}
catch (FileNotFoundException)
{
AsmDudeToolsStatic.Output_ERROR("MnemonicStore:loadRegularData: could not find file \"" + filename + "\".");
}
catch (Exception e)
{
AsmDudeToolsStatic.Output_ERROR("MnemonicStore:loadRegularData: error while reading file \"" + filename + "\"." + e);
}
}
void GetInstructionTypeSpecial1(Mnemonic mne)
{
Register r;
if (passnum == 1)
{
codegen.AdvancePC(mne);
return;
}
scanner.Get(out sym);
if (sym != Token.Register)
{
scanner.Mark(ErrorType.RegisterExpected);
return;
}
r = scanner.Register;
scanner.Get(out sym);
switch (mne)
{
case Mnemonic.NOT:
codegen.PutF1(Mnemonic.XOR, r, r, -1);
break;
case Mnemonic.CLR:
codegen.PutF1(Mnemonic.MOV, r, Register.R0, 0);
break;
case Mnemonic.RDH:
codegen.PutF0(Mnemonic.RDH, r, Register.R0, Register.R0);
break;
case Mnemonic.RDF:
codegen.PutF0(Mnemonic.RDF, r, Register.R0, Register.R0);
break;
case Mnemonic.INC:
codegen.PutF1(Mnemonic.ADD, r, r, 1);
break;
case Mnemonic.DEC:
codegen.PutF1(Mnemonic.SUB, r, r, 1);
break;
}
}
private void LoadHandcraftedData(string filename)
{
//AsmDudeToolsStatic.Output_INFO("MnemonicStore:load_data_intel: filename=" + filename);
try
{
System.IO.StreamReader file = new System.IO.StreamReader(filename);
string line;
while ((line = file.ReadLine()) != null)
{
if ((line.Length > 0) && (!line.StartsWith(";")))
{
string[] columns = line.Split('\t');
if (columns.Length == 4)
{ // general description
#region
Mnemonic mnemonic = AsmSourceTools.ParseMnemonic(columns[1]);
if (mnemonic == Mnemonic.NONE)
{
AsmDudeToolsStatic.Output_WARNING("MnemonicStore:loadHandcraftedData: unknown mnemonic in line" + line);
}
else
{
if (this._description.ContainsKey(mnemonic))
{
this._description.Remove(mnemonic);
}
this._description.Add(mnemonic, columns[2]);
if (this._htmlRef.ContainsKey(mnemonic))
{
this._htmlRef.Remove(mnemonic);
}
this._htmlRef.Add(mnemonic, columns[3]);
}
#endregion
}
else if ((columns.Length == 5) || (columns.Length == 6))
{ // signature description, ignore an old sixth column
#region
Mnemonic mnemonic = AsmSourceTools.ParseMnemonic(columns[0]);
if (mnemonic == Mnemonic.NONE)
{
AsmDudeToolsStatic.Output_WARNING("MnemonicStore:loadHandcraftedData: unknown mnemonic in line" + line);
}
else
{
AsmSignatureElement se = new AsmSignatureElement(mnemonic, columns[1], columns[2], columns[3], columns[4]);
this.Add(se);
}
#endregion
}
else
{
AsmDudeToolsStatic.Output_WARNING("MnemonicStore:loadHandcraftedData: s.Length=" + columns.Length + "; funky line" + line);
}
}
}
file.Close();
#region Fill Arch
foreach (KeyValuePair <Mnemonic, IList <AsmSignatureElement> > pair in this._data)
{
ISet <Arch> archs = new HashSet <Arch>();
foreach (AsmSignatureElement signatureElement in pair.Value)
{
foreach (Arch arch in signatureElement.Arch)
{
archs.Add(arch);
}
}
IList <Arch> list = new List <Arch>();
foreach (Arch a in archs)
{
list.Add(a);
}
this._arch[pair.Key] = list;
}
#endregion
}
catch (FileNotFoundException)
{
AsmDudeToolsStatic.Output_ERROR("MnemonicStore:LoadHandcraftedData: could not find file \"" + filename + "\".");
}
catch (Exception e)
{
AsmDudeToolsStatic.Output_ERROR("MnemonicStore:LoadHandcraftedData: error while reading file \"" + filename + "\"." + e);
}
}
public override void Render(MachineInstructionWriter writer, MachineInstructionWriterOptions options)
{
writer.WriteMnemonic(Mnemonic.ToString());
}
public bool HasElement(Mnemonic mnemonic)
{
return(this._data.ContainsKey(mnemonic));
}
public PICInstructionImmedShort(Mnemonic mnemonic, short imm)
: base(mnemonic,
new PICOperandImmediate(imm, PrimitiveType.Int16))
{
}
public IEnumerable <AsmSignatureElement> GetSignatures(Mnemonic mnemonic)
{
return((this._data.TryGetValue(mnemonic, out var list)) ? list : Enumerable.Empty <AsmSignatureElement>());
}
public PICInstructionMem2Mem(Mnemonic mnemonic, uint srcaddr, uint dstaddr)
: base(mnemonic,
new PICOperandDataMemoryAddress(srcaddr),
new PICOperandDataMemoryAddress(dstaddr))
{
}
public IEnumerable <Arch> GetArch(Mnemonic mnemonic)
{
return((this._arch.TryGetValue(mnemonic, out var value)) ? value : Enumerable.Empty <Arch>());
}
public PICInstructionMem2Mem(Mnemonic mnemonic, byte srcidx, byte dstidx)
: base(mnemonic,
new PICOperandFSRIndexation(Constant.Byte(srcidx)),
new PICOperandFSRIndexation(Constant.Byte(dstidx)))
{
}
public TargetRel9Decoder(Mnemonic mnemonic)
{
this.mnemonic = mnemonic;
}
public PICInstructionMemFB(Mnemonic mnemonic, ushort memaddr, byte bitno)
: base(mnemonic, new PICOperandBankedMemory(memaddr), new PICOperandMemBitNo(bitno))
{
}
public static Instruction Find(Mnemonic mnemonic, IEnumerable<Argument> arguments)
{
var operands = arguments.Select(argument => argument.Operands.ToArray()).ToArray();
loading.Wait();
return instructions[mnemonic].FirstOrDefault(instruction => CheckOperands(instruction, operands));
}
public MemoryByteWDestDecoder(Mnemonic mnemonic)
{
this.mnemonic = mnemonic;
}
void GetInstructionTypeR(Mnemonic mne)
{
Register d, s1, s2;
int imm;
Symbol refsym;
scanner.Get(out sym);
if (sym != Token.Register)
{
scanner.Mark(ErrorType.RegisterExpected);
return;
}
d = scanner.Register;
scanner.Get(out sym);
if (sym != Token.Comma)
{
scanner.Mark(ErrorType.CommaExpected);
return;
}
scanner.Get(out sym);
if (sym != Token.Register)
{
scanner.Mark(ErrorType.RegisterExpected);
return;
}
s1 = scanner.Register;
scanner.Get(out sym);
if (sym != Token.Comma)
{
scanner.Mark(ErrorType.CommaExpected);
return;
}
scanner.Get(out sym);
if (sym == Token.Register)
{
if (passnum == 1)
{
codegen.AdvancePC(mne);
return;
}
s2 = scanner.Register;
scanner.Get(out sym);
codegen.PutF0(mne, d, s1, s2);
}
else
{
imm = GetExpression(out refsym);
if (passnum == 1)
{
codegen.AdvancePC(mne, imm);
return;
}
if (refsym != null && codegen.OutputIsRelocatable)
{
scanner.Mark(ErrorType.RelocatableSymbolNotAllowed);
return;
}
codegen.PutF1(mne, d, s1, imm);
}
}
void GetInstructionTypeBranch(Mnemonic mne)
{
int imm;
Symbol refsym;
if (passnum == 1)
{
codegen.AdvancePC(mne);
return;
}
scanner.Get(out sym);
if (sym == Token.Register)
{
Register r = scanner.Register;
codegen.PutF3(mne, r);
}
else
{
imm = GetExpression(out refsym);
if (refsym != null)
{
imm -= (int)codegen.PC + 4;
if (refsym.type == SymbolType.Import)
scanner.Mark(ErrorType.ImportedSymbolNotAllowed);
}
codegen.PutF3off(mne, imm);
}
}
public FSRArithDecoder(Mnemonic mnemonic)
{
this.mnemonic = mnemonic;
}
public string GetHtmlRef(Mnemonic mnemonic)
{
return((this._htmlRef.TryGetValue(mnemonic, out string value)) ? value : "");
}
void GetInstructionTypeMem(Mnemonic mne)
{
Register d, s;
int off;
Symbol refsym;
scanner.Get(out sym);
if (sym != Token.Register)
{
scanner.Mark(ErrorType.RegisterExpected);
return;
}
d = scanner.Register;
scanner.Get(out sym);
if (sym != Token.Comma)
{
scanner.Mark(ErrorType.CommaExpected);
return;
}
scanner.Get(out sym);
if (sym != Token.Register)
{
scanner.Mark(ErrorType.RegisterExpected);
return;
}
s = scanner.Register;
scanner.Get(out sym);
if (sym != Token.Comma)
{
scanner.Mark(ErrorType.CommaExpected);
return;
}
scanner.Get(out sym);
off = GetExpression(out refsym);
if (passnum == 1)
{
codegen.AdvancePC(mne, off);
return;
}
if (refsym != null && codegen.OutputIsRelocatable)
scanner.Mark(ErrorType.RelocatableSymbolNotAllowed);
codegen.PutF2(mne, d, s, off);
}
void GetInstructionTypeCall(Mnemonic mne)
{
int imm;
Symbol refsym;
if (passnum == 1)
{
codegen.AdvancePC(mne);
return;
}
scanner.Get(out sym);
if (sym == Token.Register)
{
Register r = scanner.Register;
codegen.PutF3(mne, r);
}
else
{
imm = GetExpression(out refsym);
if (refsym != null)
{
imm -= (int)codegen.PC;
}
codegen.PutF3off(mne, imm, refsym);
}
}
public void SetHtmlRef(Mnemonic mnemonic, string value)
{
this._htmlRef[mnemonic] = value;
}
void GetInstructionTypeMov(Mnemonic mne)
{
Register d, s;
int imm;
Symbol refsym;
scanner.Get(out sym);
if (sym != Token.Register)
{
scanner.Mark(ErrorType.RegisterExpected);
return;
}
d = scanner.Register;
scanner.Get(out sym);
if (sym != Token.Comma)
{
scanner.Mark(ErrorType.CommaExpected);
return;
}
scanner.Get(out sym);
if (sym == Token.Register)
{
if (mne != Mnemonic.MOV)
{
scanner.Mark(ErrorType.RegisterExpected);
return;
}
if (passnum == 1)
{
codegen.AdvancePC(mne);
return;
}
s = scanner.Register;
scanner.Get(out sym);
codegen.PutF0(Mnemonic.MOV, d, Register.R0, s);
}
else
{
if (mne == Mnemonic.MOVA && !codegen.OutputIsRelocatable)
mne = Mnemonic.MOV;
imm = GetExpression(out refsym);
if (passnum == 1)
{
codegen.AdvancePC(mne, imm);
return;
}
if (mne == Mnemonic.MOVA)
{
codegen.PutMOVA(d, imm, refsym);
}
else
{
codegen.PutF1(mne, d, Register.R0, imm);
if (refsym != null && codegen.OutputIsRelocatable)
scanner.Mark(ErrorType.RelocatableSymbolNotAllowed);
}
}
}
public string GetDescription(Mnemonic mnemonic)
{
return((this._description.TryGetValue(mnemonic, out string value)) ? value : "");
}
void GetInstructionTypeSpecial0(Mnemonic mne)
{
if (passnum == 1)
{
codegen.AdvancePC(mne);
return;
}
scanner.Get(out sym);
switch (mne)
{
case Mnemonic.RET:
codegen.PutF3(Mnemonic.BRA, Register.LNK);
break;
case Mnemonic.NOP:
codegen.PutF0(Mnemonic.MOV, Register.R0, Register.R0, Register.R0);
break;
}
}
public InstructionDecoder(InstrClass iclass, Mnemonic mnemonic, params Mutator <M6809Disassembler> [] mutators)
{
this.iclass = iclass;
this.mnemonic = mnemonic;
this.mutators = mutators;
}
public PICInstructionNoOpnd(Mnemonic mnemonic) : base(mnemonic)
{
}
/// <summary>
/// begin wong's
/// </summary>
private void ToAsmCode()
{
int _imm = 0;
this.mnemonic = getMnemonic();
switch (this.mnemonic)
{
case Mnemonic.ADD:
case Mnemonic.ADDU:
case Mnemonic.SUB:
case Mnemonic.SUBU:
case Mnemonic.AND:
case Mnemonic.OR:
case Mnemonic.XOR:
case Mnemonic.NOR:
case Mnemonic.SLT:
case Mnemonic.SLTU:
case Mnemonic.SLL:
case Mnemonic.SRL:
case Mnemonic.SRA:
case Mnemonic.SLLV:
case Mnemonic.SRLV:
case Mnemonic.SRAV:
this.arg1 = getRd();
this.arg2 = getRs();
this.arg3 = getRt();
break;
case Mnemonic.JR:
case Mnemonic.JALR:
this.arg1 = getRs();
break;
case Mnemonic.ADDI:
case Mnemonic.ADDIU:
this.arg1 = getRt();
this.arg2 = getRs();
_imm = getImm();
if (_imm < 32768)
{
this.arg3 = Convert.ToString(_imm);
}
else
{
this.arg3 = Convert.ToString(_imm-65536);
}
break;
case Mnemonic.ANDI:
case Mnemonic.ORI:
case Mnemonic.XORI:
this.arg1 = getRt();
this.arg2 = getRs();
this.arg3 = Convert.ToString(getImm());
break;
case Mnemonic.LUI:
this.arg1 = getRt();
_imm = getImm();
if (_imm < 32768)
{
this.arg2 = Convert.ToString(_imm);
}
else
{
this.arg2 = Convert.ToString(_imm-65536);
}
break;
case Mnemonic.SLTI:
case Mnemonic.SLTIU:
this.arg1 = getRt();
this.arg2 = getRs();
_imm = getImm();
if (_imm < 32768)
{
this.arg3 = Convert.ToString(_imm);
}
else
{
this.arg3 = Convert.ToString(_imm-65536);
}
break;
case Mnemonic.LW:
case Mnemonic.SW:
case Mnemonic.LB:
case Mnemonic.LBU:
case Mnemonic.LH:
case Mnemonic.LHU:
case Mnemonic.SB:
case Mnemonic.SH:
this.arg1 = getRt();
this.arg2 = getRs();
_imm = getImm();
if (_imm < 32768)
{
this.arg3 = Convert.ToString(_imm);
}
else
{
this.arg3 = Convert.ToString(_imm-65536);
}
break;
case Mnemonic.BEQ:
case Mnemonic.BNE:
this.arg1 = getRt();
this.arg2 = getRs();
_imm = getImm();
if (_imm < 32768)
{
this.arg3 = Convert.ToString(_imm);
}
else
{
this.arg3 = Convert.ToString(_imm-65536);
}
break;
/* case Mnemonic.BGEZ:
case Mnemonic.BGEZAL:
case Mnemonic.BGTZ:
case Mnemonic.BLEZ:
case Mnemonic.BLTZ:
case Mnemonic.BLTZAL:
mnemonicString = mnemonicString + this.mnemonic.ToString() + " ";
mnemonicString = mnemonicString + this.arg1;
mnemonicString = mnemonicString + "," + this.arg2;
break;*/
case Mnemonic.J:
case Mnemonic.JAL:
int _address = getAdress();
if (_imm < 33554432)
{
this.arg1 = Convert.ToString(address);
}
else
{
this.arg1 = Convert.ToString(address-67108864);
}
break;
default:
break;
}
//arg3 = getRd();
//private int address;
}
