diff --git a/.gitignore b/.gitignore index f940269..02bdb0a 100644 --- a/.gitignore +++ b/.gitignore @@ -352,3 +352,4 @@ MigrationBackup/ # custom hasmer ignore **/launchSettings.json /hasmer/docs +.netcoredbg_hist diff --git a/hasmer/README.md b/hasmer/README.md index 46bd46e..b881daa 100644 --- a/hasmer/README.md +++ b/hasmer/README.md @@ -1,6 +1,6 @@ # hasmer -This directory contains the C# source code for `hasmer`, using the .NET 5.0 platform. +This directory contains the C# source code for `hasmer`, using the .NET 8.0 platform. # Setup @@ -16,7 +16,7 @@ dotnet build ``` Ensure you run the above command with the current working directory being the one containing the `hasmer.sln` file. -Building with the .NET SDK CLI will generate the executable in the `.hasmer-cli/bin/Debug/net5.0` directory. You can make a release build using: +Building with the .NET SDK CLI will generate the executable in the `.hasmer-cli/bin/Debug/net8.0` directory. You can make a release build using: ``` dotnet build -c Release ``` diff --git a/hasmer/hasmer-cli/Program.cs b/hasmer/hasmer-cli/Program.cs index 407c30b..11c77a3 100644 --- a/hasmer/hasmer-cli/Program.cs +++ b/hasmer/hasmer-cli/Program.cs @@ -19,7 +19,7 @@ public class DecodeOptions { public bool IsApk { get; set; } } - [Verb("disassemble", HelpText = "Disassembles the bytecode into a Hasm file.")] + [Verb("disassemble", HelpText = "Disassembles Hermes bytecode into a Hasm file.")] public class DisassembleOptions : DecodeOptions { [Option("exact", Required = false, HelpText = "Disassembles the exact instructions instead of optimizing them at assemble time.")] public bool IsExact { get; set; } @@ -28,7 +28,7 @@ public class DisassembleOptions : DecodeOptions { public bool IsVerbose { get; set; } } - [Verb("decompile", HelpText = "Decompiles the bytecode into a JavaScript file.")] + [Verb("decompile", HelpText = "Decompiles Hermes bytecode into a JavaScript file.")] public class DecompileOptions : DecodeOptions { [Option('p', "omit-protoype", Required = false, HelpText = "Omit prototypes being passed to constructors.", Default = true)] public bool OmitPrototypeFromConstructorInvocation { get; set; } @@ -89,7 +89,7 @@ private static void Assemble(AssembleOptions options) { } string fileName = Path.GetFileName(options.InputPath); if (fileName.Contains(".")) { - fileName = fileName.Substring(0, fileName.IndexOf('.')); + fileName = fileName.Substring(0, fileName.LastIndexOf('.')); } string outputDirectory = Path.GetDirectoryName(options.InputPath); @@ -110,7 +110,7 @@ private static DecoderParameters Decode(DecodeOptions options) { string fileName = Path.GetFileName(options.InputPath); if (fileName.Contains(".")) { - fileName = fileName.Substring(0, fileName.IndexOf('.')); + fileName = fileName.Substring(0, fileName.LastIndexOf('.')); } string outputDirectory = Path.GetDirectoryName(options.InputPath); byte[] hermesBytecode; @@ -121,7 +121,8 @@ private static DecoderParameters Decode(DecodeOptions options) { using MemoryStream fileStream = new MemoryStream((int)bundleEntry.UncompressedSize); bundleEntry.Extract(fileStream); hermesBytecode = fileStream.ToArray(); - } else { + } + else { hermesBytecode = File.ReadAllBytes(options.InputPath); } diff --git a/hasmer/hasmer-cli/hasmer-cli.csproj b/hasmer/hasmer-cli/hasmer-cli.csproj index d3ad3e8..7806152 100644 --- a/hasmer/hasmer-cli/hasmer-cli.csproj +++ b/hasmer/hasmer-cli/hasmer-cli.csproj @@ -2,9 +2,10 @@ Exe - net5.0 + net8.0 Hasmer.CLI hasmer + true diff --git a/hasmer/hasmer-lsp/hasmer-lsp.csproj b/hasmer/hasmer-lsp/hasmer-lsp.csproj index 91b4522..47cb45f 100644 --- a/hasmer/hasmer-lsp/hasmer-lsp.csproj +++ b/hasmer/hasmer-lsp/hasmer-lsp.csproj @@ -2,11 +2,12 @@ Exe - net5.0 + net8.0 Hasmer.LSP + > diff --git a/hasmer/libhasmer/Assembler/DataDisassembler.cs b/hasmer/libhasmer/Assembler/DataDisassembler.cs index d8363ef..4244ee6 100644 --- a/hasmer/libhasmer/Assembler/DataDisassembler.cs +++ b/hasmer/libhasmer/Assembler/DataDisassembler.cs @@ -74,9 +74,18 @@ public PrimitiveValue[] GetElementSeries(List buffer, uint o private void AppendDisassembly(StringBuilder builder, List buffer, char prefix) { for (int i = 0; i < buffer.Count; i++) { HbcDataBufferItems items = buffer[i]; + switch (items.Prefix.TagType) { + case HbcDataBufferTagType.Null: + case HbcDataBufferTagType.True: + case HbcDataBufferTagType.False: + builder.AppendLine($".data {prefix}{i} {items.Prefix.TagType}[{items.Items.Length}]"); + continue; + default: + break; + } IEnumerable mapped = items.Items.Select(x => { if (x.TypeCode == TypeCode.String) { - x.SetValue('"' + x.GetValue().Replace("\"", "\\\"") + '"'); + x.SetValue(StringEscape.Escape(x.GetValue())); } return x; }); @@ -85,7 +94,7 @@ private void AppendDisassembly(StringBuilder builder, List b _ => items.Prefix.TagType.ToString() }; string joined = string.Join(", ", mapped); - builder.AppendLine($".data {prefix}{i} {tagType}[{joined}] # offset = {items.Offset}"); + builder.AppendLine($".data {prefix}{i} {tagType}[] {{ {joined} }}"); } if (buffer.Count > 0) { builder.AppendLine(); @@ -93,8 +102,11 @@ private void AppendDisassembly(StringBuilder builder, List b } public void DisassembleData() { + Console.WriteLine("Parsing array buffer..."); ArrayBuffer = Source.ArrayBuffer.ReadAll(Source); + Console.WriteLine("Parsing object key buffer..."); KeyBuffer = Source.ObjectKeyBuffer.ReadAll(Source); + Console.WriteLine("Parsing object value buffer..."); ValueBuffer = Source.ObjectValueBuffer.ReadAll(Source); } diff --git a/hasmer/libhasmer/Assembler/FunctionDisassembler.cs b/hasmer/libhasmer/Assembler/FunctionDisassembler.cs index 07ed82b..67155c6 100644 --- a/hasmer/libhasmer/Assembler/FunctionDisassembler.cs +++ b/hasmer/libhasmer/Assembler/FunctionDisassembler.cs @@ -178,7 +178,7 @@ private string AnnotateObject(uint keyBufferIndex, uint valueBufferIndex, ushort /// Adds a comment to an instruction if neccessary. /// private void AnnotateVerbose(SourceCodeBuilder builder, HbcInstruction insn) { - builder.Write("# offset = 0x"); + builder.Write("// offset = 0x"); builder.Write(insn.Offset.ToString("X")); builder.Write(", length = "); builder.Write(insn.Length.ToString()); @@ -205,7 +205,7 @@ private void AnnotateInstruction(SourceCodeBuilder builder, HbcInstruction insn) }; if (annotation != null) { - builder.Write("# "); + builder.Write("// "); builder.Write(annotation); } } diff --git a/hasmer/libhasmer/Assembler/HbcAssembler.cs b/hasmer/libhasmer/Assembler/HbcAssembler.cs index 47e055a..7cf8ec1 100644 --- a/hasmer/libhasmer/Assembler/HbcAssembler.cs +++ b/hasmer/libhasmer/Assembler/HbcAssembler.cs @@ -12,16 +12,6 @@ namespace Hasmer.Assembler { /// Represents a Hasm assembler, which assembles into Hermes bytecode. /// public class HbcAssembler { - /// - /// Represents the data contained with in the header of the Hasm file (i.e. the initial ".hasm" declaration)./ - /// - public HasmHeaderReader Header { get; set; } - - /// - /// The file builder instance which creates the final to be serialized. - /// - public HbcFileBuilder FileBuilder { get; set; } - /// /// The data assembler instance. /// @@ -32,6 +22,13 @@ public class HbcAssembler { /// public FunctionAssembler FunctionAssembler { get; set; } + /// + /// The Hermes bytecode file being assembled. + /// + public HbcFile File { get; set; } + + public bool IsExact { get; set; } + /// /// The Hasm assembly to disassemble. /// @@ -48,21 +45,41 @@ public HbcAssembler(string source) { /// Assembles the given Hasm assembly into a Hermes bytecode file, serialized into a byte array. /// public byte[] Assemble() { - HasmTokenStream stream = new HasmTokenStream(Source); + Console.WriteLine("Parsing Hasm file..."); + HasmTokenizer tokenizer = new HasmTokenizer(); + tokenizer.TokenizeProgram(Source); + + // List tokens = null; + + // IsExact = tokenStream.State.IsExact; + // File = new HbcFile { + // Header = new HbcHeader { + // Magic = HbcHeader.HBC_MAGIC_HEADER, + // Version = tokenStream.State.BytecodeFormat.Version, + // SourceHash = new byte[20], + // GlobalCodeIndex = 0, + // Padding = new byte[31], + // }, + // BytecodeFormat = tokenStream.State.BytecodeFormat, + // }; - Header = new HasmHeaderReader(stream); - Header.Read(); + // Console.WriteLine("Assembling data..."); + // DataAssembler = new DataAssembler(tokens); + // DataAssembler.Assemble(); - FileBuilder = new HbcFileBuilder(this); + // Console.WriteLine("Assembling functions..."); + // FunctionAssembler = new FunctionAssembler(this, tokens); + // FunctionAssembler.Assemble(); - DataAssembler = new DataAssembler(stream); - DataAssembler.Assemble(); + // Console.WriteLine("Assembling Hermes bytecode file..."); + // File.StringTable = DataAssembler.StringTable.ToArray(); + // File.ArrayBuffer = new HbcDataBuffer(DataAssembler.ArrayBuffer.RawBuffer.ToArray()); + // File.ObjectKeyBuffer = new HbcDataBuffer(DataAssembler.ObjectKeyBuffer.RawBuffer.ToArray()); + // File.ObjectValueBuffer = new HbcDataBuffer(DataAssembler.ObjectValueBuffer.RawBuffer.ToArray()); - FunctionAssembler = new FunctionAssembler(this, stream); - FunctionAssembler.Assemble(); + // return File.Write(); - HbcFile hbcFile = FileBuilder.Build(); - return hbcFile.Write(); + return new byte[0]; } } } diff --git a/hasmer/libhasmer/Assembler/HbcDisassembler.cs b/hasmer/libhasmer/Assembler/HbcDisassembler.cs index 4f2a847..5755ae6 100644 --- a/hasmer/libhasmer/Assembler/HbcDisassembler.cs +++ b/hasmer/libhasmer/Assembler/HbcDisassembler.cs @@ -50,11 +50,18 @@ public string Disassemble() { builder.AppendLine(); builder.AppendLine(DataDisassembler.Disassemble()); - foreach (HbcSmallFuncHeader func in Source.SmallFuncHeaders) { - FunctionDisassembler decompiler = new FunctionDisassembler(this, func.GetAssemblerHeader()); - builder.AppendLine(decompiler.Disassemble()); - builder.AppendLine(); + Console.Write("Disassembling functions... "); + using (ConsoleProgressBar progress = new ConsoleProgressBar()) { + for (int i = 0; i < Source.SmallFuncHeaders.Length; i++) { + progress.Report(i / (double)Source.SmallFuncHeaders.Length); + + HbcSmallFuncHeader func = Source.SmallFuncHeaders[i]; + FunctionDisassembler decompiler = new FunctionDisassembler(this, func.GetAssemblerHeader()); + builder.AppendLine(decompiler.Disassemble()); + builder.AppendLine(); + } } + Console.WriteLine("done!"); return builder.ToString(); } diff --git a/hasmer/libhasmer/Assembler/Parser/HasmCommentParser.cs b/hasmer/libhasmer/Assembler/Parser/HasmCommentParser.cs index 67c881c..b2a537a 100644 --- a/hasmer/libhasmer/Assembler/Parser/HasmCommentParser.cs +++ b/hasmer/libhasmer/Assembler/Parser/HasmCommentParser.cs @@ -6,11 +6,11 @@ namespace Hasmer.Assembler.Parser { /// - /// Parses a comment (starting with a '#') from the stream. + /// Parses a comment (starting with a '//') from the stream. /// public class HasmCommentParser : IHasmTokenParser { public bool CanParse(HasmReaderState asm) { - return asm.Stream.PeekCharacters(1) == "#"; + return asm.Stream.Peek(2) == "//"; } public HasmToken Parse(HasmReaderState asm) { @@ -18,8 +18,17 @@ public HasmToken Parse(HasmReaderState asm) { throw new HasmParserException(asm.Stream, "invalid comment"); } - asm.Stream.CurrentLine++; - asm.Stream.CurrentColumn = 0; + while (true) { + char c = asm.Stream.PeekChar(); + if (c == '\0') { + break; + } + asm.Stream.Advance(1); + if (c == '\n') { + break; + } + } + if (!asm.Stream.IsFinished) { asm.Stream.SkipWhitespace(); } diff --git a/hasmer/libhasmer/Assembler/Parser/HasmDataDeclaration.cs b/hasmer/libhasmer/Assembler/Parser/HasmDataDeclaration.cs new file mode 100644 index 0000000..dc807b1 --- /dev/null +++ b/hasmer/libhasmer/Assembler/Parser/HasmDataDeclaration.cs @@ -0,0 +1,43 @@ +using System.Collections.Generic; + +namespace Hasmer.Assembler.Parser { + /// + /// The kind of data being declared in a ".data" declaration. + /// + [Newtonsoft.Json.JsonConverter(typeof(Newtonsoft.Json.Converters.StringEnumConverter))] + public enum HasmDataDeclarationKind { + String, + Integer, + Number, + Null, + True, + False + } + + /// + /// Represents a ".data" declaration. + /// + public class HasmDataDeclaration { + /// + /// The label of the data. + /// + public HasmLabelToken Label { get; set; } + + /// + /// The kind of the data. + /// + public HasmDataDeclarationKind Kind { get; set; } + + /// + /// The amount of distinct items in the data declaration. + /// In declarations where there are specific elements, this is equal to . + /// In declarations where elements are repeated (i.e. Null, True, or False), this is equal to the supplied repeat count. + /// + public int Count { get; set; } + + /// + /// The tokens that define the contents of the data, if there are specific elements. + /// + public List Elements { get; set; } + } +} diff --git a/hasmer/libhasmer/Assembler/Parser/HasmDeclarationParser.cs.old b/hasmer/libhasmer/Assembler/Parser/HasmDeclarationParser.cs.old new file mode 100644 index 0000000..d6df2af --- /dev/null +++ b/hasmer/libhasmer/Assembler/Parser/HasmDeclarationParser.cs.old @@ -0,0 +1,193 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Hasmer.Assembler.Parser { + /// + /// Represents a ".hasm" header declaration, the first token of a Hasm file. + /// + public class HasmHeaderDeclarationToken : HasmToken { + /// + /// The token which declares the version of the Hasm bytecode. + /// + public HasmIntegerToken Version { get; set; } + + /// + /// True if the version declaration specified that the instructions should be interpretered literally, + /// and not as abstracted forms. See for more information. + /// + public bool IsExact { get; set; } + + public HasmHeaderDeclarationToken(int state) : base(state) { } + } + + /// + /// Parses a declaration (i.e. a token which starts with "."). + /// + public class HasmDeclarationParser : IHasmTokenParser { + public bool CanParse(HasmReaderState asm) { + string op = asm.Stream.PeekOperator(); + if (op != ".") { + return false; + } + asm.Stream.AdvanceOperator(); + + string word = asm.Stream.PeekWord(); + if (word == null) { + return false; + } + + return word == "hasm" || + word == "data" || + word == "start" || + word == "end" || + word == "id" || + word == "params" || + word == "registers" || + word == "symbols" || + word == "strict" || + word == "label"; + } + + public HasmToken Parse(HasmReaderState asm) { + int state = asm.Stream.SaveState(); + + asm.Stream.AdvanceOperator(); // skip "." before declaration + string word = asm.Stream.AdvanceWord(); + if (word == "hasm") { + HasmIntegerToken version = (HasmIntegerToken)IHasmTokenParser.IntegerParser.Parse(asm); + bool isExact; + if (asm.Stream.PeekWord() == "exact") { + isExact = true; + } else if (asm.Stream.PeekWord() == "auto") { + isExact = false; + } else { + throw new HasmParserException(asm.Stream, "expecting either 'auto' or 'exact' after version declaration"); + } + asm.Stream.AdvanceWord(); + + return new HasmHeaderDeclarationToken(state) { + Version = version, + IsExact = isExact + }; + } else if (word == "data") { + HasmLabelToken label = (HasmLabelToken)IHasmTokenParser.LabelParser.Parse(asm); + string dataTypeRaw = asm.Stream.PeekWord(); + if (dataTypeRaw == null) { + throw new HasmParserException(asm.Stream, "expecting data type"); + } + asm.Stream.AdvanceWord(); + if (!Enum.IsDefined(typeof(HasmDataDeclarationKind), dataTypeRaw)) { + throw new HasmParserException(asm.Stream, $"invalid data type: '{dataTypeRaw}'"); + } + HasmDataDeclarationKind dataType = Enum.Parse(dataTypeRaw); + if (asm.Stream.PeekOperator() != "[") { + throw new HasmParserException(asm.Stream, "expecting '['"); + } + asm.Stream.AdvanceOperator(); + + IHasmTokenParser dataParser = dataType switch { + HasmDataDeclarationKind.String => IHasmTokenParser.StringParser, + HasmDataDeclarationKind.Integer => IHasmTokenParser.IntegerParser, + HasmDataDeclarationKind.Number => IHasmTokenParser.NumberParser, + HasmDataDeclarationKind.Null => new HasmSimpleParser("null"), + HasmDataDeclarationKind.True => new HasmSimpleParser("true"), + HasmDataDeclarationKind.False => new HasmSimpleParser("false"), + _ => throw new NotImplementedException() + }; + + List data = new List(); + while (true) { + data.Add((HasmLiteralToken)dataParser.Parse(asm)); + string peek = asm.Stream.PeekOperator(); + if (peek == "]") { + asm.Stream.AdvanceOperator(); + break; + } + if (peek != ",") { + throw new HasmParserException(asm.Stream, "expecting either ']' or ','"); + } + asm.Stream.AdvanceOperator(); + } + + return new HasmDataDeclarationToken(state) { + Label = label, + DataType = dataType, + Data = data + }; + } else if (word == "start") { + string functionType = asm.Stream.PeekWord(); + if (functionType != "Function" && functionType != "Constructor" && functionType != "NCFunction") { + throw new HasmParserException(asm.Stream, "expecting either 'Function', 'Constructor', or 'NCFunction'"); + } + asm.Stream.AdvanceWord(); + + string functionName; + int preNameState = asm.Stream.SaveState(); + HasmToken identToken = IHasmTokenParser.StringParser.Parse(asm); + if (identToken is HasmIdentifierToken ident) { + functionName = ident.Value; + } else { + throw new HasmParserException(preNameState, "expecting function name identifier"); + } + + // the cursor is currently at the start of the parameters, which we ignore, so skip to the next line + // .start Function (this, foo, bar, baz) + // .id XYZ ^ + // ... + asm.Stream.CurrentLine++; + asm.Stream.CurrentColumn = 0; + + List body = new List(); + HasmFunctionToken function = new HasmFunctionToken(state) { + FunctionName = functionName, + Body = body + }; + asm.CurrentFunction = function; + + HasmTokenStream bodyStream = new HasmTokenStream(asm); + foreach (HasmToken token in bodyStream.ReadTokens()) { + if (token is HasmSimpleToken simple && simple.Value == "end") { + asm.CurrentFunction = null; + break; + } + body.Add(token); + } + + return function; + } else if (word == "end") { + return new HasmSimpleToken(state) { + Value = "end" + }; + } else if (word == "id" || word == "params" || word == "registers" || word == "symbols") { + if (!IHasmTokenParser.IntegerParser.CanParse(asm)) { + throw new HasmParserException(asm.Stream, "expecting value after declaration"); + } + HasmIntegerToken intToken = (HasmIntegerToken)IHasmTokenParser.IntegerParser.Parse(asm); + HasmFunctionModifierType modType = word switch { + "id" => HasmFunctionModifierType.Id, + "params" => HasmFunctionModifierType.Params, + "registers" => HasmFunctionModifierType.Registers, + "symbols" => HasmFunctionModifierType.Symbols, + _ => throw new Exception("unreachable"), + }; + return new HasmFunctionModifierToken(state) { + ModifierType = modType, + Value = intToken.GetValueAsUInt32(), + }; + } else if (word == "strict") { + return new HasmFunctionModifierToken(state) { + ModifierType = HasmFunctionModifierType.Strict + }; + } else if (word == "label") { + // TODO + asm.Stream.AdvanceWord(); + return null; + } + + throw new Exception($"invalid declaration '.{word}'"); + } + } +} diff --git a/hasmer/libhasmer/Assembler/Parser/HasmFunctionModifierToken.cs b/hasmer/libhasmer/Assembler/Parser/HasmFunctionModifierToken.cs new file mode 100644 index 0000000..a28e0ba --- /dev/null +++ b/hasmer/libhasmer/Assembler/Parser/HasmFunctionModifierToken.cs @@ -0,0 +1,31 @@ + +namespace Hasmer.Assembler.Parser { + /// + /// The type of declaration for a function modifier. + /// + public enum HasmFunctionModifierType { + Id, + Params, + Registers, + Symbols, + Strict + } + + /// + /// Represents a declaration that modifiers a function header. + /// + public class HasmFunctionModifierToken : HasmToken { + /// + /// The type of modifier. + /// + public HasmFunctionModifierType ModifierType { get; set; } + + /// + /// The value associated with the modifier, or null if the modifier does not have a value. + /// + public uint? Value { get; set; } + + + public HasmFunctionModifierToken(HasmStringStreamState state) : base(state) { } + } +} diff --git a/hasmer/libhasmer/Assembler/Parser/HasmFunctionToken.cs b/hasmer/libhasmer/Assembler/Parser/HasmFunctionToken.cs index 388d408..4ed1f62 100644 --- a/hasmer/libhasmer/Assembler/Parser/HasmFunctionToken.cs +++ b/hasmer/libhasmer/Assembler/Parser/HasmFunctionToken.cs @@ -12,7 +12,7 @@ public class HasmFunctionToken : HasmToken { /// /// The name of the function. /// - public string FunctionName { get; set; } + public HasmIdentifierToken Name { get; set; } /// /// The tokens in the body of the function. diff --git a/hasmer/libhasmer/Assembler/Parser/HasmHeader.cs b/hasmer/libhasmer/Assembler/Parser/HasmHeader.cs new file mode 100644 index 0000000..eb192e1 --- /dev/null +++ b/hasmer/libhasmer/Assembler/Parser/HasmHeader.cs @@ -0,0 +1,18 @@ + +namespace Hasmer.Assembler.Parser { + /// + /// Represents a ".hasm" header declaration. + /// + public class HasmHeader { + /// + /// The token which declares the version of the Hasm bytecode. + /// + public HasmIntegerToken Version { get; set; } + + /// + /// True if the version declaration specified that the instructions should be interpretered literally, + /// and not as abstracted forms. See for more information. + /// + public bool IsExact { get; set; } + } +} diff --git a/hasmer/libhasmer/Assembler/Parser/HasmInstructionParser.cs.old b/hasmer/libhasmer/Assembler/Parser/HasmInstructionParser.cs.old new file mode 100644 index 0000000..f0f37e7 --- /dev/null +++ b/hasmer/libhasmer/Assembler/Parser/HasmInstructionParser.cs.old @@ -0,0 +1,79 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Hasmer.Assembler.Parser { + /// + /// Represents a Hasm instruction and its operands. + /// + public class HasmInstructionToken : HasmToken { + /// + /// The name of the instruction. + /// + public string Instruction { get; set; } + + /// + /// The operands passed to the instruction. + /// + public List Operands { get; set; } + + public HasmInstructionToken(int state) : base(state) { } + } + + /// + /// Parses a Hasm instruction. + /// + public class HasmInstructionParser : IHasmTokenParser { + public bool CanParse(HasmReaderState asm) { + // throw new NotImplementedException(); + + string instruction = asm.Stream.PeekWord(); + return instruction != null; + } + + public HasmToken Parse(HasmReaderState asm) { + int state = asm.Stream.SaveState(); + string instruction = asm.Stream.AdvanceWord(); + + HbcInstructionDefinition def = asm.BytecodeFormat.Definitions.Find(def => def.Name == instruction); + if (def == null) { + throw new HasmParserException(asm.Stream, $"unknown instruction: '{instruction}'"); + } + + if (!asm.IsExact) { + // any instruction which takes a cache index should have the cache index removed in auto mode + if (def.Name == "GetById" || def.Name == "TryGetById" || def.Name == "PutById" || def.Name == "TryPutById" + || def.Name == "GetByIdShort" || def.Name == "GetByIdLong" || def.Name == "TryGetByIdLong" || def.Name == "PutByIdLong" || def.Name == "TryPutByIdLong") { + List operandTypes = new List(def.OperandTypes); + operandTypes.RemoveAt(2); // remove the cache index + + def = new HbcInstructionDefinition { + Name = def.Name, + AbstractDefinition = def.AbstractDefinition, + IsJump = def.IsJump, + Opcode = def.Opcode, + OperandTypes = operandTypes + }; + } + } + + HasmInstructionToken token = new HasmInstructionToken(state) { + Instruction = instruction, + Operands = new List() + }; + for (int i = 0; i < def.OperandTypes.Count; i++) { + if (token.Operands.Count > 0) { + if (asm.Stream.AdvanceOperator() != ",") { + throw new HasmParserException(asm.Stream, "expecting ','"); + } + } + HasmOperandParser parser = new HasmOperandParser(def, i); + token.Operands.Add((HasmOperandToken)parser.Parse(asm)); + } + + return token; + } + } +} diff --git a/hasmer/libhasmer/Assembler/Parser/HasmInstructionToken.cs b/hasmer/libhasmer/Assembler/Parser/HasmInstructionToken.cs new file mode 100644 index 0000000..a5ee475 --- /dev/null +++ b/hasmer/libhasmer/Assembler/Parser/HasmInstructionToken.cs @@ -0,0 +1,20 @@ +using System.Collections.Generic; + +namespace Hasmer.Assembler.Parser { + /// + /// Represents a Hasm instruction and its operands. + /// + public class HasmInstructionToken : HasmToken { + /// + /// The name of the instruction. + /// + public string Instruction { get; set; } + + /// + /// The operands passed to the instruction. + /// + public List Operands { get; set; } + + public HasmInstructionToken(HasmStringStreamState state) : base(state) { } + } +} diff --git a/hasmer/libhasmer/Assembler/Parser/HasmIntegerParser.cs.old b/hasmer/libhasmer/Assembler/Parser/HasmIntegerParser.cs.old new file mode 100644 index 0000000..6b08a0a --- /dev/null +++ b/hasmer/libhasmer/Assembler/Parser/HasmIntegerParser.cs.old @@ -0,0 +1,45 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Hasmer.Assembler.Parser { + /// + /// Parses an integer. + /// + public class HasmIntegerParser : IHasmTokenParser { + public bool CanParse(HasmReaderState asm) { + int state = asm.Stream.SaveState(); + if (asm.Stream.PeekOperator() == "-") { // negative number + asm.Stream.AdvanceOperator(); + } + + string word = asm.Stream.PeekWord(); + if (word == null) { + asm.Stream.LoadState(state); + return false; + } + + asm.Stream.LoadState(state); + return long.TryParse(word, out long _); + } + + public HasmToken Parse(HasmReaderState asm) { + if (!CanParse(asm)) { + throw new HasmParserException(asm.Stream, "invalid integer"); + } + + int state = asm.Stream.SaveState(); + + int multiplier = 1; + if (asm.Stream.PeekOperator() == "-") { // negative number + asm.Stream.AdvanceOperator(); + multiplier = -1; + } + + string word = asm.Stream.AdvanceWord(); + return new HasmIntegerToken(state, long.Parse(word) * multiplier); + } + } +} diff --git a/hasmer/libhasmer/Assembler/Parser/HasmIntegerToken.cs b/hasmer/libhasmer/Assembler/Parser/HasmIntegerToken.cs new file mode 100644 index 0000000..3c9eb83 --- /dev/null +++ b/hasmer/libhasmer/Assembler/Parser/HasmIntegerToken.cs @@ -0,0 +1,105 @@ + +namespace Hasmer.Assembler.Parser { + /// + /// Represents an integer, either a 4-byte signed integer or a 4-byte unsigned integer specifically. + /// + public class HasmIntegerToken : HasmLiteralToken { + /// + /// The integer value. This is stored a long to be able to handle both int and uint types. + /// + private long Value { get; set; } + + /// + /// Returns a PrimitiveValue whose underlying byte count is equal to the smallest multiple of 2 that can hold . + /// + public PrimitiveValue GetCompactValue(bool signed) { + if (signed) { + if (Value >= sbyte.MinValue && Value <= sbyte.MaxValue) { + return new PrimitiveValue((sbyte)Value); + } else if (Value >= short.MinValue && Value <= short.MaxValue) { + return new PrimitiveValue((short)Value); + } else if (Value >= int.MinValue && Value <= int.MaxValue) { + return new PrimitiveValue((int)Value); + } + } else { + if (Value >= byte.MinValue && Value <= byte.MaxValue) { + return new PrimitiveValue((byte)Value); + } else if (Value >= ushort.MinValue && Value <= ushort.MaxValue) { + return new PrimitiveValue((ushort)Value); + } else if (Value >= uint.MinValue && Value <= uint.MaxValue) { + return new PrimitiveValue((uint)Value); + } + } + + throw new HasmParserException(this, $"Value is too large to store in a PrimitiveValue: {Value}"); + } + + /// + /// Returns a PrimitiveValue containing as an integer of width. + /// If cannot be represented in bytes, an exception is thrown. + /// + public PrimitiveValue GetValue(bool signed, int size) { + if (signed) { + if (size == 1) { + if (Value < sbyte.MinValue || Value > sbyte.MaxValue) { + throw new HasmParserException(this, $"integer is not sbyte: {Value}"); + } + return new PrimitiveValue((sbyte)Value); + } else if (size == 2) { + if (Value < short.MinValue || Value > short.MaxValue) { + throw new HasmParserException(this, $"integer is not short: {Value}"); + } + return new PrimitiveValue((short)Value); + } else if (size == 4) { + if (Value < int.MinValue || Value > int.MaxValue) { + throw new HasmParserException(this, $"integer is not int: {Value}"); + } + return new PrimitiveValue((int)Value); + } + } else { + if (size == 1) { + if (Value < byte.MinValue || Value > byte.MaxValue) { + throw new HasmParserException(this, $"integer is not byte: {Value}"); + } + return new PrimitiveValue((byte)Value); + } else if (size == 2) { + if (Value < ushort.MinValue || Value > ushort.MaxValue) { + throw new HasmParserException(this, $"integer is not ushort: {Value}"); + } + return new PrimitiveValue((ushort)Value); + } else if (size == 4) { + if (Value < uint.MinValue || Value > uint.MaxValue) { + throw new HasmParserException(this, $"integer is not int: {Value}"); + } + return new PrimitiveValue((uint)Value); + } + } + + throw new HasmParserException(this, $"invalid integer size: {size}"); + } + + /// + /// Returns the value as a 4-byte unsigned integer; throws an exception if the value is not in bounds. + /// + public uint GetValueAsUInt32() { + if (Value < uint.MinValue || Value > uint.MaxValue) { + throw new HasmParserException(this, $"integer is not uint: {Value}"); + } + return (uint)Value; + } + + /// + /// Returns the value as a 4-byte signed integer; throws an exception if the value is not in bounds. + /// + public int GetValueAsInt32() { + if (Value < int.MinValue || Value > int.MaxValue) { + throw new HasmParserException(this, $"integer is not int: {Value}"); + } + return (int)Value; + } + + public HasmIntegerToken(HasmStringStreamState state, long value) : base(state) { + Value = value; + } + } +} diff --git a/hasmer/libhasmer/Assembler/Parser/HasmLabelToken.cs b/hasmer/libhasmer/Assembler/Parser/HasmLabelToken.cs new file mode 100644 index 0000000..a2a2c15 --- /dev/null +++ b/hasmer/libhasmer/Assembler/Parser/HasmLabelToken.cs @@ -0,0 +1,46 @@ +namespace Hasmer.Assembler.Parser { + /// + /// Represents the type of a Hasm label. + /// + [Newtonsoft.Json.JsonConverter(typeof(Newtonsoft.Json.Converters.StringEnumConverter))] + public enum HasmLabelKind { + /// + /// A reference or declaration in the array buffer. + /// + ArrayBuffer = 'A', + /// + /// A reference or declaration in the object key buffer. + /// + ObjectKeyBuffer = 'K', + /// + /// A reference or declaration in the object value buffer. + /// + ObjectValueBuffer = 'V', + /// + /// A reference or declaration of an offset of code in a function's body, used for jump instructions. + /// + CodeLabel = 'L' + } + + /// + /// Represents a label definition or reference. + /// + public class HasmLabelToken : HasmToken { + /// + /// The type of the label, e.g. label = "L5", LabelType = 'L' + /// + public HasmLabelKind Kind { get; set; } + + /// + /// The index of the label, e.g. label = "L5", LabelIndex = 5 + /// + public HasmIntegerToken Index { get; set; } + + /// + /// The offset after the label, used in label references. Example: label reference = "L5-6", Offset = -6 + /// + public HasmIntegerToken ReferenceOffset { get; set; } + + public HasmLabelToken(HasmStringStreamState state) : base(state) { } + } +} diff --git a/hasmer/libhasmer/Assembler/Parser/HasmNumberToken.cs b/hasmer/libhasmer/Assembler/Parser/HasmNumberToken.cs new file mode 100644 index 0000000..3b85978 --- /dev/null +++ b/hasmer/libhasmer/Assembler/Parser/HasmNumberToken.cs @@ -0,0 +1,21 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Hasmer.Assembler.Parser { + /// + /// Represents an 8-byte IEEE754 floating-point value. + /// + /// This is directly equivalent to the "number" type in JavaScript. + /// + public class HasmNumberToken : HasmLiteralToken { + /// + /// The parsed value. + /// + public double Value { get; set; } + + public HasmNumberToken(HasmStringStreamState state) : base(state) { } + } +} diff --git a/hasmer/libhasmer/Assembler/Parser/HasmOperandParser.cs.old b/hasmer/libhasmer/Assembler/Parser/HasmOperandParser.cs.old new file mode 100644 index 0000000..ed2d8c2 --- /dev/null +++ b/hasmer/libhasmer/Assembler/Parser/HasmOperandParser.cs.old @@ -0,0 +1,88 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Hasmer.Assembler.Parser { + /// + /// Parses a Hasm instruction's operand. + /// + public class HasmOperandParser : IHasmTokenParser { + private HbcInstructionDefinition Instruction; + private int OperandIndex; + private HbcInstructionOperandType Type => Instruction.OperandTypes[OperandIndex]; + + public HasmOperandParser(HbcInstructionDefinition insn, int operand) { + Instruction = insn; + OperandIndex = operand; + } + + public bool CanParse(HasmReaderState asm) { + throw new NotImplementedException(); + } + + public HasmToken Parse(HasmReaderState asm) { + int state = asm.Stream.SaveState(); + if (Type == HbcInstructionOperandType.Reg8 || Type == HbcInstructionOperandType.Reg32) { + string reg = asm.Stream.PeekWord(); + if (reg == null || !reg.StartsWith("r") || reg.Length < 2) { + throw new HasmParserException(asm.Stream, "expecting register"); + } + if (!long.TryParse(reg.Substring(1), out long regIndex)) { + throw new HasmParserException(asm.Stream, "invalid register format"); + } + asm.Stream.AdvanceWord(); + + HasmIntegerToken token = new HasmIntegerToken(state, regIndex); + return new HasmOperandToken(state) { + OperandType = HasmOperandTokenType.Register, + Value = asm.IsExact ? token.GetValue(false, Type.GetSizeof()) : token.GetCompactValue(false), + }; + } else if (Type == HbcInstructionOperandType.Addr8 || Type == HbcInstructionOperandType.Addr32) { + HasmLabelToken labelToken = (HasmLabelToken)IHasmTokenParser.LabelParser.Parse(asm); + return new HasmOperandToken(state) { + OperandType = HasmOperandTokenType.Label, + Value = asm.IsExact ? labelToken.LabelIndex.GetValue(true, Type.GetSizeof()) : labelToken.LabelIndex.GetCompactValue(true), + }; + } else if (Type == HbcInstructionOperandType.UInt8 || Type == HbcInstructionOperandType.UInt16 || Type == HbcInstructionOperandType.UInt32 || Type == HbcInstructionOperandType.Imm32) { + if (OperandIndex == 3 && (Instruction.Name == "NewArrayWithBuffer" || Instruction.Name == "NewArrayWithBufferLong")) { + HasmLabelToken labelToken = (HasmLabelToken)IHasmTokenParser.LabelParser.Parse(asm); + return new HasmOperandToken(state) { + OperandType = HasmOperandTokenType.Label, + Value = asm.IsExact ? labelToken.LabelIndex.GetValue(false, Type.GetSizeof()) : labelToken.LabelIndex.GetCompactValue(false), + }; + } + + HasmIntegerToken intToken = (HasmIntegerToken)IHasmTokenParser.IntegerParser.Parse(asm); + return new HasmOperandToken(state) { + OperandType = HasmOperandTokenType.UInt, + Value = asm.IsExact ? intToken.GetValue(false, Type.GetSizeof()) : intToken.GetCompactValue(false), + }; + } else if (Type == HbcInstructionOperandType.UInt8S || Type == HbcInstructionOperandType.UInt16S || Type == HbcInstructionOperandType.UInt32S) { + HasmToken token = IHasmTokenParser.StringParser.Parse(asm); + if (token is HasmStringToken s) { + return new HasmOperandToken(state) { + OperandType = HasmOperandTokenType.String, + Value = new PrimitiveValue(s.Value), + }; + } else if (token is HasmIdentifierToken i) { + return new HasmOperandToken(state) { + OperandType = HasmOperandTokenType.Identifier, + Value = new PrimitiveValue(i.Value), + }; + } else { + throw new Exception($"expecting a string literal or identifier, got {token.GetType().Name}"); + } + } else if (Type == HbcInstructionOperandType.Double) { + HasmNumberToken doubleToken = (HasmNumberToken)IHasmTokenParser.NumberParser.Parse(asm); + return new HasmOperandToken(state) { + OperandType = HasmOperandTokenType.Double, + Value = new PrimitiveValue(doubleToken.Value) + }; + } + + throw new NotImplementedException(Type.ToString()); + } + } +} diff --git a/hasmer/libhasmer/Assembler/Parser/HasmOperandToken.cs b/hasmer/libhasmer/Assembler/Parser/HasmOperandToken.cs new file mode 100644 index 0000000..845da98 --- /dev/null +++ b/hasmer/libhasmer/Assembler/Parser/HasmOperandToken.cs @@ -0,0 +1,30 @@ +using System; + +namespace Hasmer.Assembler.Parser { + /// + /// Represents a Hasm instruction's operand. + /// + public class HasmOperandToken : HasmToken { + /// + /// The type of the operand. + /// + public HasmOperandTokenType OperandType { get; set; } + + /// + /// If the operand represents a string, then its kind is returned (literal or identifier). + /// Otherwise, if this operand is something other than a string, an exception is thrown. + /// + public StringKind OperandStringKind => OperandType switch { + HasmOperandTokenType.String => StringKind.Literal, + HasmOperandTokenType.Identifier => StringKind.Identifier, + _ => throw new Exception("operand is not a string") + }; + + /// + /// The value represented by the operand. + /// + public PrimitiveValue Value { get; set; } + + public HasmOperandToken(HasmStringStreamState? state) : base(state) { } + } +} diff --git a/hasmer/libhasmer/Assembler/Parser/HasmOperandTokenType.cs b/hasmer/libhasmer/Assembler/Parser/HasmOperandTokenType.cs new file mode 100644 index 0000000..e642e8a --- /dev/null +++ b/hasmer/libhasmer/Assembler/Parser/HasmOperandTokenType.cs @@ -0,0 +1,36 @@ +namespace Hasmer.Assembler.Parser { + /// + /// The type of the operand. + /// + public enum HasmOperandTokenType { + /// + /// The operand is a register reference. + /// + Register, + + /// + /// The operand is a code label reference. + /// + Label, + + /// + /// The operand is an unsigned integer. + /// + UInt, + + /// + /// The operand is a string literal. + /// + String, + + /// + /// The operand is an identifier. + /// + Identifier, + + /// + /// The operand is an eight-byte IEEE754 float-point number. + /// + Double + } +} diff --git a/hasmer/libhasmer/Assembler/Parser/HasmParserException.cs b/hasmer/libhasmer/Assembler/Parser/HasmParserException.cs index 8c61154..5d51920 100644 --- a/hasmer/libhasmer/Assembler/Parser/HasmParserException.cs +++ b/hasmer/libhasmer/Assembler/Parser/HasmParserException.cs @@ -34,20 +34,29 @@ public HasmParserException(HasmStringStream stream, string message) { } /// - /// Creates a new HasmParserException given the current stream and an exception. + /// Creates a new HasmParserException given a token and a message. /// - public HasmParserException(HasmStringStream stream, Exception e) : base(e.Message, e) { - Line = stream.CurrentLine + 1; - Column = stream.CurrentColumn + 1; + public HasmParserException(HasmToken token, string message) { + Line = token.Line + 1; + Column = token.Column + 1; + ErrorMessage = message; } /// - /// Creates a new HasmParserException given the line and column of the error as well as a message. + /// Creates a new HasmParserException given a token and a message. /// - public HasmParserException(int line, int col, string message) { - Line = line + 1; - Column = col + 1; + public HasmParserException(HasmStringStreamState state, string message) { + Line = state.Line + 1; + Column = state.Column + 1; ErrorMessage = message; } + + /// + /// Creates a new HasmParserException given the current stream and an exception. + /// + public HasmParserException(HasmStringStream stream, Exception e) : base(e.Message, e) { + Line = stream.CurrentLine + 1; + Column = stream.CurrentColumn + 1; + } } } diff --git a/hasmer/libhasmer/Assembler/Parser/HasmProgram.cs b/hasmer/libhasmer/Assembler/Parser/HasmProgram.cs new file mode 100644 index 0000000..0a631e7 --- /dev/null +++ b/hasmer/libhasmer/Assembler/Parser/HasmProgram.cs @@ -0,0 +1,9 @@ +using System.Collections.Generic; + +namespace Hasmer.Assembler.Parser { + public class HasmProgram { + public HasmHeader Header { get; set; } + public List Data { get; set; } + public List Functions { get; set; } + } +} diff --git a/hasmer/libhasmer/Assembler/Parser/HasmSimpleToken.cs b/hasmer/libhasmer/Assembler/Parser/HasmSimpleToken.cs new file mode 100644 index 0000000..2aec8e1 --- /dev/null +++ b/hasmer/libhasmer/Assembler/Parser/HasmSimpleToken.cs @@ -0,0 +1,19 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Hasmer.Assembler.Parser { + /// + /// Represents a "simple" value, generally a constant identifier (e.g. "true" or "false"). + /// + public class HasmSimpleToken : HasmLiteralToken { + /// + /// The simple value. + /// + public string Value { get; set; } + + public HasmSimpleToken(HasmStringStreamState state) : base(state) { } + } +} diff --git a/hasmer/libhasmer/Assembler/Parser/HasmStringParser.cs b/hasmer/libhasmer/Assembler/Parser/HasmStringParser.cs index bf70977..e9d8c99 100644 --- a/hasmer/libhasmer/Assembler/Parser/HasmStringParser.cs +++ b/hasmer/libhasmer/Assembler/Parser/HasmStringParser.cs @@ -17,58 +17,130 @@ public class HasmStringToken : HasmLiteralToken { public HasmStringToken(HasmStringStreamState state) : base(state) { } } + /// + /// Represents an identifier. + /// + public class HasmIdentifierToken : HasmLiteralToken { + /// + /// The name of the identifier, without the angled brackets. + /// + public string Value { get; set; } + + public HasmIdentifierToken(HasmStringStreamState state) : base(state) { } + } + /// /// Parses an escaped string surrounded by double quotes. /// public class HasmStringParser : IHasmTokenParser { - public bool CanParse(HasmReaderState asm) { - string op = asm.Stream.PeekCharacters(1); - if (op != "\"") { - return false; + enum ParserState { + Normal, + Escape + } + + private HasmLiteralToken TryParse(HasmReaderState asm) { + HasmStringStreamWhitespaceMode prevMode = asm.Stream.WhitespaceMode; + asm.Stream.WhitespaceMode = HasmStringStreamWhitespaceMode.Keep; + + char c = asm.Stream.PeekChar(); + if (c == '\0' || c != '"' && c != '<') { + return null; } + HasmStringStreamState streamState = asm.Stream.SaveState(); + asm.Stream.Advance(1); - HasmStringStreamState state = asm.Stream.SaveState(); - asm.Stream.AdvanceCharacters(1); + StringBuilder res = new StringBuilder(); + ParserState parserState = ParserState.Normal; + if (c == '"') { + while ((c = asm.Stream.AdvanceChar()) != '\0') { + if (parserState == ParserState.Normal) { + if (c == '"') { + asm.Stream.WhitespaceMode = prevMode; + return new HasmStringToken(streamState) { + Value = res.ToString(), + }; + } else if (c == '\\') { + parserState = ParserState.Escape; + } else { + res.Append(c); + } + } else if (parserState == ParserState.Escape) { + char m; + switch (c) { + case '"': m = '"'; break; + case '\\': m = '\\'; break; + case '0': m = '\0'; break; + case 'a': m = '\a'; break; + case 'b': m = '\b'; break; + case 'f': m = '\f'; break; + case 'n': m = '\n'; break; + case 'r': m = '\r'; break; + case 't': m = '\t'; break; + case 'v': m = '\v'; break; + case 'u': + string hex = asm.Stream.AdvanceCharacters(4); + if (hex == null) { + asm.Stream.WhitespaceMode = prevMode; + return null; + } + m = (char)Convert.ToInt32(hex, 16); + break; + default: + throw new Exception($"invalid string escape code: \\{c}"); + } + + parserState = ParserState.Normal; + res.Append(m); + } + } + } else if (c == '<') { + while ((c = asm.Stream.AdvanceChar()) != '\0') { + if (parserState == ParserState.Normal) { + if (c == '>') { + asm.Stream.WhitespaceMode = prevMode; + return new HasmIdentifierToken(streamState) { + Value = res.ToString(), + }; + } else if (c == '\\') { + parserState = ParserState.Escape; + } else { + res.Append(c); + } + } else if (parserState == ParserState.Escape) { + char m; + switch (c) { + case '<': m = '<'; break; + case '>': m = '>'; break; + case '\\': m = '\\'; break; + default: + throw new Exception($"invalid identifier escape code: \\{c}"); + } - char lastChar = '\0'; - while (asm.Stream.PeekCharacters(1) != null) { - string character = asm.Stream.AdvanceCharacters(1); - if (character == "\"" && lastChar != '\\') { - asm.Stream.LoadState(state); - return true; + parserState = ParserState.Normal; + res.Append(m); + } } - lastChar = character[0]; } + asm.Stream.WhitespaceMode = prevMode; + return null; + } + + public bool CanParse(HasmReaderState asm) { + HasmStringStreamState state = asm.Stream.SaveState(); + HasmLiteralToken s = TryParse(asm); asm.Stream.LoadState(state); - return false; + return s != null; } public HasmToken Parse(HasmReaderState asm) { - if (!CanParse(asm)) { - throw new HasmParserException(asm.Stream, "invalid string"); - } - HasmStringStreamState state = asm.Stream.SaveState(); - asm.Stream.AdvanceCharacters(1); // skip first double quote - - asm.Stream.WhitespaceMode = HasmStringStreamWhitespaceMode.Keep; - StringBuilder builder = new StringBuilder(); - char lastChar = '\0'; - while (asm.Stream.PeekCharacters(1) != null) { - string character = asm.Stream.AdvanceCharacters(1); - if (character == "\"" && lastChar != '\\') { - break; - } - builder.Append(character); - lastChar = character[0]; + HasmLiteralToken s = TryParse(asm); + if (s == null) { + throw new HasmParserException(asm.Stream, "invalid string literal or identifier"); } - asm.Stream.WhitespaceMode = HasmStringStreamWhitespaceMode.Remove; - string toString = builder.ToString(); - return new HasmStringToken(state) { - Value = toString - }; + return s; } } } diff --git a/hasmer/libhasmer/Assembler/Parser/HasmStringStream.cs b/hasmer/libhasmer/Assembler/Parser/HasmStringStream.cs index 0f6d648..9a4b127 100644 --- a/hasmer/libhasmer/Assembler/Parser/HasmStringStream.cs +++ b/hasmer/libhasmer/Assembler/Parser/HasmStringStream.cs @@ -1,22 +1,14 @@ -using System; +using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace Hasmer.Assembler.Parser { - /// - /// Represents the state of a . - /// public struct HasmStringStreamState { - /// - /// The line the stream was on. - /// - public int CurrentLine { get; set; } - /// - /// The column the stream was on. - /// - public int CurrentColumn { get; set; } + public int Offset { get; set; } + public int Line { get; set; } + public int Column { get; set; } } /// @@ -40,93 +32,114 @@ public class HasmStringStream { /// /// The characters that are valid in a word, returned by . /// - private const string WordCharacters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_"; + private const string WordCharacters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_$"; + /// /// The valid characters for operators, returned by /// private const string OperatorCharacters = "<>[]()+-/*{},."; /// - /// The current line of the file the stream is on. + /// The current offset of the file the stream is currently at. /// - public int CurrentLine { get; set; } - /// - /// The current column of the current line of the file the stream is on. - /// - public int CurrentColumn { get; set; } - /// + public int Cursor { get; set; } + + public int CurrentLine { + get { + if (Cursor == 0) { + return 0; + } + + // returns the amount of new lines between the start and the cursor + string s = Source.Substring(0, Cursor); + return s.Count(c => c == '\n'); + } + } + + public int CurrentColumn { + get { + if (Cursor == 0) { + return 0; + } + + // returns the amount of characters between the cursor and the last new line + int i = Source.LastIndexOf('\n', Cursor); + return Cursor - i; + } + } + /// Contains each individual line of the Hasm file. /// - public string[] Lines { get; set; } + public string Source { get; set; } + /// /// The method that the stream should use to treat whitespace. /// public HasmStringStreamWhitespaceMode WhitespaceMode { get; set; } - /// - /// The content of the current line, starting at the current column and ending at the end of the line. - /// - private string CurrentContent => Lines[CurrentLine].Substring(CurrentColumn); - /// /// true if the stream is finished (i.e. all data has been read from it), otherwise false. /// - public bool IsFinished => CurrentLine == Lines.Length; + public bool IsFinished => Cursor == Source.Length; /// /// Returns a new HasmStringStream given the raw Hasm assembly. /// public HasmStringStream(string hasm) { - string lineSeparator = hasm.Contains("\r\n") ? "\r\n" : "\n"; - Lines = hasm.Split(lineSeparator).ToArray(); + Source = hasm; WhitespaceMode = HasmStringStreamWhitespaceMode.Remove; } /// - /// Returns *length* characters of the . - ///
- /// If the requested length is the beyond the amount of characters in the CurrentContent, null is returned. - ///
- /// If the stream is finished, an exception is thrown. + /// Returns *length* characters of the starting at the . + /// If the requested length is the beyond the amount of characters in the Source, null is returned. /// - private string Peek(int length) { - if (IsFinished) { - throw new Exception("asm.Stream is finished"); - } - if (length > CurrentContent.Length) { + public string Peek(int length) { + SkipWhitespace(); + + int r = Cursor + length; + if (r < 0 || r > Source.Length) { return null; } - return CurrentContent.Substring(0, length); + return Source.Substring(Cursor, length); + } + + public char PeekChar() { + SkipWhitespace(); + + if (IsFinished) { + return '\0'; + } + return Source[Cursor]; } /// - /// Skips all whitespace starting at the current column until there is a character which is not whitespace. - ///
- /// This will not advance the stream to another line. + /// Skips all whitespace until there is a character which is not whitespace or the end of the input. /// public void SkipWhitespace() { if (WhitespaceMode == HasmStringStreamWhitespaceMode.Remove) { - while (Peek(1) == " ") { - Advance(1); + while (!IsFinished) { + char c = Source[Cursor]; + if (c == '\0') { + break; + } + if (!char.IsWhiteSpace(c)) { + break; + } + Cursor++; } } } - /// - /// Peeks *length* arbitray characters from the stream. - /// - public string PeekCharacters(int length) { - SkipWhitespace(); - return Peek(length); - } - /// /// Advances the stream by *length* characters. /// public string AdvanceCharacters(int length) { - string chars = PeekCharacters(length); + string chars = Peek(length); + if (chars == null) { + return null; + } Advance(chars.Length); - SkipWhitespace(); return chars; } @@ -135,29 +148,41 @@ public string AdvanceCharacters(int length) { ///
/// If the stream has ended, or the operator is not contained within , null is returned. /// - public string PeekOperator() { - SkipWhitespace(); - string peeked = Peek(1); - if (peeked == null) { - return null; + public char PeekOperator() { + char peeked = PeekChar(); + if (peeked == '\0') { + return '\0'; } if (!OperatorCharacters.Contains(peeked)) { - return null; + return '\0'; } - SkipWhitespace(); return peeked; } /// /// Advances the stream beyond the current operator. /// - public string AdvanceOperator() { - string op = PeekOperator(); - Advance(op.Length); - SkipWhitespace(); + public char AdvanceOperator() { + char op = PeekOperator(); + if (op == '\0') { + return '\0'; + } + AdvanceChar(); return op; } + /// + /// Advances the stream beyond the current character. + /// + public char AdvanceChar() { + char c = PeekChar(); + if (c == '\0') { + return '\0'; + } + Advance(1); + return c; + } + /// /// Peeks a word. /// A "word" is defined as an arbitrary length of characters, read until either the end of the current line or the presence of a character that is not contained by . @@ -178,21 +203,31 @@ public string AdvanceOperator() { /// /// public string PeekWord() { - SkipWhitespace(); + int cursor = Cursor; + HasmStringStreamWhitespaceMode wm = WhitespaceMode; + + WhitespaceMode = HasmStringStreamWhitespaceMode.Keep; + + StringBuilder builder = new StringBuilder(); for (int i = 1; ; i++) { - string peeked = Peek(i); - if (peeked == null) { // end of line, return token - return Peek(i - 1); + char peeked = AdvanceChar(); + if (peeked == '\0') { // end of input, return token + break; } - if (!WordCharacters.Contains(peeked[peeked.Length - 1])) { - string word = peeked.Substring(0, peeked.Length - 1); - if (word == "") { - return null; - } - SkipWhitespace(); - return word; + if (!WordCharacters.Contains(peeked)) { // end of word, return token + break; } + builder.Append(peeked); } + + Cursor = cursor; + WhitespaceMode = wm; + + string word = builder.ToString(); + if (word == "") { + return null; + } + return word; } /// @@ -201,8 +236,10 @@ public string PeekWord() { /// the word that was read public string AdvanceWord() { string word = PeekWord(); + if (word == null) { + return null; + } Advance(word.Length); - SkipWhitespace(); return word; } @@ -214,17 +251,14 @@ public string AdvanceWord() { /// If length advances the stream to the end of the current line, the stream goes to the next line and sets the current column to zero. /// public void Advance(int length) { - if (IsFinished) { - throw new Exception("asm.Stream is finished"); - } - if (length > CurrentContent.Length) { - throw new Exception("cannot advance beyond line length"); - } - CurrentColumn += length; - if (CurrentColumn == Lines[CurrentLine].Length) { - CurrentLine++; - CurrentColumn = 0; + int r = Cursor + length; + if (r < 0 || r > Source.Length) { + throw new IndexOutOfRangeException($"new cursor position out of bounds: {r}"); } + + Cursor = r; + + SkipWhitespace(); } /// @@ -232,8 +266,9 @@ public void Advance(int length) { /// public HasmStringStreamState SaveState() { return new HasmStringStreamState { - CurrentLine = CurrentLine, - CurrentColumn = CurrentColumn + Offset = Cursor, + Line = CurrentLine, + Column = CurrentColumn, }; } @@ -241,8 +276,11 @@ public HasmStringStreamState SaveState() { /// Sets the current state of the stream to *state*, which is generally used as the value returned by . /// public void LoadState(HasmStringStreamState state) { - CurrentLine = state.CurrentLine; - CurrentColumn = state.CurrentColumn; + int cursor = state.Offset; + if (cursor < 0 || cursor > Source.Length) { + throw new IndexOutOfRangeException($"loaded cursor position out of bounds: {cursor}"); + } + Cursor = cursor; } } } diff --git a/hasmer/libhasmer/Assembler/Parser/HasmStringStream.cs.old b/hasmer/libhasmer/Assembler/Parser/HasmStringStream.cs.old new file mode 100644 index 0000000..0c78e23 --- /dev/null +++ b/hasmer/libhasmer/Assembler/Parser/HasmStringStream.cs.old @@ -0,0 +1,256 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Hasmer.Assembler.Parser { + /// + /// Represents the state of a . + /// + public struct int { + /// + /// The line the stream was on. + /// + public int CurrentLine { get; set; } + /// + /// The column the stream was on. + /// + public int CurrentColumn { get; set; } + } + + /// + /// Represents how the stream should treat whitespace. + /// + public enum HasmStringStreamWhitespaceMode { + /// + /// Removes all whitespace between tokens. + /// + Remove, + /// + /// Keeps all whitespace between tokens. + /// + Keep + } + + /// + /// Represents a stream that parses a Hasm assembly file. + /// + public class HasmStringStream { + /// + /// The characters that are valid in a word, returned by . + /// + private const string WordCharacters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_$"; + /// + /// The valid characters for operators, returned by + /// + private const string OperatorCharacters = "<>[]()+-/*{},."; + + /// + /// The current line of the file the stream is on. + /// + public int CurrentLine { get; set; } + /// + /// The current column of the current line of the file the stream is on. + /// + public int CurrentColumn { get; set; } + /// + /// Contains each individual line of the Hasm file. + /// + public string[] Lines { get; set; } + /// + /// The method that the stream should use to treat whitespace. + /// + public HasmStringStreamWhitespaceMode WhitespaceMode { get; set; } + + /// + /// The content of the current line, starting at the current column and ending at the end of the line. + /// + private string CurrentContent => Lines[CurrentLine].Substring(CurrentColumn); + + /// + /// true if the stream is finished (i.e. all data has been read from it), otherwise false. + /// + public bool IsFinished => CurrentLine == Lines.Length; + + /// + /// Returns a new HasmStringStream given the raw Hasm assembly. + /// + public HasmStringStream(string hasm) { + Lines = hasm.Split("\n").ToArray(); + WhitespaceMode = HasmStringStreamWhitespaceMode.Remove; + } + + /// + /// Returns *length* characters of the . + ///
+ /// If the requested length is the beyond the amount of characters in the CurrentContent, null is returned. + ///
+ /// If the stream is finished, an exception is thrown. + /// + private string Peek(int length) { + if (IsFinished) { + throw new Exception("asm.Stream is finished"); + } + if (length > CurrentContent.Length) { + return null; + } + return CurrentContent.Substring(0, length); + } + + /// + /// Skips all whitespace starting at the current column until there is a character which is not whitespace. + ///
+ /// This will not advance the stream to another line. + /// + public void SkipWhitespace() { + if (WhitespaceMode == HasmStringStreamWhitespaceMode.Remove) { + while (Peek(1) == " ") { + Advance(1); + } + } + } + + /// + /// Peeks *length* arbitray characters from the stream. + /// + public string PeekCharacters(int length) { + SkipWhitespace(); + return Peek(length); + } + + /// + /// Advances the stream by *length* characters. + /// + public string AdvanceCharacters(int length) { + string chars = PeekCharacters(length); + if (chars == null) { + return null; + } + Advance(chars.Length); + SkipWhitespace(); + return chars; + } + + /// + /// Peeks a single-character operator from the stream. + ///
+ /// If the stream has ended, or the operator is not contained within , null is returned. + /// + public string PeekOperator() { + SkipWhitespace(); + string peeked = Peek(1); + if (peeked == null) { + return null; + } + if (!OperatorCharacters.Contains(peeked)) { + return null; + } + SkipWhitespace(); + return peeked; + } + + /// + /// Advances the stream beyond the current operator. + /// + public string AdvanceOperator() { + string op = PeekOperator(); + if (op == null) { + return null; + } + Advance(op.Length); + SkipWhitespace(); + return op; + } + + /// + /// Peeks a word. + /// A "word" is defined as an arbitrary length of characters, read until either the end of the current line or the presence of a character that is not contained by . + /// + /// + /// line = "hello my na[jeff]me is"
+ /// AdvanceWord() = hello
+ /// AdvanceWord() = my
+ /// AdvanceWord() = na
+ /// AdvanceOperator() // skip the [
+ /// AdvanceWord() = jeff
+ /// AdvanceOperator() // skip the ]
+ /// AdvanceWord() = me
+ /// AdvanceWord() = is + /// + ///
+ /// + /// + /// + public string PeekWord() { + SkipWhitespace(); + for (int i = 1; ; i++) { + string peeked = Peek(i); + if (peeked == null) { // end of line, return token + return Peek(i - 1); + } + if (!WordCharacters.Contains(peeked[peeked.Length - 1])) { + string word = peeked.Substring(0, peeked.Length - 1); + if (word == "") { + return null; + } + SkipWhitespace(); + return word; + } + } + } + + /// + /// Advances the stream beyond the current word. + /// + /// the word that was read + public string AdvanceWord() { + string word = PeekWord(); + if (word == null) { + return null; + } + Advance(word.Length); + SkipWhitespace(); + return word; + } + + /// + /// Advances the stream by *length* characters. + /// + /// length cannot be greater than the length of the . + /// + /// If length advances the stream to the end of the current line, the stream goes to the next line and sets the current column to zero. + /// + public void Advance(int length) { + if (IsFinished) { + throw new Exception("asm.Stream is finished"); + } + if (length > CurrentContent.Length) { + throw new Exception("cannot advance beyond line length"); + } + CurrentColumn += length; + if (CurrentColumn == Lines[CurrentLine].Length) { + CurrentLine++; + CurrentColumn = 0; + } + } + + /// + /// Gets the current state of the stream. + /// + public int SaveState() { + return new int { + CurrentLine = CurrentLine, + CurrentColumn = CurrentColumn + }; + } + + /// + /// Sets the current state of the stream to *state*, which is generally used as the value returned by . + /// + public void LoadState(int state) { + CurrentLine = state.CurrentLine; + CurrentColumn = state.CurrentColumn; + } + } +} diff --git a/hasmer/libhasmer/Assembler/Parser/HasmToken.cs b/hasmer/libhasmer/Assembler/Parser/HasmToken.cs index 9cc59aa..5c31585 100644 --- a/hasmer/libhasmer/Assembler/Parser/HasmToken.cs +++ b/hasmer/libhasmer/Assembler/Parser/HasmToken.cs @@ -12,42 +12,33 @@ namespace Hasmer.Assembler.Parser { /// public class HasmToken { /// - /// The line of the file that the token is on. This is zero-indexed, i.e. the first line (Line = 0), the second line (Line = 1), etc. + /// The offset in characters from the start of the file. /// [JsonIgnore] + public int Offset { get; set; } + public int Line { get; set; } - /// - /// The column of the line of the file that the token is on. This is zero-indexed, i.e. the first column (Column = 0), the second column (Column = 1), etc. - /// - [JsonIgnore] public int Column { get; set; } -#pragma warning disable IDE0051 // Remove unused private members - /// - /// Gets the type of the token (the class name of the implementation) as information when JSON serializing the token (used for debug). - /// - [JsonProperty("TokenType")] - private string JsonTokenType => GetType().Name; - - /// - /// Gets the line of the token (except 1-indexed) as information when JSON serializing the token (used for debug). - /// - [JsonProperty("Line")] - private int JsonLine => Line + 1; - - /// - /// Gets the column of the token (except 1-indexed) as information when JSON serializing the token (used for debug). - /// - [JsonProperty("Column")] - private int JsonColumn => Column + 1; -#pragma warning restore IDE0051 // Remove unused private members - /// /// Creates a new HasmToken from the given state. This does not parse anything. /// - public HasmToken(HasmStringStreamState state) { - Line = state.CurrentLine; - Column = state.CurrentColumn; + public HasmToken(HasmStringStreamState? state) { + if (state == null) { + return; + } + HasmStringStreamState s = state.Value; + Offset = s.Offset; + Line = s.Line; + Column = s.Column; + } + + public HasmStringStreamState AsStreamState() { + return new HasmStringStreamState{ + Offset = Offset, + Line = Line, + Column = Column, + }; } /// diff --git a/hasmer/libhasmer/Assembler/Parser/HasmTokenStream.cs.old b/hasmer/libhasmer/Assembler/Parser/HasmTokenStream.cs.old new file mode 100644 index 0000000..a681578 --- /dev/null +++ b/hasmer/libhasmer/Assembler/Parser/HasmTokenStream.cs.old @@ -0,0 +1,95 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Hasmer.Assembler.Parser { + /// + /// Represents a stream of Hasm tokens parsed from a Hasm file. + /// + public class HasmTokenStream { + /// + /// The current state of the reader. + /// + public HasmReaderState State { get; set; } + + /// + /// Creates a new HasmTokenStream from raw Hasm assembly. + /// + public HasmTokenStream(string hasm) { + State = new HasmReaderState { + Stream = new HasmStringStream(hasm) + }; + } + + /// + /// Creates a new HasmTokenStream from an existing state. + /// + public HasmTokenStream(HasmReaderState state) { + State = state; + } + + /// + /// Gets an enumerator returning each next token, parsed from the Hasm file. + /// + public IEnumerable ReadTokens() { + while (!State.Stream.IsFinished) { + if (State.Stream.Lines[State.Stream.CurrentLine].Trim() == "") { + State.Stream.CurrentLine++; + continue; + } + + State.Stream.SkipWhitespace(); + + List tokenParsers = new List { + IHasmTokenParser.DeclarationParser, + IHasmTokenParser.CommentParser + }; + if (State.CurrentFunction != null) { + tokenParsers.Add(IHasmTokenParser.InstructionParser); + } + + bool parsed = false; + foreach (IHasmTokenParser parser in tokenParsers) { + int state = State.Stream.SaveState(); + if (parser.CanParse(State)) { + State.Stream.LoadState(state); + HasmToken token; + try { + token = parser.Parse(State); + } catch (HasmParserException) { + throw; + } catch (Exception e) { + throw new HasmParserException(State.Stream, e); + } + if (token != null) { // tokens like comments can return null, just ignore them + yield return token; + } + + if (State.BytecodeFormat == null) { + if (token is HasmHeaderDeclarationToken header) { + uint value = header.Version.GetValueAsUInt32(); + State.BytecodeFormat = ResourceManager.ReadEmbeddedResource($"Bytecode{value}"); + State.IsExact = header.IsExact; + } else { + throw new HasmParserException(State.Stream, "expecting '.hasm' declaration"); + } + } + + parsed = true; + break; + } else { + State.Stream.LoadState(state); + } + } + + State.Stream.SkipWhitespace(); + + if (!parsed) { + throw new HasmParserException(State.Stream, "invalid statement"); + } + } + } + } +} diff --git a/hasmer/libhasmer/Assembler/Parser/HasmTokenizer.cs b/hasmer/libhasmer/Assembler/Parser/HasmTokenizer.cs new file mode 100644 index 0000000..b527114 --- /dev/null +++ b/hasmer/libhasmer/Assembler/Parser/HasmTokenizer.cs @@ -0,0 +1,685 @@ +using Newtonsoft.Json; +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace Hasmer.Assembler.Parser { + enum StringParserState { + Normal, + Escape + } + + public class TokenDefinition { + [JsonProperty] + public string Kind { get; set; } + + [JsonProperty] + public dynamic Match { get; set; } + + [JsonProperty] + public string Var { get; set; } + + [JsonProperty] + public string Modifier { get; set; } + + [JsonProperty] + public bool Repeated { get; set; } + + [JsonProperty] + public bool Optional { get; set; } + } + + public class TokenizerState { + public HasmStringStream Stream { get; set; } + + public Dictionary> Vars { get; set; } + public bool Moved { get; set; } + public HasmStringStreamWhitespaceMode WhitespaceMode { get; set; } + + public void AddVar(string name, TokenMatch token) { + if (Vars.TryGetValue(name, out List l)) { + l.Add(token); + } else { + l = new List(1); + l.Add(token); + Vars[name] = l; + } + } + + public TokenizerState Derive() { + return new TokenizerState { + WhitespaceMode = HasmStringStreamWhitespaceMode.Remove, + Stream = Stream, + Vars = new Dictionary>(), + Moved = false, + }; + } + } + + public class TokenMatch { + public object Value; + + public TokenMatch(Dictionary> matches) { + Value = matches; + } + + public TokenMatch(HasmToken token) { + Value = token; + } + + public Dictionary> AsToken() { + return (Dictionary>) Value; + } + + public HasmIntegerToken AsInteger() { + return (HasmIntegerToken) Value; + } + + public HasmStringToken AsString() { + return (HasmStringToken) Value; + } + + public HasmSimpleToken AsSimple() { + return (HasmSimpleToken) Value; + } + } + + public enum TokenizerResultKind { + TokenMatch, + EmptyMatch, + FailedMatch + } + + public struct TokenizerResult { + public TokenizerResultKind Kind { get; set; } + public TokenMatch Token { get; set; } + + public static TokenizerResult Matched(HasmToken token) { + return new TokenizerResult { + Kind = TokenizerResultKind.TokenMatch, + Token = new TokenMatch(token), + }; + } + + public static TokenizerResult Empty { + get { + return new TokenizerResult { + Kind = TokenizerResultKind.EmptyMatch + }; + } + } + + public static TokenizerResult Failed { + get { + return new TokenizerResult { + Kind = TokenizerResultKind.FailedMatch + }; + } + } + } + + public delegate TokenizerResult Tokenizer(TokenizerState state); + + public class HasmTokenizer { + private List ParseStack = new List(); + private Dictionary Tokenizers = new Dictionary(); + + private string ParseStackText => string.Join(" -> ", ParseStack); + + public HasmTokenizer() : this(ResourceManager.ReadEmbeddedResource>>("HasmTokenDefinitions")) { } + + public HasmTokenizer(Dictionary> defsMap) { + foreach (KeyValuePair> pair in defsMap) { + string name = pair.Key; + IEnumerable defs = pair.Value; + + Tokenizers[name] = CreateMultiTokenParser(defs.Select(CreateFullParser).ToList()); + } + } + + private HasmHeader TokenizeHeader(TokenMatch match) { + Dictionary> vars = match.AsToken(); + HasmIntegerToken version = vars["version"][0].AsInteger(); + HasmSimpleToken mode = vars["mode"][0].AsSimple(); + + bool isExact; + if (mode.Value == "auto") { + isExact = false; + } else if (mode.Value == "exact") { + isExact = true; + } else { + throw new HasmParserException(mode, "invalid mode; expecting either 'auto' or 'exact'"); + } + + return new HasmHeader { + Version = version, + IsExact = isExact, + }; + } + + private HasmLabelToken TokenizeLabel(TokenMatch match) { + Dictionary> vars = match.AsToken(); + HasmSimpleToken kind = vars["kind"][0].AsSimple(); + HasmLabelKind label = kind.Value switch { + "A" => HasmLabelKind.ArrayBuffer, + "K" => HasmLabelKind.ObjectKeyBuffer, + "V" => HasmLabelKind.ObjectValueBuffer, + "L" => HasmLabelKind.CodeLabel, + _ => throw new HasmParserException(kind, "invalid label type; expecting 'A', 'K', 'V', or 'L'") + }; + HasmIntegerToken index = vars["index"][0].AsInteger(); + HasmIntegerToken offset = null; + if (vars.ContainsKey("offset")) { + offset = vars["offset"][0].AsInteger(); + } + + return new HasmLabelToken(kind.AsStreamState()) { + Kind = label, + Index = index, + ReferenceOffset = offset, + }; + } + + private HasmLiteralToken TokenizeLiteral(TokenMatch match) { + if (match.Value is Dictionary> vars) { + Console.WriteLine($"vars: {vars.Count}"); + foreach (KeyValuePair> entry in vars) { + Console.WriteLine($" {entry.Key} = {entry.Value}"); + } + } + if (match.Value is HasmLiteralToken lit) { + return lit; + } + throw new Exception($"invalid literal match value type: {match.Value.GetType().FullName}"); + } + + private HasmOperandToken TokenizeOperand(TokenMatch match) { + // if (match.Value is HasmStringToken str) { + // return new HasmOperandToken(str.AsStreamState()) { + // OperandType = HasmOperandTokenType.String, + // Value = new PrimitiveType(str.Value), + // }; + // } + // if (match.Value is HasmIdentifierToken ident) { + // return new HasmOperandToken(ident.AsStreamState()) { + // OperandType = HasmOperandTokenType.Identifier, + // Value = new PrimitiveType(ident.Value), + // }; + // } + // if (match.Value is HasmIntegerToken integer) { + // return new HasmOperandToken(ident.AsStreamState()) { + // OperandType = HasmOperandTokenType.UInt, + // Value = new PrimitiveType(integer.Value), + // }; + // } + // if (match.Value is Dictionary> vars) { + // if (vars.ContainsKey("reg")) { + + // } else { + // throw new Exception("invalid operand"); + // } + // } + throw new Exception($"invalid operand match value type: {match.Value.GetType().FullName}"); + } + + private HasmDataDeclaration TokenizeDataDeclaration(TokenMatch match) { + Dictionary> vars = match.AsToken(); + + HasmSimpleToken declToken = vars["decl"][0].AsSimple(); + HasmLabelToken label = TokenizeLabel(vars["label"][0]); + HasmSimpleToken kindToken = vars["kind"][0].AsSimple(); + + if (!vars.ContainsKey("length") && !vars.ContainsKey("elements")) { + throw new HasmParserException(declToken, $"expecting either data length or specified elements"); + } + + HasmDataDeclarationKind kind = kindToken.Value switch { + "String" => HasmDataDeclarationKind.String, + "Integer" => HasmDataDeclarationKind.Integer, + "Number" => HasmDataDeclarationKind.Number, + "Null" => HasmDataDeclarationKind.Null, + "True" => HasmDataDeclarationKind.True, + "False" => HasmDataDeclarationKind.False, + _ => throw new HasmParserException(kindToken, "invalid data kind") + }; + + bool isConstType = kind switch { + HasmDataDeclarationKind.Null or HasmDataDeclarationKind.True or HasmDataDeclarationKind.False => true, + _ => false + }; + if (isConstType && vars.ContainsKey("elements")) { + throw new HasmParserException(declToken, $"data declaration of kind {kindToken.Value} cannot have specified elements"); + } + if (!isConstType && vars.ContainsKey("length")) { + throw new HasmParserException(declToken, $"data declaration of kind {kindToken.Value} must have specified elements"); + } + + if (isConstType) { + HasmIntegerToken length = vars["length"][0].AsInteger(); + + return new HasmDataDeclaration { + Label = label, + Kind = kind, + Count = length.GetValueAsInt32(), + }; + } else { + List elements = vars["elements"].Select(TokenizeLiteral).ToList(); + + return new HasmDataDeclaration { + Label = label, + Kind = kind, + Count = elements.Count, + Elements = elements, + }; + } + } + + public HasmProgram TokenizeProgram(string input) { + TokenizerState state = new TokenizerState { + Stream = new HasmStringStream(input), + Vars = new Dictionary>(), + Moved = false, + WhitespaceMode = HasmStringStreamWhitespaceMode.Remove, + }; + + ParseStack.Add("Program"); + TokenizerResult res = Tokenizers["Program"](state); + ParseStack.RemoveAt(0); + if (res.Kind == TokenizerResultKind.FailedMatch) { + throw new Exception($"failed @ {state.Stream.CurrentLine},{state.Stream.CurrentColumn}"); + } + HasmHeader header = TokenizeHeader(state.Vars["header"][0]); + List data = state.Vars["data"].Select(TokenizeDataDeclaration).ToList(); + + return new HasmProgram { + Header = header, + Data = data, + }; + } + + private Tokenizer CreateMultiTokenParser(List parsers) { + return state => { + TokenizerResult res; + HasmStringStreamState sss = state.Stream.SaveState(); + foreach (Tokenizer parser in parsers) { + state.Stream.WhitespaceMode = state.WhitespaceMode; + Console.WriteLine($"{ParseStackText}: MultiToken parser moving to next"); + res = parser(state); + if (res.Kind == TokenizerResultKind.FailedMatch) { + Console.WriteLine($"{ParseStackText}: MultiTokenParser failed match (moved = {state.Moved})"); + if (state.Moved) { + throw new HasmParserException(sss, "fatal parser error"); + } + + state.Stream.LoadState(sss); + return TokenizerResult.Failed; + } + } + + return TokenizerResult.Empty; + }; + } + + private Tokenizer CreateFullParser(TokenDefinition def) { + Tokenizer inner = CreateCapturingParser(def); + if (def.Optional && def.Repeated) { + return state => { + while (true) { + HasmStringStreamState sss = state.Stream.SaveState(); + + Console.WriteLine($"{ParseStackText}: OptionalRepeated FullParser reading next"); + TokenizerResult res = inner(state); + Console.WriteLine($"{ParseStackText}: OptionalRepeated FullParser read {res.Kind}"); + if (res.Kind == TokenizerResultKind.FailedMatch) { + state.Stream.LoadState(sss); + break; + } + } + return TokenizerResult.Empty; + }; + } else if (def.Optional) { + return state => { + HasmStringStreamState sss = state.Stream.SaveState(); + + TokenizerResult res = inner(state); + if (res.Kind == TokenizerResultKind.FailedMatch) { + Console.WriteLine(ParseStackText + ": Optional FullParser failed to match (skipping)"); + state.Stream.LoadState(sss); + return TokenizerResult.Empty; + } + return res; + }; + } else if (def.Repeated) { + return state => { + TokenizerResult res = inner(state); + if (res.Kind == TokenizerResultKind.FailedMatch) { + Console.WriteLine(ParseStackText + ": Repeated FullParser failed to match initial"); + return TokenizerResult.Failed; + } + while (true) { + HasmStringStreamState sss = state.Stream.SaveState(); + + res = inner(state); + if (res.Kind == TokenizerResultKind.FailedMatch) { + Console.WriteLine(ParseStackText + ": Repeated FullParser stopped matching"); + state.Stream.LoadState(sss); + break; + } + } + return TokenizerResult.Empty; + }; + } else { + return inner; + } + } + + int offset = 0; + + private Tokenizer CreateCapturingParser(TokenDefinition def) { + Tokenizer inner = CreateSimpleParser(def); + return state => { + TokenizerResult res = inner(state); + if (res.Kind == TokenizerResultKind.TokenMatch && !string.IsNullOrEmpty(def.Var)) { + state.AddVar(def.Var, res.Token); + } + return res; + }; + } + + private Tokenizer CreateSimpleParser(TokenDefinition def) { + switch (def.Kind) { + case "literal": + string match = (string)def.Match; + return state => { + HasmStringStreamState sss = state.Stream.SaveState(); + + string take = state.Stream.AdvanceCharacters(match.Length); + if (take == null) { + return TokenizerResult.Failed; + } + if (match == take) { + return TokenizerResult.Matched(new HasmSimpleToken(sss) { + Value = take + }); + } else { + return TokenizerResult.Failed; + } + }; + case "string": + return state => { + HasmToken token = ParseStringLike(state); + if (token is HasmStringToken) { + return TokenizerResult.Matched(token); + } else { + return TokenizerResult.Failed; + } + }; + case "ident": + return state => { + HasmToken token = ParseStringLike(state); + if (token is HasmIdentifierToken) { + return TokenizerResult.Matched(token); + } else { + return TokenizerResult.Failed; + } + }; + case "word": + return state => { + HasmStringStreamState sss = state.Stream.SaveState(); + + string take = state.Stream.AdvanceWord(); + if (take == null) { + return TokenizerResult.Failed; + } + return TokenizerResult.Matched(new HasmSimpleToken(sss) { + Value = take + }); + }; + case "integer": + return state => { + HasmStringStreamState sss = state.Stream.SaveState(); + + long multiplier = 1; + char op = state.Stream.PeekOperator(); + if (op == '-') { // negative number + state.Stream.AdvanceOperator(); + multiplier = -1; + } else if (op == '+') { + state.Stream.AdvanceOperator(); + } else if (op != '\0') { + return TokenizerResult.Failed; + } + + string word = state.Stream.AdvanceWord(); + if (word == null) { + return TokenizerResult.Failed; + } + long parsed = long.Parse(word); + return TokenizerResult.Matched(new HasmIntegerToken(sss, parsed * multiplier)); + }; + case "number": + return state => { + HasmStringStreamState sss = state.Stream.SaveState(); + + double multiplier = 1.0; + char op = state.Stream.PeekOperator(); + if (op == '-') { // negative number + state.Stream.AdvanceOperator(); + multiplier = -1.0; + } else if (op == '+') { + state.Stream.AdvanceOperator(); + } else if (op != '\0') { + return TokenizerResult.Failed; + } + + string intPart = state.Stream.AdvanceWord(); + if (intPart == null) { + return TokenizerResult.Failed; + } + char separator = state.Stream.PeekOperator(); + HasmNumberToken token; + if (separator == '.') { // separator == ".", it's a fraction + state.Stream.AdvanceOperator(); + string fractionPart = state.Stream.AdvanceWord(); + if (fractionPart == null) { + return TokenizerResult.Failed; + } + token = new HasmNumberToken(sss) { + Value = double.Parse($"{intPart}.{fractionPart}") * multiplier + }; + } else { + if (intPart == "Infinity") { + token = new HasmNumberToken(sss) { + Value = multiplier == 1.0 ? double.PositiveInfinity : double.NegativeInfinity + }; + } else if (intPart == "NaN") { + token = new HasmNumberToken(sss) { + Value = double.NaN + }; + } else { + token = new HasmNumberToken(sss) { + Value = double.Parse(intPart) * multiplier + }; + } + } + + return TokenizerResult.Matched(token); + }; + case "enum": + JArray matchArr = (JArray)def.Match; + IEnumerable values = matchArr.Values(); + return state => { + HasmStringStreamState sss = state.Stream.SaveState(); + foreach (string value in values) { + state.Stream.LoadState(sss); + + string take = state.Stream.AdvanceCharacters(value.Length); + if (take == null) { + continue; + } + if (value == take) { + return TokenizerResult.Matched(new HasmSimpleToken(sss) { + Value = value + }); + } + } + + state.Stream.LoadState(sss); + return TokenizerResult.Failed; + }; + case "or": + JArray matches = (JArray)def.Match; + IEnumerable tokenizers = matches.ToObject>().Select(CreateFullParser); + return state => { + HasmStringStreamState sss = state.Stream.SaveState(); + foreach (Tokenizer tokenizer in tokenizers) { + state.Stream.LoadState(sss); + TokenizerResult res = tokenizer(state); + if (res.Kind != TokenizerResultKind.FailedMatch) { + return res; + } + } + + state.Stream.LoadState(sss); + return TokenizerResult.Failed; + }; + default: + if (def.Modifier != null) { + switch (def.Modifier) { + case "contiguous": + return state => { + state.WhitespaceMode = HasmStringStreamWhitespaceMode.Keep; + return TokenizerResult.Empty; + }; + case "move": + return state => { + state.Moved = true; + return TokenizerResult.Empty; + }; + default: + throw new Exception($"invalid modifier: {def.Modifier}"); + } + } + + if (def.Match is JArray matchArray) { + List tokens = matchArray.ToObject>(); + return CreateMultiTokenParser(tokens.Select(CreateFullParser).ToList()); + } + + if (def.Kind[0] == '$') { + Tokenizer tokenizer = Tokenizers[def.Kind[1..]]; + return state => { + ParseStack.Add(def.Kind[1..]); + TokenizerState derived = state.Derive(); + TokenizerResult res = tokenizer(derived); + if (res.Kind == TokenizerResultKind.FailedMatch) { + ParseStack.RemoveAt(ParseStack.Count - 1); + return res; + } + if (!string.IsNullOrEmpty(def.Var)) { + if (derived.Vars.Count > 0) { + state.AddVar(def.Var, new TokenMatch(derived.Vars)); + } else if (res.Token != null) { + state.AddVar(def.Var, res.Token); + } + } + ParseStack.RemoveAt(ParseStack.Count - 1); + return TokenizerResult.Empty; + }; + } else { + throw new Exception($"invalid token kind: {def.Kind}"); + } + } + } + + private static HasmLiteralToken ParseStringLike(TokenizerState state) { + HasmStringStreamWhitespaceMode prevMode = state.Stream.WhitespaceMode; + state.Stream.WhitespaceMode = HasmStringStreamWhitespaceMode.Keep; + + char c = state.Stream.PeekChar(); + if (c == '\0' || c != '"' && c != '<') { + return null; + } + HasmStringStreamState streamState = state.Stream.SaveState(); + state.Stream.Advance(1); + + StringBuilder res = new StringBuilder(); + StringParserState parserState = StringParserState.Normal; + if (c == '"') { + while ((c = state.Stream.AdvanceChar()) != '\0') { + if (parserState == StringParserState.Normal) { + if (c == '"') { + state.Stream.WhitespaceMode = prevMode; + return new HasmStringToken(streamState) { + Value = res.ToString(), + }; + } else if (c == '\\') { + parserState = StringParserState.Escape; + } else { + res.Append(c); + } + } else if (parserState == StringParserState.Escape) { + char m; + switch (c) { + case '"': m = '"'; break; + case '\\': m = '\\'; break; + case '0': m = '\0'; break; + case 'a': m = '\a'; break; + case 'b': m = '\b'; break; + case 'f': m = '\f'; break; + case 'n': m = '\n'; break; + case 'r': m = '\r'; break; + case 't': m = '\t'; break; + case 'v': m = '\v'; break; + case 'u': + string hex = state.Stream.AdvanceCharacters(4); + if (hex == null) { + state.Stream.WhitespaceMode = prevMode; + return null; + } + m = (char)Convert.ToInt32(hex, 16); + break; + default: + throw new Exception($"invalid string escape code: \\{c}"); + } + + parserState = StringParserState.Normal; + res.Append(m); + } + } + } else if (c == '<') { + while ((c = state.Stream.AdvanceChar()) != '\0') { + if (parserState == StringParserState.Normal) { + if (c == '>') { + state.Stream.WhitespaceMode = prevMode; + return new HasmIdentifierToken(streamState) { + Value = res.ToString(), + }; + } else if (c == '\\') { + parserState = StringParserState.Escape; + } else { + res.Append(c); + } + } else if (parserState == StringParserState.Escape) { + char m; + switch (c) { + case '<': m = '<'; break; + case '>': m = '>'; break; + case '\\': m = '\\'; break; + default: + throw new Exception($"invalid identifier escape code: \\{c}"); + } + + parserState = StringParserState.Normal; + res.Append(m); + } + } + } + + state.Stream.WhitespaceMode = prevMode; + return null; + } + } +} diff --git a/hasmer/libhasmer/Assembler/Parser/IHasmTokenParser.cs b/hasmer/libhasmer/Assembler/Parser/IHasmTokenParser.cs index 9e1ac06..9fac281 100644 --- a/hasmer/libhasmer/Assembler/Parser/IHasmTokenParser.cs +++ b/hasmer/libhasmer/Assembler/Parser/IHasmTokenParser.cs @@ -9,14 +9,6 @@ namespace Hasmer.Assembler.Parser { /// Represents a class which can parse Hasm tokens from a Hasm file. /// public interface IHasmTokenParser { - public static readonly IHasmTokenParser CommentParser = new HasmCommentParser(); - public static readonly IHasmTokenParser DeclarationParser = new HasmDeclarationParser(); - public static readonly IHasmTokenParser IntegerParser = new HasmIntegerParser(); - public static readonly IHasmTokenParser NumberParser = new HasmNumberParser(); - public static readonly IHasmTokenParser StringParser = new HasmStringParser(); - public static readonly IHasmTokenParser LabelParser = new HasmLabelParser(); - public static readonly IHasmTokenParser InstructionParser = new HasmInstructionParser(); - /// /// Returns true if a valid token can be parsed immediately, or false if one cannot. /// diff --git a/hasmer/libhasmer/Assembler/Visitor/DataAssembler.cs b/hasmer/libhasmer/Assembler/Visitor/DataAssembler.cs index 8c71bac..8eb7c3d 100644 --- a/hasmer/libhasmer/Assembler/Visitor/DataAssembler.cs +++ b/hasmer/libhasmer/Assembler/Visitor/DataAssembler.cs @@ -14,16 +14,22 @@ public class HasmAssemblerDataBuffer { /// /// The raw bytes of the buffer. /// - public List RawBuffer { get; set; } + public MemoryStream RawBuffer { get; set; } + + /// + /// A writer for . + /// + public BinaryWriter BufferWriter { get; set; } /// /// Represents key-value between the label in the buffer (i.e. A5, key = 5) and the offset of that label in the . /// - public Dictionary HasmBuffer { get; set; } + public Dictionary HasmBuffer { get; set; } public HasmAssemblerDataBuffer() { - RawBuffer = new List(); - HasmBuffer = new Dictionary(); + RawBuffer = new MemoryStream(); + BufferWriter = new BinaryWriter(RawBuffer); + HasmBuffer = new Dictionary(); } } @@ -32,9 +38,9 @@ public HasmAssemblerDataBuffer() { /// public class DataAssembler { /// - /// The token stream of the Hasm file. + /// The tokens of the Hasm program. /// - private HasmTokenStream Stream; + private HasmProgram Program; /// /// The array buffer. @@ -52,18 +58,24 @@ public class DataAssembler { public HasmAssemblerDataBuffer ObjectValueBuffer { get; set; } /// - /// Represents the string table. + /// The string table, where each index is the entry's ID. + /// + public List StringTable { get; set; } + + /// + /// Fast lookup into the string table by the string's value. /// The key is the string and the value is the ID of the string. - /// The ID is a sequential value, incremented for each new string. + /// That is, the index into . /// - public Dictionary StringTable { get; set; } + private Dictionary StringTableLookup { get; set; } /// /// Creates a new data assembler. /// - public DataAssembler(HasmTokenStream stream) { - Stream = stream; - StringTable = new Dictionary(); + public DataAssembler(HasmProgram program) { + Program = program; + StringTable = new List(); + StringTableLookup = new Dictionary(); ArrayBuffer = new HasmAssemblerDataBuffer(); ObjectKeyBuffer = new HasmAssemblerDataBuffer(); ObjectValueBuffer = new HasmAssemblerDataBuffer(); @@ -72,12 +84,12 @@ public DataAssembler(HasmTokenStream stream) { /// /// Gets a by its label (i.e. "A", "K", or "V"). /// - private HasmAssemblerDataBuffer GetBufferByName(LabelType type) { - return type switch { - LabelType.ArrayBuffer => ArrayBuffer, - LabelType.ObjectKeyBuffer => ObjectKeyBuffer, - LabelType.ObjectValueBuffer => ObjectValueBuffer, - _ => throw new Exception("invalid buffer label: " + type) + private HasmAssemblerDataBuffer GetBufferByName(HasmLabelKind kind) { + return kind switch { + HasmLabelKind.ArrayBuffer => ArrayBuffer, + HasmLabelKind.ObjectKeyBuffer => ObjectKeyBuffer, + HasmLabelKind.ObjectValueBuffer => ObjectValueBuffer, + _ => throw new Exception($"invalid buffer label '{kind}'") }; } @@ -86,76 +98,85 @@ private HasmAssemblerDataBuffer GetBufferByName(LabelType type) { /// If the string is not already present in the string table, /// it is added and the ID of the newly added string is returned. /// - public uint GetStringId(string str) { - if (StringTable.ContainsKey(str)) { - return StringTable[str]; + public uint GetStringId(string s, StringKind kind) { + uint id; + if (StringTableLookup.TryGetValue(s, out id)) { + return id; } - uint newId = (uint)StringTable.Count; - StringTable[str] = newId; - return newId; + id = (uint)StringTable.Count; + bool isUTF16 = !s.All(char.IsAscii); + StringTable.Add(new StringTableEntry(kind, s, isUTF16)); + StringTableLookup[s] = id; + + return id; } /// /// Parses all the data tokens and assembles them into data. /// public void Assemble() { - foreach (HasmToken token in Stream.ReadTokens()) { - if (token is HasmDataDeclarationToken data) { - HasmDataDeclarationType type = data.DataType; - uint labelIndex = data.Label.LabelIndex.GetValueAsUInt32(); - - HasmAssemblerDataBuffer buffer = GetBufferByName(data.Label.LabelType); - buffer.HasmBuffer[labelIndex] = buffer.RawBuffer.Count; - - HbcDataBufferTagType tagType = type switch { - HasmDataDeclarationType.Null => HbcDataBufferTagType.Null, - HasmDataDeclarationType.True => HbcDataBufferTagType.True, - HasmDataDeclarationType.False => HbcDataBufferTagType.False, - HasmDataDeclarationType.String => HbcDataBufferTagType.ByteString, // this gets overwritten depending on the string offsets - HasmDataDeclarationType.Number => HbcDataBufferTagType.Number, - HasmDataDeclarationType.Integer => HbcDataBufferTagType.Integer, - _ => throw new Exception("invalid declaration type") - }; - - if (type == HasmDataDeclarationType.String) { - List ids = data.Data.Cast().Select(str => GetStringId(str.Value)).ToList(); - foreach (uint id in ids) { - if (id > ushort.MaxValue) { - tagType = HbcDataBufferTagType.LongString; - break; - } else if (id > byte.MaxValue) { - tagType = HbcDataBufferTagType.ShortString; - } + foreach (HasmDataDeclaration data in Program.Data) { + HasmDataDeclarationKind kind = data.Kind; + uint labelIndex = data.Label.Index.GetValueAsUInt32(); + + HasmAssemblerDataBuffer buffer = GetBufferByName(data.Label.Kind); + buffer.HasmBuffer[labelIndex] = buffer.RawBuffer.Position; + + HbcDataBufferTagType tagType = kind switch { + HasmDataDeclarationKind.Null => HbcDataBufferTagType.Null, + HasmDataDeclarationKind.True => HbcDataBufferTagType.True, + HasmDataDeclarationKind.False => HbcDataBufferTagType.False, + HasmDataDeclarationKind.String => HbcDataBufferTagType.ByteString, // this gets overwritten depending on the string offsets + HasmDataDeclarationKind.Number => HbcDataBufferTagType.Number, + HasmDataDeclarationKind.Integer => HbcDataBufferTagType.Integer, + _ => throw new Exception("invalid declaration type") + }; + + if (kind == HasmDataDeclarationKind.String) { + IEnumerable ids = data.Elements.Cast().Select(str => GetStringId(str.Value, StringKind.Literal)); + foreach (uint id in ids) { + if (id > ushort.MaxValue) { + tagType = HbcDataBufferTagType.LongString; + break; + } else if (id > byte.MaxValue) { + tagType = HbcDataBufferTagType.ShortString; } } + } - using MemoryStream ms = new MemoryStream(); - using BinaryWriter bw = new BinaryWriter(ms); - - const byte TAG_MASK = 0x70; - if (data.Data.Count > 0x0F) { - byte keyTag = (byte)(((byte)tagType | (byte)(data.Data.Count >> 8) | 0x80) & TAG_MASK); - bw.Write(keyTag); - bw.Write((byte) (data.Data.Count & 0xFF)); - } else { - byte keyTag = (byte)(((byte)tagType | (byte)data.Data.Count) & TAG_MASK); - bw.Write(keyTag); - } + const byte TAG_MASK = 0x70; + if (data.Count > 0x0F) { + byte keyTag = (byte)(((byte)tagType | (byte)(data.Count >> 8) | 0x80) & TAG_MASK); + buffer.BufferWriter.Write(keyTag); + buffer.BufferWriter.Write((byte)(data.Count & 0xFF)); + } else { + byte keyTag = (byte)(((byte)tagType | (byte)data.Count) & TAG_MASK); + buffer.BufferWriter.Write(keyTag); + } - foreach (HasmLiteralToken literal in data.Data) { + if (data.Elements != null) { + foreach (HasmLiteralToken literal in data.Elements) { + uint id = uint.MaxValue; if (literal is HasmIntegerToken integer) { - bw.Write(integer.GetValueAsInt32()); + buffer.BufferWriter.Write(integer.GetValueAsInt32()); + continue; } else if (literal is HasmNumberToken number) { - bw.Write(number.Value); + buffer.BufferWriter.Write(number.Value); + continue; } else if (literal is HasmStringToken str) { - uint id = GetStringId(str.Value); + id = GetStringId(str.Value, StringKind.Literal); + } else if (literal is HasmIdentifierToken ident) { + id = GetStringId(ident.Value, StringKind.Identifier); + } + + if (id != uint.MaxValue) { if (tagType == HbcDataBufferTagType.ByteString) { - bw.Write((byte)id); + buffer.BufferWriter.Write((byte)id); } else if (tagType == HbcDataBufferTagType.ShortString) { - bw.Write((ushort)id); + buffer.BufferWriter.Write((ushort)id); } else if (tagType == HbcDataBufferTagType.LongString) { - bw.Write(id); + buffer.BufferWriter.Write(id); } else { throw new Exception("invalid tag type"); } @@ -165,9 +186,6 @@ public void Assemble() { // the length of the data represents the amount of constant values in the buffer // and since those values are constant they don't need to be written } - - byte[] dataArray = ms.ToArray(); - buffer.RawBuffer.AddRange(dataArray); } } } diff --git a/hasmer/libhasmer/Assembler/Visitor/FunctionAssembler.cs b/hasmer/libhasmer/Assembler/Visitor/FunctionAssembler.cs index 524dc2f..23370bd 100644 --- a/hasmer/libhasmer/Assembler/Visitor/FunctionAssembler.cs +++ b/hasmer/libhasmer/Assembler/Visitor/FunctionAssembler.cs @@ -19,7 +19,7 @@ public class FunctionAssembler { /// /// The token stream that reads Hasm tokens from the source code. /// - private HasmTokenStream Stream; + private IEnumerable Stream; /// /// The functions that are declared in the file. @@ -29,33 +29,93 @@ public class FunctionAssembler { /// /// Creates a new function assembler instance. /// - public FunctionAssembler(HbcAssembler hbcAssembler, HasmTokenStream stream) { + public FunctionAssembler(HbcAssembler hbcAssembler, IEnumerable stream) { Functions = new List(); HbcAssembler = hbcAssembler; Stream = stream; } - private void OptimizeInstruction(ref HbcInstructionDefinition def, HasmInstructionToken token) { + private bool DoesVariantFit(HbcInstructionDefinition concreteVariant, HasmInstructionToken insn) { + // Console.WriteLine($" DoesVariantFit(concreteVariant = {concreteVariant.Name}, insn = {insn.Instruction})"); + + for (int i = 0; i < concreteVariant.OperandTypes.Count; i++) { + HasmOperandToken operand = insn.Operands[i]; + HbcInstructionOperandType type = concreteVariant.OperandTypes[i]; + + // Console.WriteLine($" {i}: OperandType = {operand.OperandType}, type = {type}"); + + switch (operand.OperandType) { + case HasmOperandTokenType.String: + case HasmOperandTokenType.Identifier: + uint stringId = HbcAssembler.DataAssembler.GetStringId(operand.Value.GetValue(), operand.OperandStringKind); + // Console.WriteLine($" {i}: stringId = {stringId}, type = {type}"); + if (!type.CanStoreInteger(stringId)) { + // Console.WriteLine($" {i}: CanStoreInteger FAILED"); + return false; + } + break; + case HasmOperandTokenType.Register: + case HasmOperandTokenType.Label: + case HasmOperandTokenType.UInt: + ulong value = operand.Value.GetIntegerValue(); + if (!type.CanStoreInteger(value)) { + return false; + } + break; + default: + break; + } + } + + return true; + } + + private HbcInstructionDefinition OptimizeInstruction(HbcInstructionDefinition def, HasmInstructionToken insn) { if (def.AbstractDefinition == null) { - return; + return def; } - HbcAbstractInstructionDefinition abstractDef = HbcAssembler.Header.Format.AbstractDefinitions[def.AbstractDefinition.Value]; - List concreteVariants = abstractDef.Variants.Select(variantId => HbcAssembler.Header.Format.Definitions[(int)variantId]).ToList(); + HbcAbstractInstructionDefinition abstractDef = HbcAssembler.File.BytecodeFormat.AbstractDefinitions[def.AbstractDefinition.Value]; + List concreteVariants = abstractDef.VariantOpcodes.Select(variantId => HbcAssembler.File.BytecodeFormat.Definitions[(int)variantId]).ToList(); + List validVariants = new List(concreteVariants.Count); + foreach (HbcInstructionDefinition concreteVariant in concreteVariants) { - throw new Exception("TODO: OptimizeInstruction"); + if (DoesVariantFit(concreteVariant, insn)) { + validVariants.Add(concreteVariant); + } + } + + if (validVariants.Count == 0) { + throw new HasmParserException(insn, "no concrete defintions for variant exist for provided arguments"); } + + validVariants.Sort((a, b) => a.TotalSize - b.TotalSize); + + return validVariants[0]; } private void WriteInstruction(BinaryWriter writer, HasmInstructionToken insn) { string insnName = insn.Instruction; - HbcInstructionDefinition def = HbcAssembler.Header.Format.Definitions.Find(def => def.Name == insnName); + HbcInstructionDefinition def = HbcAssembler.File.BytecodeFormat.Definitions.Find(def => def.Name == insnName); if (def == null) { - throw new HasmParserException(insn.Line, insn.Column, $"unknown instruction: {insnName}"); + throw new HasmParserException(insn, $"unknown instruction: {insnName}"); + } + + if (!HbcAssembler.IsExact) { + // add indentifier cache operands if not in exact mode + if (insnName == "TryGetById" || insnName == "GetById" || insnName == "TryPutById" || insnName == "PutById") { + // insert a cache index of 0 as the third operand + insn.Operands.Insert(2, new HasmOperandToken(null) { + OperandType = HasmOperandTokenType.UInt, + Value = new PrimitiveValue((byte)0), + }); + } + + def = OptimizeInstruction(def, insn); } - if (!HbcAssembler.Header.IsExact) { - OptimizeInstruction(ref def, insn); + if (def.OperandTypes.Count != insn.Operands.Count) { + throw new HasmParserException(insn, $"expecting {def.OperandTypes.Count} operands but got {insn.Operands.Count}"); } writer.Write((byte)def.Opcode); @@ -65,7 +125,7 @@ private void WriteInstruction(BinaryWriter writer, HasmInstructionToken insn) { HbcInstructionOperandType type = def.OperandTypes[i]; if (operand.Value.TypeCode == TypeCode.String) { - uint stringId = HbcAssembler.DataAssembler.GetStringId(operand.Value.GetValue()); + uint stringId = HbcAssembler.DataAssembler.GetStringId(operand.Value.GetValue(), operand.OperandStringKind); if (type == HbcInstructionOperandType.UInt8S) { if (stringId > byte.MaxValue) { throw new Exception("string ID cannot fit into UInt8"); @@ -82,9 +142,13 @@ private void WriteInstruction(BinaryWriter writer, HasmInstructionToken insn) { } operand.Value = new PrimitiveValue(stringId); // convert string to ID } - } else if (type == HbcInstructionOperandType.Addr8 || type == HbcInstructionOperandType.Reg8 || type == HbcInstructionOperandType.UInt8) { + } else if (type == HbcInstructionOperandType.Addr8) { + writer.Write(operand.Value.GetValue()); + } else if (type == HbcInstructionOperandType.Reg8 || type == HbcInstructionOperandType.UInt8) { writer.Write(operand.Value.GetValue()); - } else if (type == HbcInstructionOperandType.Addr32 || type == HbcInstructionOperandType.Reg32 || type == HbcInstructionOperandType.UInt32 || type == HbcInstructionOperandType.Imm32) { + } else if (type == HbcInstructionOperandType.Addr32) { + writer.Write(operand.Value.GetValue()); + } else if (type == HbcInstructionOperandType.Reg32 || type == HbcInstructionOperandType.UInt32 || type == HbcInstructionOperandType.Imm32) { writer.Write(operand.Value.GetValue()); } else if (type == HbcInstructionOperandType.UInt16) { writer.Write(operand.Value.GetValue()); @@ -103,7 +167,7 @@ private byte[] BuildBytecode() { using MemoryStream ms = new MemoryStream(); using BinaryWriter writer = new BinaryWriter(ms); - HbcFile file = HbcAssembler.FileBuilder.File; + HbcFile file = HbcAssembler.File; foreach (HbcFunctionBuilder builder in Functions) { file.SmallFuncHeaders[builder.FunctionId].Offset = (uint)ms.Position; foreach (HasmInstructionToken insn in builder.Instructions) { @@ -144,36 +208,54 @@ private void AssembleFunction(HasmFunctionToken func, HbcFunctionBuilder builder } public void Assemble() { - HbcFile file = HbcAssembler.FileBuilder.File; + HbcFile file = HbcAssembler.File; - foreach (HasmToken token in Stream.ReadTokens()) { + Console.WriteLine("Parsing functions..."); + foreach (HasmToken token in Stream) { if (token is HasmFunctionToken func) { HbcFunctionBuilder builder = new HbcFunctionBuilder { - FunctionName = func.FunctionName, + FunctionName = func.Name.Value, FunctionId = uint.MaxValue, EnvironmentSize = uint.MaxValue, - FrameSize = uint.MaxValue, ParamCount = uint.MaxValue, + FrameSize = uint.MaxValue, Flags = HbcFuncHeaderFlags.ProhibitNone, Instructions = new List() }; AssembleFunction(func, builder); - file.SmallFuncHeaders[builder.FunctionId] = new HbcSmallFuncHeader { - DeclarationFile = file, - FunctionName = HbcAssembler.DataAssembler.GetStringId(builder.FunctionName), - FunctionId = builder.FunctionId, - EnvironmentSize = builder.EnvironmentSize, - FrameSize = builder.FrameSize, - ParamCount = builder.ParamCount, - Flags = builder.Flags, - }; + if (builder.FunctionId == uint.MaxValue) { + throw new Exception($"function <{builder.FunctionName}> is missing a '.id' declaration"); + } + if (builder.ParamCount == uint.MaxValue) { + throw new Exception($"function <{builder.FunctionName}> is missing a '.params' declaration"); + } + if (builder.FrameSize == uint.MaxValue) { + throw new Exception($"function <{builder.FunctionName}> is missing a '.registers' declaration"); + } + if (builder.EnvironmentSize == uint.MaxValue) { + throw new Exception($"function <{builder.FunctionName}> is missing a '.symbols' declaration"); + } Functions.Add(builder); } } + file.SmallFuncHeaders = new HbcSmallFuncHeader[Functions.Count]; + foreach (HbcFunctionBuilder builder in Functions) { + file.SmallFuncHeaders[builder.FunctionId] = new HbcSmallFuncHeader { + DeclarationFile = file, + FunctionName = HbcAssembler.DataAssembler.GetStringId(builder.FunctionName, StringKind.Identifier), + FunctionId = builder.FunctionId, + EnvironmentSize = builder.EnvironmentSize, + FrameSize = builder.FrameSize, + ParamCount = builder.ParamCount, + Flags = builder.Flags, + }; + } + + Console.WriteLine("Building bytecode..."); file.Instructions = BuildBytecode(); } } diff --git a/hasmer/libhasmer/Common/ConsoleProgressBar.cs b/hasmer/libhasmer/Common/ConsoleProgressBar.cs new file mode 100644 index 0000000..e770d93 --- /dev/null +++ b/hasmer/libhasmer/Common/ConsoleProgressBar.cs @@ -0,0 +1,91 @@ +using System; +using System.Text; +using System.Threading; + +namespace Hasmer { + /// + /// Taken from https://gist.github.com/DanielSWolf/0ab6a96899cc5377bf54 + /// + public class ConsoleProgressBar : IDisposable, IProgress { + private const int blockCount = 40; + private readonly TimeSpan animationInterval = TimeSpan.FromSeconds(1.0 / 10); + private const string animation = @"|/-\"; + + private readonly Timer timer; + + private double currentProgress = 0; + private string currentText = string.Empty; + private bool disposed = false; + private int animationIndex = 0; + + public ConsoleProgressBar() { + timer = new Timer(TimerHandler); + + // A progress bar is only for temporary display in a console window. + // If the console output is redirected to a file, draw nothing. + // Otherwise, we'll end up with a lot of garbage in the target file. + if (!Console.IsOutputRedirected) { + ResetTimer(); + } + } + + public void Report(double value) { + // Make sure value is in [0..1] range + value = Math.Max(0, Math.Min(1, value)); + Interlocked.Exchange(ref currentProgress, value); + } + + private void TimerHandler(object state) { + lock (timer) { + if (disposed) return; + + int progressBlockCount = (int)(currentProgress * blockCount); + int percent = (int)(currentProgress * 100); + string text = string.Format("[{0}{1}] {2,3}% {3}", + new string('#', progressBlockCount), new string('-', blockCount - progressBlockCount), + percent, + animation[animationIndex++ % animation.Length]); + UpdateText(text); + + ResetTimer(); + } + } + + private void UpdateText(string text) { + // Get length of common portion + int commonPrefixLength = 0; + int commonLength = Math.Min(currentText.Length, text.Length); + while (commonPrefixLength < commonLength && text[commonPrefixLength] == currentText[commonPrefixLength]) { + commonPrefixLength++; + } + + // Backtrack to the first differing character + StringBuilder outputBuilder = new StringBuilder(); + outputBuilder.Append('\b', currentText.Length - commonPrefixLength); + + // Output new suffix + outputBuilder.Append(text.Substring(commonPrefixLength)); + + // If the new text is shorter than the old one: delete overlapping characters + int overlapCount = currentText.Length - text.Length; + if (overlapCount > 0) { + outputBuilder.Append(' ', overlapCount); + outputBuilder.Append('\b', overlapCount); + } + + Console.Write(outputBuilder); + currentText = text; + } + + private void ResetTimer() { + timer.Change(animationInterval, TimeSpan.FromMilliseconds(-1)); + } + + public void Dispose() { + lock (timer) { + disposed = true; + UpdateText(string.Empty); + } + } + } +} diff --git a/hasmer/libhasmer/Common/HbcAbstractInstructionDefinition.cs b/hasmer/libhasmer/Common/HbcAbstractInstructionDefinition.cs new file mode 100644 index 0000000..44dbb22 --- /dev/null +++ b/hasmer/libhasmer/Common/HbcAbstractInstructionDefinition.cs @@ -0,0 +1,32 @@ +using System.Collections.Generic; +using Newtonsoft.Json; + +namespace Hasmer { + /// + /// Represents the abstract form of variant instructions. + /// Variant instructions are instructions which perform the same action, but can have differently sized operands. + /// By abstracting these instructions to all have one name, the assembler can optimize the size of the operands. + /// Thus, programmers do not have to figure out the proper sizes when they write Hasm code. + ///

+ /// Passing the "--exact" flag to the hasmer disassmbler will ignore abstract definitions, + /// and instead emit the exact instruction. + /// + public class HbcAbstractInstructionDefinition { + /// + /// The abstract name that can be used to represent any of the . + ///
+ /// For example, the instructions "JStrictNotEqual" and "JStrictNotEqualLong" + /// will have an abstract name of simply "JStrictNotEqual". + ///
+ /// The assembler will decide which to use based on the operands at assemble time. + /// + [JsonProperty] + public string Name { get; set; } + + /// + /// The opcodes of each variant that can be defined by this abstract definition. + /// + [JsonProperty] + public List VariantOpcodes { get; set; } + } +} diff --git a/hasmer/libhasmer/Common/HbcBytecodeFormat.cs b/hasmer/libhasmer/Common/HbcBytecodeFormat.cs index e45fd2d..ec6c982 100644 --- a/hasmer/libhasmer/Common/HbcBytecodeFormat.cs +++ b/hasmer/libhasmer/Common/HbcBytecodeFormat.cs @@ -3,126 +3,12 @@ using System.Linq; using System.Text; using System.Threading.Tasks; +using System.Runtime.Serialization; using Newtonsoft.Json; using Newtonsoft.Json.Linq; -using System.Runtime.Serialization; using Newtonsoft.Json.Converters; namespace Hasmer { - /// - /// Represents the type of an operand. - /// - [JsonConverter(typeof(StringEnumConverter))] - public enum HbcInstructionOperandType { - /// - /// The operand is a one-byte register reference. - /// - Reg8, - /// - /// The operand is a four-byte register reference. - /// - Reg32, - /// - /// The operand is an unsigned byte. - /// - UInt8, - /// - /// The operand is an unsigned two-byte integer. - /// - UInt16, - /// - /// The operand is an unsigned four-byte integer. - /// - UInt32, - /// - /// The operand is a one-byte code address reference. - /// - Addr8, - /// - /// The operand is a four-byte code address reference. - /// - Addr32, - /// - /// The operand is a four-byte unsigned integer. - /// - Imm32, - /// - /// The operand is an eight-byte IEEE754 floating-point value. - /// - Double, - /// - /// The operand is a one-byte reference to the string table. - /// - UInt8S, - /// - /// The operand is a two-byte reference to the string table. - /// - UInt16S, - /// - /// The operand is a four-byte reference to the string table. - /// - UInt32S - } - - /// - /// Represents the definition of an instruction in a JSON bytecode definitions file. - /// - public class HbcInstructionDefinition { - /// - /// The opcode of the instruction in the binary. - /// - [JsonProperty] - public int Opcode { get; set; } - /// - /// The human-readable name of the instruction. - /// - [JsonProperty] - public string Name { get; set; } - /// - /// The types of all the operands the operand handles. - /// - [JsonProperty] - public List OperandTypes { get; set; } - /// - /// true if the operation is a jumping instruction (i.e. changes the current instruction being executed), or otherwise false. - /// - [JsonProperty] - public bool IsJump { get; set; } - /// - /// The index in the abstract definition table of the abstract form of the instruction, or null if the instruction does not have an abstract form. - /// - [JsonProperty] - public int? AbstractDefinition { get; set; } - } - - /// - /// Represents the abstract form of variant instructions. - /// Variant instructions are instructions which perform the same action, but can have differently sized operands. - /// By abstracting these instructions to all have one name, the assembler can optimize the size of the operands. - /// Thus, programmers do not have to figure out the proper sizes when they write Hasm code. - ///

- /// Passing the "--exact" flag to the hasmer disassmbler will ignore abstract definitions, - /// and instead emit the exact instruction. - /// - public class HbcAbstractInstructionDefinition { - /// - /// The abstract name that can be used to represent any of the . - ///
- /// For example, the instructions "JStrictNotEqual" and "JStrictNotEqualLong" - /// will have an abstract name of simply "JStrictNotEqual". - ///
- /// The assembler will decide which to use based on the operands at assemble time. - /// - [JsonProperty] - public string Name { get; set; } - - /// - /// The opcodes of each variant that can be defined by this abstract definition. - /// - [JsonProperty] - public List Variants { get; set; } - } - /// /// Represents a definition of the bytecode operations for a given Hermes version. ///
diff --git a/hasmer/libhasmer/Common/HbcDataBuffer.cs b/hasmer/libhasmer/Common/HbcDataBuffer.cs index 40aaecd..60cad8a 100644 --- a/hasmer/libhasmer/Common/HbcDataBuffer.cs +++ b/hasmer/libhasmer/Common/HbcDataBuffer.cs @@ -32,6 +32,10 @@ public class HbcDataBufferPrefix { /// The type of the data in the data buffer. /// public HbcDataBufferTagType TagType { get; set; } + + public override string ToString() { + return $"{TagType.ToString()} x {Length}"; + } } /// @@ -80,8 +84,10 @@ public List ReadAll(HbcFile source) { uint offset = (uint)ms.Position; HbcDataBufferPrefix prefix = ReadTagType(reader); PrimitiveValue[] values = new PrimitiveValue[prefix.Length]; + // Console.WriteLine(" prefix: " + prefix.ToString()); for (int i = 0; i < values.Length; i++) { values[i] = ReadValue(source, prefix.TagType, reader); + // Console.WriteLine(" Read value: " + values[i].ToString()); } itemsList.Add(new HbcDataBufferItems { Prefix = prefix, @@ -101,7 +107,7 @@ public void WriteAll(BinaryWriter writer) { } /// - /// Disassembles a single HbcDataBufferItems from an offset in the data buffer (i.e. from an instruction operand). + /// Disassembles a single HbcDataBufferItems from an offset in the data buffer (e.g. from an instruction operand). /// public HbcDataBufferItems Read(HbcFile source, uint offset) { using MemoryStream ms = new MemoryStream(Buffer); @@ -126,9 +132,9 @@ public HbcDataBufferItems Read(HbcFile source, uint offset) { private PrimitiveValue ReadValue(HbcFile source, HbcDataBufferTagType tagType, BinaryReader reader) { // new PrimitiveValue made for each switch to preserve the PrimitiveValue type tagging mechanism for numbers return tagType switch { - HbcDataBufferTagType.ByteString => new PrimitiveValue(source.StringTable[reader.ReadByte()]), - HbcDataBufferTagType.ShortString => new PrimitiveValue(source.StringTable[reader.ReadUInt16()]), - HbcDataBufferTagType.LongString => new PrimitiveValue(source.StringTable[reader.ReadUInt32()]), + HbcDataBufferTagType.ByteString => new PrimitiveValue(source.GetStringTableEntry((int)reader.ReadByte()).Value), + HbcDataBufferTagType.ShortString => new PrimitiveValue(source.GetStringTableEntry((int)reader.ReadUInt16()).Value), + HbcDataBufferTagType.LongString => new PrimitiveValue(source.GetStringTableEntry((int)reader.ReadUInt32()).Value), HbcDataBufferTagType.Number => new PrimitiveValue(reader.ReadDouble()), HbcDataBufferTagType.Integer => new PrimitiveValue(reader.ReadInt32()), HbcDataBufferTagType.Null => new PrimitiveValue(null), diff --git a/hasmer/libhasmer/Common/HbcEncodedItem.cs b/hasmer/libhasmer/Common/HbcEncodedItem.cs index 7732cc5..85f577b 100644 --- a/hasmer/libhasmer/Common/HbcEncodedItem.cs +++ b/hasmer/libhasmer/Common/HbcEncodedItem.cs @@ -15,52 +15,45 @@ public abstract class HbcEncodedItem { /// /// Converts the name of a type in JSON to the .NET type. /// - private static Type GetTypeFromName(string name) { - switch (name) { - case "UInt8": - return typeof(byte); - case "UInt16": - return typeof(ushort); - case "UInt32": - return typeof(uint); - case "UInt64": - return typeof(ulong); - default: - throw new InvalidDataException("bad type: " + name); - } - } + private static Type GetTypeFromName(string name) => name switch { + "UInt8" => typeof(byte), + "UInt16" => typeof(ushort), + "UInt32" => typeof(uint), + "UInt64" => typeof(ulong), + _ => throw new InvalidDataException("bad type: " + name), + }; /// /// Reads a value from the buffer given the type of the value. /// - private static object ReadType(HbcReader reader, string type) { - if (type == "UInt8") { - return reader.ReadByte(); - } else if (type == "UInt16") { - return reader.ReadUInt16(); - } else if (type == "UInt32") { - return reader.ReadUInt32(); - } else if (type == "UInt64") { - return reader.ReadUInt64(); - } else { - throw new InvalidDataException("bad type: " + type); - } - } + private static object ReadType(HbcReader reader, string type) => type switch { + // the explicit cast to object is necessary, the C# compiler casts all the values to UInt64 before casting to object + "UInt8" => (object)reader.ReadByte(), + "UInt16" => (object)reader.ReadUInt16(), + "UInt32" => (object)reader.ReadUInt32(), + "UInt64" => (object)reader.ReadUInt64(), + _ => throw new InvalidDataException("bad type: " + type), + }; /// /// Writes a value to the buffer given the type. /// private static void WriteType(HbcWriter writer, string type, object value) { - if (type == "UInt8") { - writer.Write((byte)value); - } else if (type == "UInt16") { - writer.Write((ushort)value); - } else if (type == "UInt32") { - writer.Write((uint)value); - } else if (type == "UInt64") { - writer.Write((ulong)value); - } else { - throw new InvalidDataException("bad type: " + type); + switch (type) { + case "UInt8": + writer.Write((byte)value); + break; + case "UInt16": + writer.Write((ushort)value); + break; + case "UInt32": + writer.Write((uint)value); + break; + case "UInt64": + writer.Write((ulong)value); + break; + default: + throw new InvalidDataException("bad type: " + type); } } @@ -139,7 +132,12 @@ public static object ReadFromDefinition(HbcReader reader, JToken def) { foreach (JProperty property in obj.Properties()) { PropertyInfo info = typeof(T).GetProperty(property.Name, BindingFlags.Public | BindingFlags.Instance); object value = ReadFromDefinition(reader, property.Value); - info.SetValue(decoded, value); + try { + info.SetValue(decoded, value); + } catch (Exception e) { + Console.WriteLine($"Failed to set {info.PropertyType.FullName} property '{typeof(T).FullName}.{property.Name}' (expecting {property.Value}, read {value.GetType().FullName} {value}): {e}"); + Environment.Exit(1); + } } return decoded; diff --git a/hasmer/libhasmer/Common/HbcFile.cs b/hasmer/libhasmer/Common/HbcFile.cs index 62fad5b..f7daaf5 100644 --- a/hasmer/libhasmer/Common/HbcFile.cs +++ b/hasmer/libhasmer/Common/HbcFile.cs @@ -10,6 +10,8 @@ namespace Hasmer { /// Represents a parsed Hermes bytecode file. /// public class HbcFile { + const uint MAX_STRING_LENGTH = 0xFF; + /// /// The header of the file. /// @@ -56,15 +58,10 @@ public class HbcFile { /// public uint InstructionOffset { get; set; } - /// - /// The types of the strings in the string table. - /// - public StringKind[] StringKinds { get; set; } - /// /// The parsed string table. Index = string index (i.e. from an operand, etc.), Value = string at that index. /// - public string[] StringTable { get; private set; } + public StringTableEntry[] StringTable { get; set; } /// /// Creates a new bytecode file (probably to be writen out). Does not parse anything. @@ -101,43 +98,43 @@ public HbcFile(HbcReader reader) { } SmallFuncHeaders[i] = header; } - reader.Align(); - Console.WriteLine(Header.StringCount); - Console.WriteLine(Header.StringKindCount); - Console.WriteLine(Header.IdentifierCount); - + StringKindEntry[] stringKinds = new StringKindEntry[Header.StringKindCount]; for (uint i = 0; i < Header.StringKindCount; i++) { - uint stringKind = reader.ReadUInt32(); - Console.WriteLine(Convert.ToString(stringKind, 2)); + stringKinds[i] = new StringKindEntry(reader.ReadUInt32()); } - reader.Align(); + uint[] identifierHashes = new uint[Header.IdentifierCount]; for (uint i = 0; i < Header.IdentifierCount; i++) { - uint identifier = reader.ReadUInt32(); - Console.WriteLine(Convert.ToString(identifier, 2)); + identifierHashes[i] = reader.ReadUInt32(); } reader.Align(); + Console.WriteLine($" rSmallStrings @ {reader.BaseStream.Position}"); + HbcSmallStringTableEntry[] smallStringTable = new HbcSmallStringTableEntry[Header.StringCount]; for (int i = 0; i < Header.StringCount; i++) { smallStringTable[i] = HbcEncodedItem.Decode(reader, (JObject)def["SmallStringTableEntry"]); } - reader.Align(); HbcOverflowStringTableEntry[] overflowStringTable = new HbcOverflowStringTableEntry[Header.OverflowStringCount]; for (int i = 0; i < Header.OverflowStringCount; i++) { overflowStringTable[i] = HbcEncodedItem.Decode(reader, (JObject)def["OverflowStringTableEntry"]); } - reader.Align(); byte[] stringStorage = reader.ReadBytes((int)Header.StringStorageSize); reader.Align(); + // TODO: find the actual bytecode version that BigIntTable was added + if (Header.Version >= 100) { + // TODO: parse the BigIntTable + throw new Exception("BigIntTable not yet implemented"); + } + ArrayBuffer = new HbcDataBuffer(reader.ReadBytes((int)Header.ArrayBufferSize)); reader.Align(); @@ -163,14 +160,13 @@ public HbcFile(HbcReader reader) { HbcCjsModuleTableEntry entry = HbcEncodedItem.Decode(reader, (JObject)def["CjsModuleTableEntry"]); CjsModuleTable[i] = entry; } - reader.Align(); InstructionOffset = (uint)reader.BaseStream.Position; Instructions = new byte[reader.BaseStream.Length - reader.BaseStream.Position]; reader.BaseStream.Read(Instructions, 0, Instructions.Length); - CreateStringTable(stringStorage, smallStringTable, overflowStringTable); + CreateStringTable(stringStorage, smallStringTable, overflowStringTable, stringKinds, identifierHashes); BytecodeFormat = ResourceManager.ReadEmbeddedResource($"Bytecode{Header.Version}"); } @@ -179,32 +175,134 @@ public HbcFile(HbcReader reader) { /// Writes the Hermes bytecode file and serializes it to a byte array. /// public byte[] Write() { + Header.StringCount = (uint)StringTable.Length; + Header.StringKindCount = 0; + Header.IdentifierCount = 0; + Header.OverflowStringCount = 0; + Header.StringStorageSize = 0; + Header.ArrayBufferSize = (uint)ArrayBuffer.Buffer.Length; + Header.ObjKeyBufferSize = (uint)ObjectKeyBuffer.Buffer.Length; + Header.ObjValueBufferSize = (uint)ObjectValueBuffer.Buffer.Length; + Header.FunctionCount = (uint)SmallFuncHeaders.Length; + JObject def = ResourceManager.LoadJsonObject("BytecodeFileFormat"); using MemoryStream ms = new MemoryStream(); using HbcWriter writer = new HbcWriter(ms); - // write the initial header -- some of these values get overwritten when we rewrite the header as the last step + // write the initial header -- these values get overwritten when we rewrite the header as the last step HbcEncodedItem.Encode(writer, (JObject)def["Header"], Header); writer.Align(); - for (uint i = 0; i < Header.FunctionCount; i++) { - HbcEncodedItem.Encode(writer, (JObject)def["SmallFuncHeader"], SmallFuncHeaders[i]); + + foreach (HbcSmallFuncHeader header in SmallFuncHeaders) { + HbcEncodedItem.Encode(writer, (JObject)def["SmallFuncHeader"], header); // TODO: large functions } writer.Align(); - // write string kind count - foreach (StringKind kind in StringKinds) { + // write string kinds + if (StringTable.Length > 0) { + StringKind currentKind = StringTable[0].Kind; + uint currentCount = 1; + for (uint i = 1; i < StringTable.Length; i++) { + StringTableEntry entry = StringTable[i]; + if (entry.Kind == currentKind) { + currentCount++; + } else { + writer.Write(new StringKindEntry(currentKind, currentCount).Entry); + + Header.StringKindCount++; + currentKind = entry.Kind; + currentCount = 1; + } + } + // make sure to write the last run of string kinds + writer.Write(new StringKindEntry(currentKind, currentCount).Entry); } - // write identifier count + // write identifier hashes + for (uint i = 0; i < StringTable.Length; i++) { + StringTableEntry entry = StringTable[i]; + if (entry.IsIdentifier) { + writer.Write(entry.Hash); + Header.IdentifierCount++; + } + } + writer.Align(); + + // encode all strings, indexable by their ID + byte[][] encodedStrings = new byte[StringTable.Length][]; + uint[] encodedStringsAreUTF16 = new uint[StringTable.Length]; + for (uint i = 0; i < StringTable.Length; i++) { + StringTableEntry ste = StringTable[i]; + byte[] encoded = ste.Encoded; + encodedStrings[i] = encoded; + encodedStringsAreUTF16[i] = ste.IsUTF16 ? 1u : 0u; + + if (encoded.Length >= MAX_STRING_LENGTH) { + Header.OverflowStringCount++; + } + Header.StringStorageSize += (uint)encoded.Length; + } + + // construct the contiguous string storage, small string table, and large + byte[] stringStorage = new byte[Header.StringStorageSize]; + HbcSmallStringTableEntry[] smallStrings = new HbcSmallStringTableEntry[StringTable.Length]; + HbcOverflowStringTableEntry[] overflowStrings = new HbcOverflowStringTableEntry[Header.OverflowStringCount]; + uint stringStorageOffset = 0; + uint overflowOffset = 0; + for (uint i = 0; i < StringTable.Length; i++) { + byte[] encoded = encodedStrings[i]; + uint isUTF16 = encodedStringsAreUTF16[i]; + uint encodingDivisor = isUTF16 == 0u ? 1u : 2u; + + HbcSmallStringTableEntry sste; + if (encoded.Length >= MAX_STRING_LENGTH) { + sste = new HbcSmallStringTableEntry { + IsUTF16 = isUTF16, + Offset = overflowOffset, + Length = MAX_STRING_LENGTH, + }; + + overflowStrings[overflowOffset] = new HbcOverflowStringTableEntry { + Offset = stringStorageOffset, + Length = (uint)encoded.Length / encodingDivisor, + }; + + overflowOffset++; + } else { + sste = new HbcSmallStringTableEntry { + IsUTF16 = isUTF16, + Offset = stringStorageOffset, + Length = (uint)encoded.Length / encodingDivisor, + }; + } + smallStrings[i] = sste; + + Array.Copy(encoded, 0, stringStorage, stringStorageOffset, encoded.Length); + stringStorageOffset += (uint)encoded.Length / encodingDivisor; + } + + Console.WriteLine($" wSmallStrings @ {ms.Position}"); // write small string table + foreach (HbcSmallStringTableEntry entry in smallStrings) { + HbcEncodedItem.Encode(writer, (JObject)def["SmallStringTableEntry"], entry); + } + writer.Align(); // write overflow string table + foreach (HbcOverflowStringTableEntry entry in overflowStrings) { + HbcEncodedItem.Encode(writer, (JObject)def["OverflowStringTableEntry"], entry); + } + writer.Align(); // write string storage + writer.Write(stringStorage); + writer.Align(); + + // TODO: read BigIntTable // write array buffer ArrayBuffer.WriteAll(writer); @@ -223,7 +321,7 @@ public byte[] Write() { // write cjs modules // write instructions - InstructionOffset = (uint) ms.Position; + InstructionOffset = (uint)ms.Position; writer.Write(Instructions); // re-write the header with the final values after writing the rest of the stream @@ -231,42 +329,71 @@ public byte[] Write() { ms.Position = 0; HbcEncodedItem.Encode(writer, (JObject)def["Header"], Header); + Console.WriteLine($"Wrote HBC!\n IdentifierCount = {Header.IdentifierCount}\n StringCount = {Header.StringCount}"); + ms.Position = Header.FileLength; return ms.ToArray(); } + public StringTableEntry GetStringTableEntry(int index) { + if (index < 0 || index >= StringTable.Length) { + throw new Exception("out of bounds string index: " + index); + } + return StringTable[index]; + } + /// /// Creates a parsed string table from the raw string storage data. /// - private void CreateStringTable(byte[] stringStorage, HbcSmallStringTableEntry[] smallStringTable, HbcOverflowStringTableEntry[] overflowStringTable) { - const uint MAX_STRING_LENGTH = 0xFF; + private void CreateStringTable(byte[] stringStorage, HbcSmallStringTableEntry[] smallStringTable, HbcOverflowStringTableEntry[] overflowStringTable, StringKindEntry[] stringKinds, uint[] identifierHashes) { + Console.WriteLine($"stringStorage.Length = {stringStorage.Length}"); + + StringKind[] kindLookup = new StringKind[smallStringTable.Length]; + int k = 0; + foreach (StringKindEntry entry in stringKinds) { + for (int i = 0; i < entry.Count; i++, k++) { + kindLookup[k] = entry.Kind; + } + } - StringTable = new string[smallStringTable.Length]; + StringTable = new StringTableEntry[smallStringTable.Length]; + int identIdx = 0; for (uint i = 0; i < smallStringTable.Length; i++) { HbcSmallStringTableEntry entry = smallStringTable[(int)i]; uint offset = entry.Offset; uint length = entry.Length; - uint isUTF16 = entry.IsUTF16; + bool isUTF16 = entry.IsUTF16 != 0; + + Console.WriteLine($" offset = {offset}, length = {length}, isUTF16 = {isUTF16}"); if (length >= MAX_STRING_LENGTH) { HbcOverflowStringTableEntry overflow = overflowStringTable[offset]; offset = overflow.Offset; length = overflow.Length; + Console.WriteLine($" overflow; offset = {offset}, length = {length}"); } - if (isUTF16 == 1) { + if (isUTF16) { length *= 2; + Console.WriteLine($" isUTF16; length = {length}"); } byte[] stringBytes = new byte[length]; Array.Copy(stringStorage, offset, stringBytes, 0, length); - string str = isUTF16 switch { - 1 => string.Concat(stringBytes.Select(b => b.ToString("X2"))), - _ => Encoding.UTF8.GetString(stringBytes) - }; - StringTable[i] = str; + StringKind kind = kindLookup[i]; + Encoding enc = isUTF16 ? Encoding.Unicode : Encoding.ASCII; + string str = enc.GetString(stringBytes); + + StringTableEntry stEntry = new StringTableEntry(kind, str, isUTF16); + if (stEntry.IsIdentifier) { + uint hash = identifierHashes[identIdx++]; + if (stEntry.Hash != hash) { + Console.WriteLine($"Warning: identifier '{stEntry.Value}' has invalid hash; expecting {hash} but calculated {stEntry.Hash}"); + } + } + StringTable[i] = stEntry; } } } diff --git a/hasmer/libhasmer/Common/HbcFuncHeader.cs b/hasmer/libhasmer/Common/HbcFuncHeader.cs index 2f036f8..36e37c4 100644 --- a/hasmer/libhasmer/Common/HbcFuncHeader.cs +++ b/hasmer/libhasmer/Common/HbcFuncHeader.cs @@ -46,7 +46,7 @@ public class HbcFuncHeader : HbcEncodedItem { public uint BytecodeSizeInBytes { get; set; } /// - /// The index in the string table of the function's name (i.e. HbcFile.StringTable[FunctionName]). + /// The index in the string table of the function's name (i.e. HbcFile.GetStringTableEntry(FunctionName)). /// public uint FunctionName { get; set; } @@ -95,7 +95,7 @@ public virtual HbcFuncHeader GetAssemblerHeader() { /// public string GetFunctionName(HbcFile source) { HbcSmallFuncHeader func = source.SmallFuncHeaders[FunctionId]; - string functionName = source.StringTable[func.FunctionName]; + string functionName = source.GetStringTableEntry((int)func.FunctionName).Value; if (functionName == "") { return $"$closure${FunctionId}"; } diff --git a/hasmer/libhasmer/Common/HbcInstruction.cs b/hasmer/libhasmer/Common/HbcInstruction.cs index 775c1b4..07d0a8d 100644 --- a/hasmer/libhasmer/Common/HbcInstruction.cs +++ b/hasmer/libhasmer/Common/HbcInstruction.cs @@ -6,127 +6,6 @@ using System.IO; namespace Hasmer { - /// - /// Represents an operand of Hermes bytecode instruction. - /// - public class HbcInstructionOperand { - /// - /// The type of operand that is represented by the object. - /// - public HbcInstructionOperandType Type { get; set; } - - /// - /// The raw value of the object, represented as a PrimitiveValue to preserve type information. - ///
- /// Is is highly recommended to use and - /// instead of accessing this property directly. - /// Use with caution. - /// - public PrimitiveValue Value { get; set; } - - /// - /// Writes the operand to a stream of binary data. - /// - public void ToWriter(BinaryWriter writer) { - switch (Type) { - case HbcInstructionOperandType.Reg8: writer.Write(GetValue()); break; - case HbcInstructionOperandType.Reg32: writer.Write(GetValue()); break; - case HbcInstructionOperandType.UInt8: writer.Write(GetValue()); break; - case HbcInstructionOperandType.UInt16: writer.Write(GetValue()); break; - case HbcInstructionOperandType.UInt32: writer.Write(GetValue()); break; - case HbcInstructionOperandType.Addr8: writer.Write(GetValue()); break; - case HbcInstructionOperandType.Addr32: writer.Write(GetValue()); break; - case HbcInstructionOperandType.Imm32: writer.Write(GetValue()); break; - case HbcInstructionOperandType.Double: writer.Write(GetValue()); break; - case HbcInstructionOperandType.UInt8S: writer.Write(GetValue()); break; - case HbcInstructionOperandType.UInt16S: writer.Write(GetValue()); break; - case HbcInstructionOperandType.UInt32S: writer.Write(GetValue()); break; - default: throw new InvalidOperationException("invalid operand type"); - } - } - - /// - /// Reads the operand from a stream of binary data. - /// - public static HbcInstructionOperand FromReader(BinaryReader reader, HbcInstructionOperandType type) { - object rawValue = type switch { - HbcInstructionOperandType.Reg8 => reader.ReadByte(), - HbcInstructionOperandType.Reg32 => reader.ReadUInt32(), - HbcInstructionOperandType.UInt8 => reader.ReadByte(), - HbcInstructionOperandType.UInt16 => reader.ReadUInt16(), - HbcInstructionOperandType.UInt32 => reader.ReadUInt32(), - HbcInstructionOperandType.Addr8 => reader.ReadSByte(), - HbcInstructionOperandType.Addr32 => reader.ReadInt32(), - HbcInstructionOperandType.Imm32 => reader.ReadUInt32(), - HbcInstructionOperandType.Double => reader.ReadDouble(), - HbcInstructionOperandType.UInt8S => reader.ReadByte(), - HbcInstructionOperandType.UInt16S => reader.ReadUInt16(), - HbcInstructionOperandType.UInt32S => reader.ReadUInt32(), - _ => throw new InvalidOperationException("invalid operand type"), - }; - return new HbcInstructionOperand { - Type = type, - Value = new PrimitiveValue(rawValue) - }; - } - - /// - /// Returns the value as the given type. - /// - public T GetValue() { - return Value.GetValue(); - } - - /// - /// Returns the value, or is the value is a string, the string the value points to. - /// - public T GetResolvedValue(HbcFile file) { - return Type switch { - HbcInstructionOperandType.UInt8S => (T)(object)file.StringTable[GetValue()], - HbcInstructionOperandType.UInt16S => (T)(object)file.StringTable[GetValue()], - HbcInstructionOperandType.UInt32S => (T)(object)file.StringTable[GetValue()], - _ => GetValue() - }; - } - - /// - /// Converts a double to a string, catching edge cases. - /// - private string ToDoubleString(double d) { - if (double.IsNegativeInfinity(d)) { - return "-Infinity"; - } else if (double.IsPositiveInfinity(d)) { - return "Infinity"; - } else if (double.IsNaN(d)) { - return "NaN"; - } - - string format = new string('#', 324); // https://stackoverflow.com/a/14964797 - return d.ToString("0." + format); - } - - /// - /// Converts the operand to a human-readable format used for disassembly. - /// - public string ToDisassembly(HbcFile file) { - return Type switch { - HbcInstructionOperandType.Reg8 => $"r{GetValue()}", - HbcInstructionOperandType.Reg32 => $"r{GetValue()}", - HbcInstructionOperandType.UInt8 => GetValue().ToString(), - HbcInstructionOperandType.UInt16 => GetValue().ToString(), - HbcInstructionOperandType.UInt32 => GetValue().ToString(), - HbcInstructionOperandType.Addr8 => $"Addr8({GetValue()})", - HbcInstructionOperandType.Addr32 => $"Addr32({GetValue()})", - HbcInstructionOperandType.Imm32 => GetValue().ToString(), - HbcInstructionOperandType.Double => ToDoubleString(GetValue()), - HbcInstructionOperandType.UInt8S => $"\"{StringEscape.Escape(file.StringTable[GetValue()])}\"", - HbcInstructionOperandType.UInt16S => $"\"{StringEscape.Escape(file.StringTable[GetValue()])}\"", - HbcInstructionOperandType.UInt32S => $"\"{StringEscape.Escape(file.StringTable[GetValue()])}\"", - _ => throw new InvalidOperationException("invalid operand type"), - }; - } - } - /// /// Represents an instruction in Hermes bytecode. /// diff --git a/hasmer/libhasmer/Common/HbcInstructionDefinition.cs b/hasmer/libhasmer/Common/HbcInstructionDefinition.cs new file mode 100644 index 0000000..6a8855f --- /dev/null +++ b/hasmer/libhasmer/Common/HbcInstructionDefinition.cs @@ -0,0 +1,38 @@ +using System.Collections.Generic; +using System.Linq; +using Newtonsoft.Json; + +namespace Hasmer { + /// + /// Represents the definition of an instruction in a JSON bytecode definitions file. + /// + public class HbcInstructionDefinition { + /// + /// The opcode of the instruction in the binary. + /// + [JsonProperty] + public int Opcode { get; set; } + /// + /// The human-readable name of the instruction. + /// + [JsonProperty] + public string Name { get; set; } + /// + /// The types of all the operands the operand handles. + /// + [JsonProperty] + public List OperandTypes { get; set; } + /// + /// true if the operation is a jumping instruction (i.e. changes the current instruction being executed), or otherwise false. + /// + [JsonProperty] + public bool IsJump { get; set; } + /// + /// The index in the abstract definition table of the abstract form of the instruction, or null if the instruction does not have an abstract form. + /// + [JsonProperty] + public int? AbstractDefinition { get; set; } + + public int TotalSize => 1 + OperandTypes.Select(opType => opType.GetSizeof()).Sum(); + } +} diff --git a/hasmer/libhasmer/Common/HbcInstructionOperand.cs b/hasmer/libhasmer/Common/HbcInstructionOperand.cs new file mode 100644 index 0000000..4262dc5 --- /dev/null +++ b/hasmer/libhasmer/Common/HbcInstructionOperand.cs @@ -0,0 +1,109 @@ +using System; +using System.IO; + +namespace Hasmer { + /// + /// Represents an operand of Hermes bytecode instruction. + /// + public class HbcInstructionOperand { + /// + /// The type of operand that is represented by the object. + /// + public HbcInstructionOperandType Type { get; set; } + + /// + /// The raw value of the object, represented as a PrimitiveValue to preserve type information. + ///
+ /// Is is highly recommended to use and + /// instead of accessing this property directly. + /// Use with caution. + /// + public PrimitiveValue Value { get; set; } + + /// + /// Writes the operand to a stream of binary data. + /// + public void ToWriter(BinaryWriter writer) { + switch (Type) { + case HbcInstructionOperandType.Reg8: writer.Write(GetValue()); break; + case HbcInstructionOperandType.Reg32: writer.Write(GetValue()); break; + case HbcInstructionOperandType.UInt8: writer.Write(GetValue()); break; + case HbcInstructionOperandType.UInt16: writer.Write(GetValue()); break; + case HbcInstructionOperandType.UInt32: writer.Write(GetValue()); break; + case HbcInstructionOperandType.Addr8: writer.Write(GetValue()); break; + case HbcInstructionOperandType.Addr32: writer.Write(GetValue()); break; + case HbcInstructionOperandType.Imm32: writer.Write(GetValue()); break; + case HbcInstructionOperandType.Double: writer.Write(GetValue()); break; + case HbcInstructionOperandType.UInt8S: writer.Write(GetValue()); break; + case HbcInstructionOperandType.UInt16S: writer.Write(GetValue()); break; + case HbcInstructionOperandType.UInt32S: writer.Write(GetValue()); break; + default: throw new InvalidOperationException("invalid operand type"); + } + } + + /// + /// Reads the operand from a stream of binary data. + /// + public static HbcInstructionOperand FromReader(BinaryReader reader, HbcInstructionOperandType type) { + object rawValue = type switch { + HbcInstructionOperandType.Reg8 => reader.ReadByte(), + HbcInstructionOperandType.Reg32 => reader.ReadUInt32(), + HbcInstructionOperandType.UInt8 => reader.ReadByte(), + HbcInstructionOperandType.UInt16 => reader.ReadUInt16(), + HbcInstructionOperandType.UInt32 => reader.ReadUInt32(), + HbcInstructionOperandType.Addr8 => reader.ReadSByte(), + HbcInstructionOperandType.Addr32 => reader.ReadInt32(), + HbcInstructionOperandType.Imm32 => reader.ReadUInt32(), + HbcInstructionOperandType.Double => reader.ReadDouble(), + HbcInstructionOperandType.UInt8S => reader.ReadByte(), + HbcInstructionOperandType.UInt16S => reader.ReadUInt16(), + HbcInstructionOperandType.UInt32S => reader.ReadUInt32(), + _ => throw new InvalidOperationException("invalid operand type"), + }; + return new HbcInstructionOperand { + Type = type, + Value = new PrimitiveValue(rawValue) + }; + } + + /// + /// Returns the value as the given type. + /// + public T GetValue() { + return Value.GetValue(); + } + + /// + /// Returns the value, or is the value is a string, the string the value points to. + /// + public T GetResolvedValue(HbcFile file) { + return Type switch { + HbcInstructionOperandType.UInt8S => (T)(object)file.GetStringTableEntry((int)GetValue()), + HbcInstructionOperandType.UInt16S => (T)(object)file.GetStringTableEntry((int)GetValue()), + HbcInstructionOperandType.UInt32S => (T)(object)file.GetStringTableEntry((int)GetValue()), + _ => GetValue() + }; + } + + /// + /// Converts the operand to a human-readable format used for disassembly. + /// + public string ToDisassembly(HbcFile file) { + return Type switch { + HbcInstructionOperandType.Reg8 => $"r{GetValue()}", + HbcInstructionOperandType.Reg32 => $"r{GetValue()}", + HbcInstructionOperandType.UInt8 => GetValue().ToString(), + HbcInstructionOperandType.UInt16 => GetValue().ToString(), + HbcInstructionOperandType.UInt32 => GetValue().ToString(), + HbcInstructionOperandType.Addr8 => $"Addr8({GetValue()})", + HbcInstructionOperandType.Addr32 => $"Addr32({GetValue()})", + HbcInstructionOperandType.Imm32 => GetValue().ToString(), + HbcInstructionOperandType.Double => StringEscape.DoubleToString(GetValue()), + HbcInstructionOperandType.UInt8S => file.GetStringTableEntry((int)GetValue()).Printable, + HbcInstructionOperandType.UInt16S => file.GetStringTableEntry((int)GetValue()).Printable, + HbcInstructionOperandType.UInt32S => file.GetStringTableEntry((int)GetValue()).Printable, + _ => throw new InvalidOperationException("invalid operand type"), + }; + } + } +} diff --git a/hasmer/libhasmer/Common/HbcInstructionOperandType.cs b/hasmer/libhasmer/Common/HbcInstructionOperandType.cs new file mode 100644 index 0000000..9606eda --- /dev/null +++ b/hasmer/libhasmer/Common/HbcInstructionOperandType.cs @@ -0,0 +1,97 @@ +using System; +using System.Runtime.Serialization; +using Newtonsoft.Json; +using Newtonsoft.Json.Linq; +using Newtonsoft.Json.Converters; + +namespace Hasmer { + /// + /// Represents the type of an operand. + /// + [JsonConverter(typeof(StringEnumConverter))] + public enum HbcInstructionOperandType { + /// + /// The operand is a one-byte register reference. + /// + Reg8, + /// + /// The operand is a four-byte register reference. + /// + Reg32, + /// + /// The operand is an unsigned byte. + /// + UInt8, + /// + /// The operand is an unsigned two-byte integer. + /// + UInt16, + /// + /// The operand is an unsigned four-byte integer. + /// + UInt32, + /// + /// The operand is a one-byte code address reference. + /// + Addr8, + /// + /// The operand is a four-byte code address reference. + /// + Addr32, + /// + /// The operand is a four-byte unsigned integer. + /// + Imm32, + /// + /// The operand is an eight-byte IEEE754 floating-point value. + /// + Double, + /// + /// The operand is a one-byte reference to the string table. + /// + UInt8S, + /// + /// The operand is a two-byte reference to the string table. + /// + UInt16S, + /// + /// The operand is a four-byte reference to the string table. + /// + UInt32S + } + + public static class HbcInstructionOperandTypeImpl { + public static int GetSizeof(this HbcInstructionOperandType opType) { + return opType switch { + HbcInstructionOperandType.Reg8 or HbcInstructionOperandType.UInt8 or HbcInstructionOperandType.Addr8 or HbcInstructionOperandType.UInt8S => 1, + HbcInstructionOperandType.UInt16 or HbcInstructionOperandType.UInt16S => 2, + HbcInstructionOperandType.Reg32 or HbcInstructionOperandType.UInt32 or HbcInstructionOperandType.Addr32 or HbcInstructionOperandType.Imm32 or HbcInstructionOperandType.UInt32S => 4, + HbcInstructionOperandType.Double => 8, + _ => throw new Exception("unreachable"), + }; + } + + public static bool CanStoreInteger(this HbcInstructionOperandType opType, ulong integer) { + switch (opType) { + case HbcInstructionOperandType.Reg8: + case HbcInstructionOperandType.UInt8: + case HbcInstructionOperandType.UInt8S: + return integer <= byte.MaxValue; + case HbcInstructionOperandType.UInt16: + case HbcInstructionOperandType.UInt16S: + return integer <= ushort.MaxValue; + case HbcInstructionOperandType.Addr8: + return (long)integer >= sbyte.MinValue && (long)integer <= sbyte.MaxValue; + case HbcInstructionOperandType.Addr32: + return (long)integer >= int.MinValue && (long)integer <= int.MaxValue; + case HbcInstructionOperandType.Imm32: + case HbcInstructionOperandType.Reg32: + case HbcInstructionOperandType.UInt32: + case HbcInstructionOperandType.UInt32S: + return integer <= uint.MaxValue; + default: + throw new Exception($"invalid operand type to store integer: {opType}"); + } + } + } +} diff --git a/hasmer/libhasmer/Common/HbcReader.cs b/hasmer/libhasmer/Common/HbcReader.cs index b3b37d5..a0daa22 100644 --- a/hasmer/libhasmer/Common/HbcReader.cs +++ b/hasmer/libhasmer/Common/HbcReader.cs @@ -44,6 +44,9 @@ public uint ReadBits(int amount) { if (amount > 32) { throw new IndexOutOfRangeException("cannot read more than 32 bits at once"); } + if (amount < 1) { + throw new IndexOutOfRangeException("bits must be >= 1"); + } uint val = 0; for (int i = 0; i < amount; i++) { diff --git a/hasmer/libhasmer/Common/HbcWriter.cs b/hasmer/libhasmer/Common/HbcWriter.cs index 684484c..c5b192f 100644 --- a/hasmer/libhasmer/Common/HbcWriter.cs +++ b/hasmer/libhasmer/Common/HbcWriter.cs @@ -9,8 +9,8 @@ namespace Hasmer { /// Represents a BinaryWriter which can write individual bits. /// public class HbcWriter : BinaryWriter { - // private byte? CurrentByte; - // private int Index; + private byte CurrentByte; + private byte Index; public HbcWriter(Stream stream) : base(stream) { } @@ -22,11 +22,30 @@ public void Align() { } public void WriteBit(byte bit) { - throw new NotImplementedException(); + if (bit == 0) { + CurrentByte &= (byte)~(1 << Index++); + } else { + CurrentByte |= (byte)(1 << Index++); + } + if (Index == 8) { + Write(CurrentByte); + + CurrentByte = 0; + Index = 0; + } } public void WriteBits(uint value, int bitsToWrite) { - throw new NotImplementedException(); + if (bitsToWrite > 32) { + throw new IndexOutOfRangeException("cannot write more than 32 bits at once"); + } + if (bitsToWrite < 1) { + throw new IndexOutOfRangeException("bits must be >= 1"); + } + for (int i = bitsToWrite - 1; i >= 0; i--) { + byte currentBit = (byte)((value >> i) & 1); + WriteBit(currentBit); + } } } } diff --git a/hasmer/libhasmer/Common/JenkinsHash.cs b/hasmer/libhasmer/Common/JenkinsHash.cs new file mode 100644 index 0000000..b9130af --- /dev/null +++ b/hasmer/libhasmer/Common/JenkinsHash.cs @@ -0,0 +1,44 @@ +using System; + +namespace Hasmer { + public class JenkinsHash { + private uint State; + + public void Update(uint x) { + this.State = Mix2(Mix1(this.State + x)); + } + + public uint Finalize() { + uint s = this.State; + this.State = 0; + return s; + } + + private static uint Mix1(uint h) { + return h + (h << 10); + } + + private static uint Mix2(uint h) { + return h ^ (h >> 6); + } + + public static uint Hash(ReadOnlySpan data, bool isUTF16) { + JenkinsHash h = new JenkinsHash(); + if (isUTF16) { + if (data.Length % 2 != 0) { + throw new Exception("UTF-16 data length should be a multiple of 2"); + } + + for (int i = 0; i < data.Length - 1; i += 2) { + uint x = BitConverter.ToUInt16(data.Slice(start: i, length: 2)); + h.Update(x); + } + } else { + foreach (byte x in data) { + h.Update(x); + } + } + return h.Finalize(); + } + } +} diff --git a/hasmer/libhasmer/Common/ObjectDumper.cs b/hasmer/libhasmer/Common/ObjectDumper.cs index 718b02f..368b102 100644 --- a/hasmer/libhasmer/Common/ObjectDumper.cs +++ b/hasmer/libhasmer/Common/ObjectDumper.cs @@ -5,16 +5,16 @@ using System.Text; namespace Hasmer { - internal class ObjectDumper { - private int _level; - private readonly int _indentSize; - private readonly StringBuilder _stringBuilder; - private readonly List _hashListOfFoundElements; + public class ObjectDumper { + private int Level; + private readonly int IndentSize; + private readonly StringBuilder Builder; + private readonly List FoundElements; private ObjectDumper(int indentSize) { - _indentSize = indentSize; - _stringBuilder = new StringBuilder(); - _hashListOfFoundElements = new List(); + IndentSize = indentSize; + Builder = new StringBuilder(); + FoundElements = new List(); } public static string Dump(object element) { @@ -22,7 +22,7 @@ public static string Dump(object element) { } public static string Dump(object element, int indentSize) { - var instance = new ObjectDumper(indentSize); + ObjectDumper instance = new ObjectDumper(indentSize); return instance.DumpElement(element); } @@ -30,107 +30,116 @@ private string DumpElement(object element) { if (element == null || element is ValueType || element is string) { Write(FormatValue(element)); } else { - var objectType = element.GetType(); - if (!typeof(IEnumerable).IsAssignableFrom(objectType)) { + Type objectType = element.GetType(); + IEnumerable enumerableElement = element as IEnumerable; + + if (enumerableElement == null) { Write("{{{0}}}", objectType.FullName); - _hashListOfFoundElements.Add(element.GetHashCode()); - _level++; - } + FoundElements.Add(element.GetHashCode()); + Level++; - var enumerableElement = element as IEnumerable; - if (enumerableElement != null) { - foreach (object item in enumerableElement) { - if (item is IEnumerable && !(item is string)) { - _level++; - DumpElement(item); - _level--; - } else { - if (!AlreadyTouched(item)) - DumpElement(item); - else - Write("{{{0}}} <-- bidirectional reference found", item.GetType().FullName); - } - } - } else { - MemberInfo[] members = element.GetType().GetMembers(BindingFlags.Public | BindingFlags.Instance); - foreach (var memberInfo in members) { - var fieldInfo = memberInfo as FieldInfo; - var propertyInfo = memberInfo as PropertyInfo; + MemberInfo[] members = element.GetType().GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); + foreach (MemberInfo memberInfo in members) { + FieldInfo fieldInfo = memberInfo as FieldInfo; + PropertyInfo propertyInfo = memberInfo as PropertyInfo; - if (fieldInfo == null && propertyInfo == null) + if (fieldInfo == null && propertyInfo == null) { continue; + } - var type = fieldInfo != null ? fieldInfo.FieldType : propertyInfo.PropertyType; + Type type = fieldInfo != null ? fieldInfo.FieldType : propertyInfo.PropertyType; object value = fieldInfo != null - ? fieldInfo.GetValue(element) - : propertyInfo.GetValue(element, null); + ? fieldInfo.GetValue(element) + : propertyInfo.GetValue(element, null); if (type.IsValueType || type == typeof(string)) { Write("{0}: {1}", memberInfo.Name, FormatValue(value)); } else { - var isEnumerable = typeof(IEnumerable).IsAssignableFrom(type); + bool isEnumerable = typeof(IEnumerable).IsAssignableFrom(type); Write("{0}: {1}", memberInfo.Name, isEnumerable ? "..." : "{ }"); - var alreadyTouched = !isEnumerable && AlreadyTouched(value); - _level++; - if (!alreadyTouched) + bool alreadyTouched = !isEnumerable && AlreadyTouched(value); + Level++; + if (!alreadyTouched) { DumpElement(value); - else + } else { Write("{{{0}}} <-- bidirectional reference found", value.GetType().FullName); - _level--; + } + Level--; + } + } + } else { + foreach (object item in enumerableElement) { + if (item is IEnumerable && !(item is string)) { + Level++; + DumpElement(item); + Level--; + } else { + if (!AlreadyTouched(item)) { + DumpElement(item); + } else { + Write("{{{0}}} <-- bidirectional reference found", item.GetType().FullName); + } } } } - if (!typeof(IEnumerable).IsAssignableFrom(objectType)) { - _level--; - } + Level--; } - return _stringBuilder.ToString(); + return Builder.ToString(); } private bool AlreadyTouched(object value) { if (value == null) return false; - var hash = value.GetHashCode(); - for (var i = 0; i < _hashListOfFoundElements.Count; i++) { - if (_hashListOfFoundElements[i] == hash) + int hash = value.GetHashCode(); + for (int i = 0; i < FoundElements.Count; i++) { + if (FoundElements[i] == hash) { return true; + } } return false; } private void Write(string value, params object[] args) { - var space = new string(' ', _level * _indentSize); + string space = new string(' ', Level * IndentSize); - if (args != null) + if (args != null) { value = string.Format(value, args); + } - _stringBuilder.AppendLine(space + value); + Builder.Append(space); + Builder.AppendLine(value); } private string FormatValue(object o) { - if (o == null) - return ("null"); + if (o == null) { + return "null"; + } - if (o is DateTime) - return (((DateTime)o).ToShortDateString()); + if (o is DateTime dt) { + return dt.ToShortDateString(); + } - if (o is string) - return string.Format("\"{0}\"", o); + if (o is string) { + return string.Format($"\"{o}\""); + } - if (o is char && (char)o == '\0') + if (o is char c && c == '\0') { return string.Empty; + } - if (o is ValueType) - return (o.ToString()); + if (o is ValueType) { + return o.ToString(); + } - if (o is IEnumerable) - return ("..."); + if (o is IEnumerable) { + return "..."; + } - return ("{ }"); + return "{ }"; } } } diff --git a/hasmer/libhasmer/Common/PrimitiveValue.cs b/hasmer/libhasmer/Common/PrimitiveValue.cs index 52471e1..41056cd 100644 --- a/hasmer/libhasmer/Common/PrimitiveValue.cs +++ b/hasmer/libhasmer/Common/PrimitiveValue.cs @@ -49,23 +49,36 @@ public void SetValue(object rawValue) { } /// - /// Returns the raw value coerced to type T. It is the duty of the caller to ensure that the type actually is of type T before calling. + /// Returns the raw value coerced to a ulong. + /// The the raw value is not an integer type, an exception is thrown. /// - public T GetValue() { - return Type.GetTypeCode(typeof(T)) switch { - TypeCode.Byte => (T)Convert.ChangeType(Convert.ToByte(RawValue), typeof(T)), - TypeCode.SByte => (T)Convert.ChangeType(Convert.ToSByte(RawValue), typeof(T)), - TypeCode.Int16 => (T)Convert.ChangeType(Convert.ToInt16(RawValue), typeof(T)), - TypeCode.UInt16 => (T)Convert.ChangeType(Convert.ToUInt16(RawValue), typeof(T)), - TypeCode.Int32 => (T)Convert.ChangeType(Convert.ToInt32(RawValue), typeof(T)), - TypeCode.UInt32 => (T)Convert.ChangeType(Convert.ToUInt32(RawValue), typeof(T)), - TypeCode.Double => (T)Convert.ChangeType(Convert.ToDouble(RawValue), typeof(T)), - TypeCode.Boolean => (T)Convert.ChangeType(Convert.ToBoolean(RawValue), typeof(T)), - TypeCode.String => (T)RawValue, - TypeCode.Empty => default(T), - _ => throw new NotImplementedException() - }; - } + public ulong GetIntegerValue() => TypeCode switch { + TypeCode.Byte => (ulong)Convert.ToByte(RawValue), + TypeCode.SByte => (ulong)Convert.ToSByte(RawValue), + TypeCode.Int16 => (ulong)Convert.ToInt16(RawValue), + TypeCode.UInt16 => (ulong)Convert.ToUInt16(RawValue), + TypeCode.Int32 => (ulong)Convert.ToInt32(RawValue), + TypeCode.UInt32 => (ulong)Convert.ToUInt32(RawValue), + _ => throw new Exception("cannot get integer value of non-integer PrimitiveValue"), + }; + + /// + /// Returns the raw value coerced to type T. + /// It is the duty of the caller to ensure that the type actually is of type T before calling. + /// + public T GetValue() => TypeCode switch { + TypeCode.Byte => (T)Convert.ChangeType(Convert.ToByte(RawValue), typeof(T)), + TypeCode.SByte => (T)Convert.ChangeType(Convert.ToSByte(RawValue), typeof(T)), + TypeCode.Int16 => (T)Convert.ChangeType(Convert.ToInt16(RawValue), typeof(T)), + TypeCode.UInt16 => (T)Convert.ChangeType(Convert.ToUInt16(RawValue), typeof(T)), + TypeCode.Int32 => (T)Convert.ChangeType(Convert.ToInt32(RawValue), typeof(T)), + TypeCode.UInt32 => (T)Convert.ChangeType(Convert.ToUInt32(RawValue), typeof(T)), + TypeCode.Double => (T)Convert.ChangeType(Convert.ToDouble(RawValue), typeof(T)), + TypeCode.Boolean => (T)Convert.ChangeType(Convert.ToBoolean(RawValue), typeof(T)), + TypeCode.String => (T)RawValue, + TypeCode.Empty => default(T), + _ => throw new NotImplementedException() + }; public override int GetHashCode() { if (RawValue == null) { @@ -95,7 +108,7 @@ public override string ToString() { TypeCode.UInt16 => Convert.ToUInt16(RawValue).ToString(), TypeCode.Int32 => Convert.ToInt32(RawValue).ToString(), TypeCode.UInt32 => Convert.ToUInt32(RawValue).ToString(), - TypeCode.Double => Convert.ToDouble(RawValue).ToString(), + TypeCode.Double => StringEscape.DoubleToString(Convert.ToDouble(RawValue)), TypeCode.Boolean => Convert.ToBoolean(RawValue) ? "true" : "false", TypeCode.String => (string)RawValue, TypeCode.Empty => "null", diff --git a/hasmer/libhasmer/Common/ResourceManager.cs b/hasmer/libhasmer/Common/ResourceManager.cs index 7b062a4..43a7cef 100644 --- a/hasmer/libhasmer/Common/ResourceManager.cs +++ b/hasmer/libhasmer/Common/ResourceManager.cs @@ -21,6 +21,9 @@ public static string ReadEmbeddedResource(string name) { Assembly assembly = Assembly.GetExecutingAssembly(); using Stream stream = assembly.GetManifestResourceStream("Hasmer.Resources." + name + ".json"); + if (stream == null) { + throw new Exception("embedded resource does not exist: " + name); + } using StreamReader reader = new StreamReader(stream); return reader.ReadToEnd(); } diff --git a/hasmer/libhasmer/Common/StringEscape.cs b/hasmer/libhasmer/Common/StringEscape.cs index abc707f..54ca499 100644 --- a/hasmer/libhasmer/Common/StringEscape.cs +++ b/hasmer/libhasmer/Common/StringEscape.cs @@ -9,24 +9,54 @@ namespace Hasmer { /// Utility for working with string escape codes. /// public class StringEscape { + // Taken from https://stackoverflow.com/a/33697376. + private const string DoubleFixedPoint = "0.###################################################################################################################################################################################################################################################################################################################################################"; + /// - /// Escapes a string, replacing untypable characters and keyword operators with escaped versions. + /// Escapes a string so that it can be used as string literal in Hasm source code. + /// Shamelessly taken from https://stackoverflow.com/a/14087738. /// - public static string Escape(string str) { - return str - .Replace("\n", @"\n") - .Replace("\r", @"\r") - .Replace("\"", "\\\""); + public static string Escape(string s) { + StringBuilder literal = new StringBuilder(s.Length + 2); + literal.Append("\""); + foreach (char c in s) { + switch (c) { + case '\"': literal.Append("\\\""); break; + case '\\': literal.Append(@"\\"); break; + case '\0': literal.Append(@"\0"); break; + case '\a': literal.Append(@"\a"); break; + case '\b': literal.Append(@"\b"); break; + case '\f': literal.Append(@"\f"); break; + case '\n': literal.Append(@"\n"); break; + case '\r': literal.Append(@"\r"); break; + case '\t': literal.Append(@"\t"); break; + case '\v': literal.Append(@"\v"); break; + default: + if (c >= 0x20 && c <= 0x7e) { + // ASCII printable character + literal.Append(c); + } else { + // UTF16 escaped character + literal.Append(@"\u"); + literal.Append(((int)c).ToString("x4")); + } + break; + } + } + literal.Append("\""); + return literal.ToString(); } - /// - /// Unescapes a string, replacing escape codes with their corresponding untypable characters or keyword operators. - /// - public static string Unescape(string str) { - return str - .Replace(@"\n", "\n") - .Replace(@"\r", "\r") - .Replace("\\\"", "\""); + public static string DoubleToString(double d) { + if (double.IsInfinity(d)) { + return "Infinity"; + } else if (double.IsNegativeInfinity(d)) { + return "-Infinity"; + } else if (double.IsNaN(d)) { + return "NaN"; + } else { + return d.ToString(DoubleFixedPoint); + } } } } diff --git a/hasmer/libhasmer/Common/StringKindEntry.cs b/hasmer/libhasmer/Common/StringKindEntry.cs new file mode 100644 index 0000000..bbd0d70 --- /dev/null +++ b/hasmer/libhasmer/Common/StringKindEntry.cs @@ -0,0 +1,42 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Hasmer { + /// + /// Used for determining whether a string is an identifier or a string literal. + /// + [Flags] + public enum StringKind { + /// + /// The string is a string literal, e.g. a string in quotes: `var s = "Hello, World!"`. + /// "Hello, World!" would be encoded as a string literal, i.e. this flag. + /// + Literal = 0 << StringKindEntry.CountBits, + /// + /// The string is an identifier, e.g. the name of a function. + /// + Identifier = 1 << StringKindEntry.CountBits + } + + public struct StringKindEntry { + public const int CountBits = 31; + const uint MaxCount = (1u << CountBits) - 1; + + public uint Entry { get; set; } + + public StringKindEntry(uint entry) { + Entry = entry; + } + + public StringKindEntry(StringKind kind, uint count) { + Entry = (uint)kind | (count & MaxCount); + } + + public StringKind Kind => (StringKind)(Entry & ~MaxCount); + + public int Count => (int)(Entry & MaxCount); + } +} diff --git a/hasmer/libhasmer/Common/StringTableEntry.cs b/hasmer/libhasmer/Common/StringTableEntry.cs new file mode 100644 index 0000000..9d8ef77 --- /dev/null +++ b/hasmer/libhasmer/Common/StringTableEntry.cs @@ -0,0 +1,39 @@ +using System; +using System.Text; +using Hasmer.Decompiler.AST; + +namespace Hasmer { + public class StringTableEntry { + public StringKind Kind { get; private set; } + public string Value { get; private set; } + public bool IsUTF16 { get; private set; } + + public StringTableEntry(StringKind kind, string value, bool isUTF16) { + Kind = kind; + Value = value; + IsUTF16 = isUTF16; + } + + public bool IsIdentifier => Kind == StringKind.Identifier; + public bool IsLiteral => Kind == StringKind.Literal; + public uint Hash => JenkinsHash.Hash(Encoded, IsUTF16); + public byte[] Encoded { + get { + if (IsUTF16) { + return Encoding.Unicode.GetBytes(Value); + } else { + return Encoding.ASCII.GetBytes(Value); + } + } + } + public string Printable { + get { + if (IsIdentifier) { + return new Identifier(Value).ToString(); + } else { + return StringEscape.Escape(Value); + } + } + } + } +} diff --git a/hasmer/libhasmer/Decompiler/AST/Identifier.cs b/hasmer/libhasmer/Decompiler/AST/Identifier.cs index c65adb3..7805f5f 100644 --- a/hasmer/libhasmer/Decompiler/AST/Identifier.cs +++ b/hasmer/libhasmer/Decompiler/AST/Identifier.cs @@ -13,7 +13,7 @@ public class Identifier : SyntaxNode { /// /// A regular expression which represents a valid JavaScript identifier. /// - public static readonly Regex NamePattern = new Regex(@"^([A-Za-z]|_|\$)([A-Za-z]|_|\$|[0-9])+$", RegexOptions.Compiled); + public static readonly Regex NamePattern = new Regex(@"^([A-Za-z]|_|\$)([A-Za-z]|_|\$|[0-9])*$", RegexOptions.Compiled); /// /// The name of the identifier. @@ -40,8 +40,20 @@ public override void WriteDirect(SourceCodeBuilder builder) { builder.Write(Name); } + private static string EscapeIdentifier(string ident) { + return ident.Replace(@"\", @"\\").Replace("<", @"\<").Replace(">", @"\>"); + } + public override string ToString() { - return Name; + if (Name.Length == 0) { + return "<>"; + } else { + if (Identifier.NamePattern.IsMatch(Name)) { + return $"<{Name}>"; + } else { + return $"<{EscapeIdentifier(Name)}>"; + } + } } } } diff --git a/hasmer/libhasmer/Decompiler/Analysis/StaticAnalyzer.cs b/hasmer/libhasmer/Decompiler/Analysis/StaticAnalyzer.cs index f73225f..8814719 100644 --- a/hasmer/libhasmer/Decompiler/Analysis/StaticAnalyzer.cs +++ b/hasmer/libhasmer/Decompiler/Analysis/StaticAnalyzer.cs @@ -33,10 +33,10 @@ private static void OptimizeObjectDeclarations(BlockStatement block) { currentObject = expr; currentObjectName = objName; } else if (currentObject != null && - assn.Left is MemberExpression memberExpr && - memberExpr.Object is Identifier objIndent && - !objIndent.IsRedundant && - objIndent.Name == currentObjectName.Name) { + assn.Left is MemberExpression memberExpr && + memberExpr.Object is Identifier objIndent && + !objIndent.IsRedundant && + objIndent.Name == currentObjectName.Name) { currentObject.Properties.Add(new ObjectExpressionProperty { Key = memberExpr.Property, Value = assn.Right diff --git a/hasmer/libhasmer/Decompiler/Analysis/StaticAnalyzerState.cs b/hasmer/libhasmer/Decompiler/Analysis/StaticAnalyzerState.cs index c722599..5c87439 100644 --- a/hasmer/libhasmer/Decompiler/Analysis/StaticAnalyzerState.cs +++ b/hasmer/libhasmer/Decompiler/Analysis/StaticAnalyzerState.cs @@ -8,7 +8,7 @@ namespace Hasmer.Decompiler.Analysis { public class StaticAnalyzerState { public Dictionary Registers { get; set; } - public List Variables { get; set; } + public List Variables { get; set; } public StaticAnalyzerState() { Registers = new Dictionary(); diff --git a/hasmer/libhasmer/Decompiler/Visitor/EnvironmentOperations.cs b/hasmer/libhasmer/Decompiler/Visitor/EnvironmentOperations.cs index dfb6a45..dbca486 100644 --- a/hasmer/libhasmer/Decompiler/Visitor/EnvironmentOperations.cs +++ b/hasmer/libhasmer/Decompiler/Visitor/EnvironmentOperations.cs @@ -18,7 +18,7 @@ public class EnvironmentIdentifier : SyntaxNode { /// /// The name of the function which defined the environment. /// - public string EnvironmentName => EnvironmentContext.Source.StringTable[EnvironmentContext.Function.FunctionName]; + public string EnvironmentName => EnvironmentContext.Source.GetStringTableEntry((int)EnvironmentContext.Function.FunctionName).Value; public override void WriteDirect(SourceCodeBuilder builder) { throw new Exception(); @@ -100,7 +100,7 @@ public static void StoreToEnvironment(DecompilerContext context) { /// [Visitor] public static void GetNewTarget(DecompilerContext context) { - byte register = context.Instruction.Operands[0].GetValue< byte>(); + byte register = context.Instruction.Operands[0].GetValue(); context.State.Registers[register] = new Identifier("NewTarget"); } diff --git a/hasmer/libhasmer/Decompiler/Visitor/FieldOperations.cs b/hasmer/libhasmer/Decompiler/Visitor/FieldOperations.cs index 88d1900..9574369 100644 --- a/hasmer/libhasmer/Decompiler/Visitor/FieldOperations.cs +++ b/hasmer/libhasmer/Decompiler/Visitor/FieldOperations.cs @@ -155,11 +155,11 @@ public static void PutByVal(DecompilerContext context) { [Visitor] public static void PutById(DecompilerContext context) => - CommonPutById(context, new Identifier(context.Source.StringTable[context.Instruction.Operands[3].GetValue()])); + CommonPutById(context, new Identifier(context.Source.GetStringTableEntry((int)context.Instruction.Operands[3].GetValue()).Value)); [Visitor] public static void PutNewOwnById(DecompilerContext context) => - CommonPutById(context, new Identifier(context.Source.StringTable[context.Instruction.Operands[2].GetValue()])); + CommonPutById(context, new Identifier(context.Source.GetStringTableEntry((int)context.Instruction.Operands[2].GetValue()).Value)); [Visitor] public static void PutOwnByIndex(DecompilerContext context) => diff --git a/hasmer/libhasmer/Decompiler/Visitor/InvokeOperations.cs b/hasmer/libhasmer/Decompiler/Visitor/InvokeOperations.cs index e44cd04..31f1d97 100644 --- a/hasmer/libhasmer/Decompiler/Visitor/InvokeOperations.cs +++ b/hasmer/libhasmer/Decompiler/Visitor/InvokeOperations.cs @@ -40,7 +40,7 @@ private static void AnalyzeCallUsage(DecompilerContext context, byte resultRegis break; } } else if (hasBeenReferenced) { // if there was a reference made, but it was cleared with a different value, stop - break; + break; } } diff --git a/hasmer/libhasmer/Resources/Bytecode40.json b/hasmer/libhasmer/Resources/Bytecode40.json index 4b3ddbd..f4208db 100644 --- a/hasmer/libhasmer/Resources/Bytecode40.json +++ b/hasmer/libhasmer/Resources/Bytecode40.json @@ -1924,6 +1924,5 @@ ] } ], - "GitTag": "v0.0.3", "GitCommitHash": "01deee71329aebaa6bddb291d6695709b90b3c97" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode41.json b/hasmer/libhasmer/Resources/Bytecode41.json index 6baa32a..4f91751 100644 --- a/hasmer/libhasmer/Resources/Bytecode41.json +++ b/hasmer/libhasmer/Resources/Bytecode41.json @@ -1970,6 +1970,5 @@ ] } ], - "GitTag": "v0.0.3", "GitCommitHash": "cbb5ee0c0f6c180cc45e912d6f396c342e4c717c" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode42.json b/hasmer/libhasmer/Resources/Bytecode42.json index 5858301..4a62fba 100644 --- a/hasmer/libhasmer/Resources/Bytecode42.json +++ b/hasmer/libhasmer/Resources/Bytecode42.json @@ -1970,6 +1970,5 @@ ] } ], - "GitTag": "v0.0.3", "GitCommitHash": "5397600dd52f1853d3136a404ac3163c0a3e9af0" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode43.json b/hasmer/libhasmer/Resources/Bytecode43.json index 3f4eee6..59b8a1c 100644 --- a/hasmer/libhasmer/Resources/Bytecode43.json +++ b/hasmer/libhasmer/Resources/Bytecode43.json @@ -1970,6 +1970,5 @@ ] } ], - "GitTag": "v0.0.3", "GitCommitHash": "4ee8ccf03e6385a4921e077b0e9a1a655ce322f8" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode44.json b/hasmer/libhasmer/Resources/Bytecode44.json index bbcb4fb..457b885 100644 --- a/hasmer/libhasmer/Resources/Bytecode44.json +++ b/hasmer/libhasmer/Resources/Bytecode44.json @@ -1978,6 +1978,5 @@ ] } ], - "GitTag": "v0.0.3", "GitCommitHash": "ea9d1bba9fd20638c8dcc27137fea470e442268c" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode45.json b/hasmer/libhasmer/Resources/Bytecode45.json index 7376894..33dfa19 100644 --- a/hasmer/libhasmer/Resources/Bytecode45.json +++ b/hasmer/libhasmer/Resources/Bytecode45.json @@ -2019,6 +2019,5 @@ ] } ], - "GitTag": "v0.0.3", "GitCommitHash": "c334f746798c0caa48e339e011dd67b9058503b4" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode46.json b/hasmer/libhasmer/Resources/Bytecode46.json index 1e2b3ec..1fca0c7 100644 --- a/hasmer/libhasmer/Resources/Bytecode46.json +++ b/hasmer/libhasmer/Resources/Bytecode46.json @@ -2028,6 +2028,5 @@ ] } ], - "GitTag": "v0.0.3", "GitCommitHash": "640e37f3d5b6af5b88c6e568156e58367e9a7a85" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode47.json b/hasmer/libhasmer/Resources/Bytecode47.json index 3abf111..65dab47 100644 --- a/hasmer/libhasmer/Resources/Bytecode47.json +++ b/hasmer/libhasmer/Resources/Bytecode47.json @@ -2028,6 +2028,5 @@ ] } ], - "GitTag": "v0.0.3", "GitCommitHash": "85f0531ae10ed1513bd8c93c1f33c954356ab2b1" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode48.json b/hasmer/libhasmer/Resources/Bytecode48.json index 90794cc..b46f79a 100644 --- a/hasmer/libhasmer/Resources/Bytecode48.json +++ b/hasmer/libhasmer/Resources/Bytecode48.json @@ -2028,6 +2028,5 @@ ] } ], - "GitTag": "v0.0.3", "GitCommitHash": "0d8e0c1ac4fb7c24272fe4fcfa959bc549b4d0f7" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode49.json b/hasmer/libhasmer/Resources/Bytecode49.json index a2a2353..7f7fdd8 100644 --- a/hasmer/libhasmer/Resources/Bytecode49.json +++ b/hasmer/libhasmer/Resources/Bytecode49.json @@ -2028,6 +2028,5 @@ ] } ], - "GitTag": "v0.0.3", "GitCommitHash": "4bef968dafb7bc9b3012910900dcacba9f026c01" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode50.json b/hasmer/libhasmer/Resources/Bytecode50.json index 607b8de..fcee827 100644 --- a/hasmer/libhasmer/Resources/Bytecode50.json +++ b/hasmer/libhasmer/Resources/Bytecode50.json @@ -2028,6 +2028,5 @@ ] } ], - "GitTag": "v0.0.3", "GitCommitHash": "c2a0873f00486c593eb84c6fac394f6a6175dd3f" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode51.json b/hasmer/libhasmer/Resources/Bytecode51.json index d4a8b51..12fb290 100644 --- a/hasmer/libhasmer/Resources/Bytecode51.json +++ b/hasmer/libhasmer/Resources/Bytecode51.json @@ -2028,6 +2028,5 @@ ] } ], - "GitTag": "v0.0.3", "GitCommitHash": "445041f8913b28327dc3a90a2819de5e2d7c3e6f" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode52.json b/hasmer/libhasmer/Resources/Bytecode52.json index f0367f1..5a3b05a 100644 --- a/hasmer/libhasmer/Resources/Bytecode52.json +++ b/hasmer/libhasmer/Resources/Bytecode52.json @@ -2132,6 +2132,5 @@ ] } ], - "GitTag": "v0.0.3", "GitCommitHash": "fcf1a6b28f95ce832a357f77a7564a82153f1f0d" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode53.json b/hasmer/libhasmer/Resources/Bytecode53.json index 439f9d1..51c17c1 100644 --- a/hasmer/libhasmer/Resources/Bytecode53.json +++ b/hasmer/libhasmer/Resources/Bytecode53.json @@ -2132,6 +2132,5 @@ ] } ], - "GitTag": "v0.0.3", "GitCommitHash": "5d69c95a820ed743f26765cd7233fb314b1958bd" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode54.json b/hasmer/libhasmer/Resources/Bytecode54.json index ce83c5e..cba01e1 100644 --- a/hasmer/libhasmer/Resources/Bytecode54.json +++ b/hasmer/libhasmer/Resources/Bytecode54.json @@ -2132,6 +2132,5 @@ ] } ], - "GitTag": "v0.0.3", "GitCommitHash": "05910f79afb60bd8e085808f7c5bf681adba7b72" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode55.json b/hasmer/libhasmer/Resources/Bytecode55.json index 4f3a657..3b0dbfb 100644 --- a/hasmer/libhasmer/Resources/Bytecode55.json +++ b/hasmer/libhasmer/Resources/Bytecode55.json @@ -2132,6 +2132,5 @@ ] } ], - "GitTag": "v0.0.3", "GitCommitHash": "0d2d83d89bead6e3d036c22be6462376e3f928c0" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode56.json b/hasmer/libhasmer/Resources/Bytecode56.json index 221c344..2a27979 100644 --- a/hasmer/libhasmer/Resources/Bytecode56.json +++ b/hasmer/libhasmer/Resources/Bytecode56.json @@ -2132,6 +2132,5 @@ ] } ], - "GitTag": "v0.0.3", "GitCommitHash": "17816a14bad62dbccb2de75f62eb999b5973ad8b" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode57.json b/hasmer/libhasmer/Resources/Bytecode57.json index cb147e6..3cddf09 100644 --- a/hasmer/libhasmer/Resources/Bytecode57.json +++ b/hasmer/libhasmer/Resources/Bytecode57.json @@ -2132,6 +2132,5 @@ ] } ], - "GitTag": "v0.0.3", "GitCommitHash": "2b791aab3a569106fcb769c4a9c3c85092eeb5a8" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode58.json b/hasmer/libhasmer/Resources/Bytecode58.json index 9bffdfe..c61f9d7 100644 --- a/hasmer/libhasmer/Resources/Bytecode58.json +++ b/hasmer/libhasmer/Resources/Bytecode58.json @@ -2132,6 +2132,5 @@ ] } ], - "GitTag": "v0.0.3", "GitCommitHash": "ce9242a487f3ffbde30370cb5b7e936e33ea6b81" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode59.json b/hasmer/libhasmer/Resources/Bytecode59.json index 5d03371..dbc802f 100644 --- a/hasmer/libhasmer/Resources/Bytecode59.json +++ b/hasmer/libhasmer/Resources/Bytecode59.json @@ -2140,6 +2140,5 @@ ] } ], - "GitTag": "v0.11.0", "GitCommitHash": "f22a18f67da3f03db59c1ec715d6ec3776b03fbf" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode60.json b/hasmer/libhasmer/Resources/Bytecode60.json index 8148a73..a2e77a8 100644 --- a/hasmer/libhasmer/Resources/Bytecode60.json +++ b/hasmer/libhasmer/Resources/Bytecode60.json @@ -2140,6 +2140,5 @@ ] } ], - "GitTag": "v0.11.0", "GitCommitHash": "d088f6f5fdfd56e0dd946dc53533462fd3505102" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode61.json b/hasmer/libhasmer/Resources/Bytecode61.json index 4888686..bfee17f 100644 --- a/hasmer/libhasmer/Resources/Bytecode61.json +++ b/hasmer/libhasmer/Resources/Bytecode61.json @@ -2140,6 +2140,5 @@ ] } ], - "GitTag": "v0.11.0", "GitCommitHash": "2ea89f022c502b2bb57d71be910c02623f0df576" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode62.json b/hasmer/libhasmer/Resources/Bytecode62.json index 0fa3c33..8739b9b 100644 --- a/hasmer/libhasmer/Resources/Bytecode62.json +++ b/hasmer/libhasmer/Resources/Bytecode62.json @@ -2140,6 +2140,5 @@ ] } ], - "GitTag": "v0.11.0", "GitCommitHash": "ae0bc93f49de682c80bcd3c37b6b227dcdf262e8" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode63.json b/hasmer/libhasmer/Resources/Bytecode63.json index b0f1ac3..177cd69 100644 --- a/hasmer/libhasmer/Resources/Bytecode63.json +++ b/hasmer/libhasmer/Resources/Bytecode63.json @@ -2140,6 +2140,5 @@ ] } ], - "GitTag": "v0.11.0", "GitCommitHash": "8eb59230c5decb290e06bc73f0c9cca426f2f208" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode64.json b/hasmer/libhasmer/Resources/Bytecode64.json index 06d09b4..37a29c1 100644 --- a/hasmer/libhasmer/Resources/Bytecode64.json +++ b/hasmer/libhasmer/Resources/Bytecode64.json @@ -2140,6 +2140,5 @@ ] } ], - "GitTag": "v0.11.0", "GitCommitHash": "2d326de0c123d230d3e1446e3aec7f43dd4d62b3" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode65.json b/hasmer/libhasmer/Resources/Bytecode65.json index bf4e092..4251ee4 100644 --- a/hasmer/libhasmer/Resources/Bytecode65.json +++ b/hasmer/libhasmer/Resources/Bytecode65.json @@ -2140,6 +2140,5 @@ ] } ], - "GitTag": "v0.11.0", "GitCommitHash": "28436fbfe9f4ac6a064dd22bd46122117d1080b7" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode66.json b/hasmer/libhasmer/Resources/Bytecode66.json index 193f983..a47a9b0 100644 --- a/hasmer/libhasmer/Resources/Bytecode66.json +++ b/hasmer/libhasmer/Resources/Bytecode66.json @@ -2140,6 +2140,5 @@ ] } ], - "GitTag": "v0.11.0", "GitCommitHash": "892bf2cf461bfcaea117826ef06a965b1f67e658" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode67.json b/hasmer/libhasmer/Resources/Bytecode67.json index f7d5307..62ccd45 100644 --- a/hasmer/libhasmer/Resources/Bytecode67.json +++ b/hasmer/libhasmer/Resources/Bytecode67.json @@ -2140,6 +2140,5 @@ ] } ], - "GitTag": "v0.11.0", "GitCommitHash": "f9e263df6ee38acf3aaf8030dc731add113c2155" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode68.json b/hasmer/libhasmer/Resources/Bytecode68.json index 374d1c3..217a56a 100644 --- a/hasmer/libhasmer/Resources/Bytecode68.json +++ b/hasmer/libhasmer/Resources/Bytecode68.json @@ -2140,6 +2140,5 @@ ] } ], - "GitTag": "v0.11.0", "GitCommitHash": "883eb4df0c2e79220e196bfc93e8b8ff9baa44d6" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode69.json b/hasmer/libhasmer/Resources/Bytecode69.json index 201c0b4..153a339 100644 --- a/hasmer/libhasmer/Resources/Bytecode69.json +++ b/hasmer/libhasmer/Resources/Bytecode69.json @@ -2140,6 +2140,5 @@ ] } ], - "GitTag": "v0.11.0", "GitCommitHash": "5a402ac42d81470804ac28189cf74433657e0228" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode70.json b/hasmer/libhasmer/Resources/Bytecode70.json index 52462e4..1b4232b 100644 --- a/hasmer/libhasmer/Resources/Bytecode70.json +++ b/hasmer/libhasmer/Resources/Bytecode70.json @@ -2140,6 +2140,5 @@ ] } ], - "GitTag": "v0.11.0", "GitCommitHash": "fdd3817f87acb715f00a36edf0ea9e1f18f60133" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode71.json b/hasmer/libhasmer/Resources/Bytecode71.json index bdd340a..33eb8d5 100644 --- a/hasmer/libhasmer/Resources/Bytecode71.json +++ b/hasmer/libhasmer/Resources/Bytecode71.json @@ -2140,6 +2140,5 @@ ] } ], - "GitTag": "v0.11.0", "GitCommitHash": "e5f89a5092db91e582036b691cec1017f6dcdfe7" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode72.json b/hasmer/libhasmer/Resources/Bytecode72.json index 91985e6..424243c 100644 --- a/hasmer/libhasmer/Resources/Bytecode72.json +++ b/hasmer/libhasmer/Resources/Bytecode72.json @@ -2140,6 +2140,5 @@ ] } ], - "GitTag": "v0.11.0", "GitCommitHash": "d1637f28eb0b3a6055d16e8e4fcb43d2942e35c8" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode73.json b/hasmer/libhasmer/Resources/Bytecode73.json index fc2b884..a4753a7 100644 --- a/hasmer/libhasmer/Resources/Bytecode73.json +++ b/hasmer/libhasmer/Resources/Bytecode73.json @@ -2168,6 +2168,5 @@ ] } ], - "GitTag": "v0.11.0", "GitCommitHash": "ecded4d4a4aca33c7654b85b8ce3c0b1903bd8fa" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode74.json b/hasmer/libhasmer/Resources/Bytecode74.json index 318f2e4..1fbc1db 100644 --- a/hasmer/libhasmer/Resources/Bytecode74.json +++ b/hasmer/libhasmer/Resources/Bytecode74.json @@ -2168,6 +2168,5 @@ ] } ], - "GitTag": "v0.11.0", "GitCommitHash": "4f15a2e8af7ff204d99aebd4d31ebcf86e9d7144" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode75.json b/hasmer/libhasmer/Resources/Bytecode75.json index bf7780b..97fb3f7 100644 --- a/hasmer/libhasmer/Resources/Bytecode75.json +++ b/hasmer/libhasmer/Resources/Bytecode75.json @@ -2168,6 +2168,5 @@ ] } ], - "GitTag": "v0.11.0", "GitCommitHash": "6871396f352ec7eedacf1795d10d28175cffb5ef" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode76.json b/hasmer/libhasmer/Resources/Bytecode76.json index ba68f06..d6fffe8 100644 --- a/hasmer/libhasmer/Resources/Bytecode76.json +++ b/hasmer/libhasmer/Resources/Bytecode76.json @@ -2168,6 +2168,5 @@ ] } ], - "GitTag": "v0.11.0", "GitCommitHash": "df60b4768ac071dd6ccc6dd08717ece1949c156f" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode77.json b/hasmer/libhasmer/Resources/Bytecode77.json index 4b38206..acc6d4f 100644 --- a/hasmer/libhasmer/Resources/Bytecode77.json +++ b/hasmer/libhasmer/Resources/Bytecode77.json @@ -2168,6 +2168,5 @@ ] } ], - "GitTag": "v0.11.0", "GitCommitHash": "701b9dd6a70afecaeaf7e4d9bb5b6e843f705294" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode78.json b/hasmer/libhasmer/Resources/Bytecode78.json index 266158a..1c5ebc1 100644 --- a/hasmer/libhasmer/Resources/Bytecode78.json +++ b/hasmer/libhasmer/Resources/Bytecode78.json @@ -2168,6 +2168,5 @@ ] } ], - "GitTag": "v0.11.0", "GitCommitHash": "c57fde25efaef83cec7e80b27e064d31d7bb166e" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode79.json b/hasmer/libhasmer/Resources/Bytecode79.json index 4139f48..ee7b492 100644 --- a/hasmer/libhasmer/Resources/Bytecode79.json +++ b/hasmer/libhasmer/Resources/Bytecode79.json @@ -2168,6 +2168,5 @@ ] } ], - "GitTag": "v0.11.0", "GitCommitHash": "05b29726e766594ae0a9be7947dd1378303d9a42" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode80.json b/hasmer/libhasmer/Resources/Bytecode80.json index 7607f03..316b6aa 100644 --- a/hasmer/libhasmer/Resources/Bytecode80.json +++ b/hasmer/libhasmer/Resources/Bytecode80.json @@ -2187,6 +2187,5 @@ ] } ], - "GitTag": "v0.11.0", "GitCommitHash": "e70045d8430e7913e2f74695402d9fb12214e4f4" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode81.json b/hasmer/libhasmer/Resources/Bytecode81.json index 11c15a9..5f8403e 100644 --- a/hasmer/libhasmer/Resources/Bytecode81.json +++ b/hasmer/libhasmer/Resources/Bytecode81.json @@ -2234,6 +2234,5 @@ ] } ], - "GitTag": "v0.11.0", "GitCommitHash": "7828e35c26023e9b6554d1dfab704e1007369f0d" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode82.json b/hasmer/libhasmer/Resources/Bytecode82.json index 61b5e65..90f8f06 100644 --- a/hasmer/libhasmer/Resources/Bytecode82.json +++ b/hasmer/libhasmer/Resources/Bytecode82.json @@ -2234,6 +2234,5 @@ ] } ], - "GitTag": "v0.11.0", "GitCommitHash": "65de349ab1bde8062b54346c2d861cbde71d5841" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode83.json b/hasmer/libhasmer/Resources/Bytecode83.json index e942e71..7cbe6d5 100644 --- a/hasmer/libhasmer/Resources/Bytecode83.json +++ b/hasmer/libhasmer/Resources/Bytecode83.json @@ -2234,6 +2234,5 @@ ] } ], - "GitTag": "v0.11.0", "GitCommitHash": "7324df965f5ff91b179e3b8a85c243776577cc18" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode84.json b/hasmer/libhasmer/Resources/Bytecode84.json index 0b58c03..48dcb3a 100644 --- a/hasmer/libhasmer/Resources/Bytecode84.json +++ b/hasmer/libhasmer/Resources/Bytecode84.json @@ -2374,6 +2374,5 @@ ] } ], - "GitTag": "v0.11.0", "GitCommitHash": "c2cd9e385a922f486a55e6bd70db2032f78379ed" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode85.json b/hasmer/libhasmer/Resources/Bytecode85.json index 14cc633..9c0b997 100644 --- a/hasmer/libhasmer/Resources/Bytecode85.json +++ b/hasmer/libhasmer/Resources/Bytecode85.json @@ -371,6 +371,24 @@ }, { "Opcode": 37, + "Name": "Inc", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 38, + "Name": "Dec", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 39, "Name": "InstanceOf", "OperandTypes": [ "Reg8", @@ -380,7 +398,7 @@ "IsJump": false }, { - "Opcode": 38, + "Opcode": 40, "Name": "IsIn", "OperandTypes": [ "Reg8", @@ -390,7 +408,7 @@ "IsJump": false }, { - "Opcode": 39, + "Opcode": 41, "Name": "GetEnvironment", "OperandTypes": [ "Reg8", @@ -399,7 +417,7 @@ "IsJump": false }, { - "Opcode": 40, + "Opcode": 42, "Name": "StoreToEnvironment", "OperandTypes": [ "Reg8", @@ -410,7 +428,7 @@ "AbstractDefinition": 3 }, { - "Opcode": 41, + "Opcode": 43, "Name": "StoreToEnvironmentL", "OperandTypes": [ "Reg8", @@ -421,7 +439,7 @@ "AbstractDefinition": 3 }, { - "Opcode": 42, + "Opcode": 44, "Name": "StoreNPToEnvironment", "OperandTypes": [ "Reg8", @@ -432,7 +450,7 @@ "AbstractDefinition": 4 }, { - "Opcode": 43, + "Opcode": 45, "Name": "StoreNPToEnvironmentL", "OperandTypes": [ "Reg8", @@ -443,7 +461,7 @@ "AbstractDefinition": 4 }, { - "Opcode": 44, + "Opcode": 46, "Name": "LoadFromEnvironment", "OperandTypes": [ "Reg8", @@ -454,7 +472,7 @@ "AbstractDefinition": 5 }, { - "Opcode": 45, + "Opcode": 47, "Name": "LoadFromEnvironmentL", "OperandTypes": [ "Reg8", @@ -465,7 +483,7 @@ "AbstractDefinition": 5 }, { - "Opcode": 46, + "Opcode": 48, "Name": "GetGlobalObject", "OperandTypes": [ "Reg8" @@ -473,7 +491,7 @@ "IsJump": false }, { - "Opcode": 47, + "Opcode": 49, "Name": "GetNewTarget", "OperandTypes": [ "Reg8" @@ -481,7 +499,7 @@ "IsJump": false }, { - "Opcode": 48, + "Opcode": 50, "Name": "CreateEnvironment", "OperandTypes": [ "Reg8" @@ -489,7 +507,7 @@ "IsJump": false }, { - "Opcode": 49, + "Opcode": 51, "Name": "DeclareGlobalVar", "OperandTypes": [ "UInt32S" @@ -497,7 +515,7 @@ "IsJump": false }, { - "Opcode": 50, + "Opcode": 52, "Name": "GetByIdShort", "OperandTypes": [ "Reg8", @@ -509,7 +527,7 @@ "AbstractDefinition": 6 }, { - "Opcode": 51, + "Opcode": 53, "Name": "GetById", "OperandTypes": [ "Reg8", @@ -521,7 +539,7 @@ "AbstractDefinition": 6 }, { - "Opcode": 52, + "Opcode": 54, "Name": "GetByIdLong", "OperandTypes": [ "Reg8", @@ -533,7 +551,7 @@ "AbstractDefinition": 6 }, { - "Opcode": 53, + "Opcode": 55, "Name": "TryGetById", "OperandTypes": [ "Reg8", @@ -545,7 +563,7 @@ "AbstractDefinition": 7 }, { - "Opcode": 54, + "Opcode": 56, "Name": "TryGetByIdLong", "OperandTypes": [ "Reg8", @@ -557,7 +575,7 @@ "AbstractDefinition": 7 }, { - "Opcode": 55, + "Opcode": 57, "Name": "PutById", "OperandTypes": [ "Reg8", @@ -569,7 +587,7 @@ "AbstractDefinition": 8 }, { - "Opcode": 56, + "Opcode": 58, "Name": "PutByIdLong", "OperandTypes": [ "Reg8", @@ -581,7 +599,7 @@ "AbstractDefinition": 8 }, { - "Opcode": 57, + "Opcode": 59, "Name": "TryPutById", "OperandTypes": [ "Reg8", @@ -593,7 +611,7 @@ "AbstractDefinition": 9 }, { - "Opcode": 58, + "Opcode": 60, "Name": "TryPutByIdLong", "OperandTypes": [ "Reg8", @@ -605,7 +623,7 @@ "AbstractDefinition": 9 }, { - "Opcode": 59, + "Opcode": 61, "Name": "PutNewOwnByIdShort", "OperandTypes": [ "Reg8", @@ -616,7 +634,7 @@ "AbstractDefinition": 10 }, { - "Opcode": 60, + "Opcode": 62, "Name": "PutNewOwnById", "OperandTypes": [ "Reg8", @@ -627,7 +645,7 @@ "AbstractDefinition": 10 }, { - "Opcode": 61, + "Opcode": 63, "Name": "PutNewOwnByIdLong", "OperandTypes": [ "Reg8", @@ -638,7 +656,7 @@ "AbstractDefinition": 10 }, { - "Opcode": 62, + "Opcode": 64, "Name": "PutNewOwnNEById", "OperandTypes": [ "Reg8", @@ -649,7 +667,7 @@ "AbstractDefinition": 11 }, { - "Opcode": 63, + "Opcode": 65, "Name": "PutNewOwnNEByIdLong", "OperandTypes": [ "Reg8", @@ -660,7 +678,7 @@ "AbstractDefinition": 11 }, { - "Opcode": 64, + "Opcode": 66, "Name": "PutOwnByIndex", "OperandTypes": [ "Reg8", @@ -671,7 +689,7 @@ "AbstractDefinition": 12 }, { - "Opcode": 65, + "Opcode": 67, "Name": "PutOwnByIndexL", "OperandTypes": [ "Reg8", @@ -682,7 +700,7 @@ "AbstractDefinition": 12 }, { - "Opcode": 66, + "Opcode": 68, "Name": "PutOwnByVal", "OperandTypes": [ "Reg8", @@ -693,7 +711,7 @@ "IsJump": false }, { - "Opcode": 67, + "Opcode": 69, "Name": "DelById", "OperandTypes": [ "Reg8", @@ -704,7 +722,7 @@ "AbstractDefinition": 13 }, { - "Opcode": 68, + "Opcode": 70, "Name": "DelByIdLong", "OperandTypes": [ "Reg8", @@ -715,7 +733,7 @@ "AbstractDefinition": 13 }, { - "Opcode": 69, + "Opcode": 71, "Name": "GetByVal", "OperandTypes": [ "Reg8", @@ -725,7 +743,7 @@ "IsJump": false }, { - "Opcode": 70, + "Opcode": 72, "Name": "PutByVal", "OperandTypes": [ "Reg8", @@ -735,7 +753,7 @@ "IsJump": false }, { - "Opcode": 71, + "Opcode": 73, "Name": "DelByVal", "OperandTypes": [ "Reg8", @@ -745,7 +763,7 @@ "IsJump": false }, { - "Opcode": 72, + "Opcode": 74, "Name": "PutOwnGetterSetterByVal", "OperandTypes": [ "Reg8", @@ -757,7 +775,7 @@ "IsJump": false }, { - "Opcode": 73, + "Opcode": 75, "Name": "GetPNameList", "OperandTypes": [ "Reg8", @@ -768,7 +786,7 @@ "IsJump": false }, { - "Opcode": 74, + "Opcode": 76, "Name": "GetNextPName", "OperandTypes": [ "Reg8", @@ -780,7 +798,7 @@ "IsJump": false }, { - "Opcode": 75, + "Opcode": 77, "Name": "Call", "OperandTypes": [ "Reg8", @@ -791,7 +809,7 @@ "AbstractDefinition": 14 }, { - "Opcode": 76, + "Opcode": 78, "Name": "Construct", "OperandTypes": [ "Reg8", @@ -802,7 +820,7 @@ "AbstractDefinition": 15 }, { - "Opcode": 77, + "Opcode": 79, "Name": "Call1", "OperandTypes": [ "Reg8", @@ -812,7 +830,7 @@ "IsJump": false }, { - "Opcode": 78, + "Opcode": 80, "Name": "CallDirect", "OperandTypes": [ "Reg8", @@ -823,7 +841,7 @@ "AbstractDefinition": 16 }, { - "Opcode": 79, + "Opcode": 81, "Name": "Call2", "OperandTypes": [ "Reg8", @@ -834,7 +852,7 @@ "IsJump": false }, { - "Opcode": 80, + "Opcode": 82, "Name": "Call3", "OperandTypes": [ "Reg8", @@ -846,7 +864,7 @@ "IsJump": false }, { - "Opcode": 81, + "Opcode": 83, "Name": "Call4", "OperandTypes": [ "Reg8", @@ -859,7 +877,7 @@ "IsJump": false }, { - "Opcode": 82, + "Opcode": 84, "Name": "CallLong", "OperandTypes": [ "Reg8", @@ -870,7 +888,7 @@ "AbstractDefinition": 14 }, { - "Opcode": 83, + "Opcode": 85, "Name": "ConstructLong", "OperandTypes": [ "Reg8", @@ -881,7 +899,7 @@ "AbstractDefinition": 15 }, { - "Opcode": 84, + "Opcode": 86, "Name": "CallDirectLongIndex", "OperandTypes": [ "Reg8", @@ -892,7 +910,7 @@ "AbstractDefinition": 16 }, { - "Opcode": 85, + "Opcode": 87, "Name": "CallBuiltin", "OperandTypes": [ "Reg8", @@ -903,7 +921,7 @@ "AbstractDefinition": 17 }, { - "Opcode": 86, + "Opcode": 88, "Name": "CallBuiltinLong", "OperandTypes": [ "Reg8", @@ -914,7 +932,7 @@ "AbstractDefinition": 17 }, { - "Opcode": 87, + "Opcode": 89, "Name": "GetBuiltinClosure", "OperandTypes": [ "Reg8", @@ -923,7 +941,7 @@ "IsJump": false }, { - "Opcode": 88, + "Opcode": 90, "Name": "Ret", "OperandTypes": [ "Reg8" @@ -931,7 +949,7 @@ "IsJump": false }, { - "Opcode": 89, + "Opcode": 91, "Name": "Catch", "OperandTypes": [ "Reg8" @@ -939,7 +957,7 @@ "IsJump": false }, { - "Opcode": 90, + "Opcode": 92, "Name": "DirectEval", "OperandTypes": [ "Reg8", @@ -948,7 +966,7 @@ "IsJump": false }, { - "Opcode": 91, + "Opcode": 93, "Name": "Throw", "OperandTypes": [ "Reg8" @@ -956,7 +974,7 @@ "IsJump": false }, { - "Opcode": 92, + "Opcode": 94, "Name": "ThrowIfEmpty", "OperandTypes": [ "Reg8", @@ -965,19 +983,19 @@ "IsJump": false }, { - "Opcode": 93, + "Opcode": 95, "Name": "Debugger", "OperandTypes": [], "IsJump": false }, { - "Opcode": 94, + "Opcode": 96, "Name": "AsyncBreakCheck", "OperandTypes": [], "IsJump": false }, { - "Opcode": 95, + "Opcode": 97, "Name": "ProfilePoint", "OperandTypes": [ "UInt16" @@ -985,7 +1003,7 @@ "IsJump": false }, { - "Opcode": 96, + "Opcode": 98, "Name": "CreateClosure", "OperandTypes": [ "Reg8", @@ -996,7 +1014,7 @@ "AbstractDefinition": 18 }, { - "Opcode": 97, + "Opcode": 99, "Name": "CreateClosureLongIndex", "OperandTypes": [ "Reg8", @@ -1007,7 +1025,7 @@ "AbstractDefinition": 18 }, { - "Opcode": 98, + "Opcode": 100, "Name": "CreateGeneratorClosure", "OperandTypes": [ "Reg8", @@ -1018,7 +1036,7 @@ "AbstractDefinition": 19 }, { - "Opcode": 99, + "Opcode": 101, "Name": "CreateGeneratorClosureLongIndex", "OperandTypes": [ "Reg8", @@ -1029,7 +1047,7 @@ "AbstractDefinition": 19 }, { - "Opcode": 100, + "Opcode": 102, "Name": "CreateAsyncClosure", "OperandTypes": [ "Reg8", @@ -1040,7 +1058,7 @@ "AbstractDefinition": 20 }, { - "Opcode": 101, + "Opcode": 103, "Name": "CreateAsyncClosureLongIndex", "OperandTypes": [ "Reg8", @@ -1051,7 +1069,7 @@ "AbstractDefinition": 20 }, { - "Opcode": 102, + "Opcode": 104, "Name": "CreateThis", "OperandTypes": [ "Reg8", @@ -1061,7 +1079,7 @@ "IsJump": false }, { - "Opcode": 103, + "Opcode": 105, "Name": "SelectObject", "OperandTypes": [ "Reg8", @@ -1071,7 +1089,7 @@ "IsJump": false }, { - "Opcode": 104, + "Opcode": 106, "Name": "LoadParam", "OperandTypes": [ "Reg8", @@ -1081,7 +1099,7 @@ "AbstractDefinition": 21 }, { - "Opcode": 105, + "Opcode": 107, "Name": "LoadParamLong", "OperandTypes": [ "Reg8", @@ -1091,7 +1109,7 @@ "AbstractDefinition": 21 }, { - "Opcode": 106, + "Opcode": 108, "Name": "LoadConstUInt8", "OperandTypes": [ "Reg8", @@ -1100,7 +1118,7 @@ "IsJump": false }, { - "Opcode": 107, + "Opcode": 109, "Name": "LoadConstInt", "OperandTypes": [ "Reg8", @@ -1109,7 +1127,7 @@ "IsJump": false }, { - "Opcode": 108, + "Opcode": 110, "Name": "LoadConstDouble", "OperandTypes": [ "Reg8", @@ -1118,7 +1136,7 @@ "IsJump": false }, { - "Opcode": 109, + "Opcode": 111, "Name": "LoadConstString", "OperandTypes": [ "Reg8", @@ -1128,7 +1146,7 @@ "AbstractDefinition": 22 }, { - "Opcode": 110, + "Opcode": 112, "Name": "LoadConstStringLongIndex", "OperandTypes": [ "Reg8", @@ -1138,7 +1156,7 @@ "AbstractDefinition": 22 }, { - "Opcode": 111, + "Opcode": 113, "Name": "LoadConstEmpty", "OperandTypes": [ "Reg8" @@ -1146,7 +1164,7 @@ "IsJump": false }, { - "Opcode": 112, + "Opcode": 114, "Name": "LoadConstUndefined", "OperandTypes": [ "Reg8" @@ -1154,7 +1172,7 @@ "IsJump": false }, { - "Opcode": 113, + "Opcode": 115, "Name": "LoadConstNull", "OperandTypes": [ "Reg8" @@ -1162,7 +1180,7 @@ "IsJump": false }, { - "Opcode": 114, + "Opcode": 116, "Name": "LoadConstTrue", "OperandTypes": [ "Reg8" @@ -1170,7 +1188,7 @@ "IsJump": false }, { - "Opcode": 115, + "Opcode": 117, "Name": "LoadConstFalse", "OperandTypes": [ "Reg8" @@ -1178,7 +1196,7 @@ "IsJump": false }, { - "Opcode": 116, + "Opcode": 118, "Name": "LoadConstZero", "OperandTypes": [ "Reg8" @@ -1186,7 +1204,7 @@ "IsJump": false }, { - "Opcode": 117, + "Opcode": 119, "Name": "CoerceThisNS", "OperandTypes": [ "Reg8", @@ -1195,7 +1213,7 @@ "IsJump": false }, { - "Opcode": 118, + "Opcode": 120, "Name": "LoadThisNS", "OperandTypes": [ "Reg8" @@ -1203,7 +1221,7 @@ "IsJump": false }, { - "Opcode": 119, + "Opcode": 121, "Name": "ToNumber", "OperandTypes": [ "Reg8", @@ -1212,7 +1230,7 @@ "IsJump": false }, { - "Opcode": 120, + "Opcode": 122, "Name": "ToInt32", "OperandTypes": [ "Reg8", @@ -1221,7 +1239,7 @@ "IsJump": false }, { - "Opcode": 121, + "Opcode": 123, "Name": "AddEmptyString", "OperandTypes": [ "Reg8", @@ -1230,7 +1248,7 @@ "IsJump": false }, { - "Opcode": 122, + "Opcode": 124, "Name": "GetArgumentsPropByVal", "OperandTypes": [ "Reg8", @@ -1240,7 +1258,7 @@ "IsJump": false }, { - "Opcode": 123, + "Opcode": 125, "Name": "GetArgumentsLength", "OperandTypes": [ "Reg8", @@ -1249,7 +1267,7 @@ "IsJump": false }, { - "Opcode": 124, + "Opcode": 126, "Name": "ReifyArguments", "OperandTypes": [ "Reg8" @@ -1257,7 +1275,7 @@ "IsJump": false }, { - "Opcode": 125, + "Opcode": 127, "Name": "CreateRegExp", "OperandTypes": [ "Reg8", @@ -1268,7 +1286,7 @@ "IsJump": false }, { - "Opcode": 126, + "Opcode": 128, "Name": "SwitchImm", "OperandTypes": [ "Reg8", @@ -1280,13 +1298,13 @@ "IsJump": false }, { - "Opcode": 127, + "Opcode": 129, "Name": "StartGenerator", "OperandTypes": [], "IsJump": false }, { - "Opcode": 128, + "Opcode": 130, "Name": "ResumeGenerator", "OperandTypes": [ "Reg8", @@ -1295,13 +1313,13 @@ "IsJump": false }, { - "Opcode": 129, + "Opcode": 131, "Name": "CompleteGenerator", "OperandTypes": [], "IsJump": false }, { - "Opcode": 130, + "Opcode": 132, "Name": "CreateGenerator", "OperandTypes": [ "Reg8", @@ -1312,7 +1330,7 @@ "AbstractDefinition": 23 }, { - "Opcode": 131, + "Opcode": 133, "Name": "CreateGeneratorLongIndex", "OperandTypes": [ "Reg8", @@ -1323,7 +1341,7 @@ "AbstractDefinition": 23 }, { - "Opcode": 132, + "Opcode": 134, "Name": "IteratorBegin", "OperandTypes": [ "Reg8", @@ -1332,7 +1350,7 @@ "IsJump": false }, { - "Opcode": 133, + "Opcode": 135, "Name": "IteratorNext", "OperandTypes": [ "Reg8", @@ -1342,7 +1360,7 @@ "IsJump": false }, { - "Opcode": 134, + "Opcode": 136, "Name": "IteratorClose", "OperandTypes": [ "Reg8", @@ -1351,7 +1369,7 @@ "IsJump": false }, { - "Opcode": 135, + "Opcode": 137, "Name": "Jmp", "OperandTypes": [ "Addr8" @@ -1360,7 +1378,7 @@ "AbstractDefinition": 24 }, { - "Opcode": 136, + "Opcode": 138, "Name": "JmpLong", "OperandTypes": [ "Addr32" @@ -1369,7 +1387,7 @@ "AbstractDefinition": 24 }, { - "Opcode": 137, + "Opcode": 139, "Name": "JmpTrue", "OperandTypes": [ "Addr8", @@ -1379,7 +1397,7 @@ "AbstractDefinition": 25 }, { - "Opcode": 138, + "Opcode": 140, "Name": "JmpTrueLong", "OperandTypes": [ "Addr32", @@ -1389,7 +1407,7 @@ "AbstractDefinition": 25 }, { - "Opcode": 139, + "Opcode": 141, "Name": "JmpFalse", "OperandTypes": [ "Addr8", @@ -1399,7 +1417,7 @@ "AbstractDefinition": 26 }, { - "Opcode": 140, + "Opcode": 142, "Name": "JmpFalseLong", "OperandTypes": [ "Addr32", @@ -1409,7 +1427,7 @@ "AbstractDefinition": 26 }, { - "Opcode": 141, + "Opcode": 143, "Name": "JmpUndefined", "OperandTypes": [ "Addr8", @@ -1419,7 +1437,7 @@ "AbstractDefinition": 27 }, { - "Opcode": 142, + "Opcode": 144, "Name": "JmpUndefinedLong", "OperandTypes": [ "Addr32", @@ -1429,7 +1447,7 @@ "AbstractDefinition": 27 }, { - "Opcode": 143, + "Opcode": 145, "Name": "SaveGenerator", "OperandTypes": [ "Addr8" @@ -1438,7 +1456,7 @@ "AbstractDefinition": 28 }, { - "Opcode": 144, + "Opcode": 146, "Name": "SaveGeneratorLong", "OperandTypes": [ "Addr32" @@ -1447,7 +1465,7 @@ "AbstractDefinition": 28 }, { - "Opcode": 145, + "Opcode": 147, "Name": "JLess", "OperandTypes": [ "Addr8", @@ -1458,7 +1476,7 @@ "AbstractDefinition": 29 }, { - "Opcode": 146, + "Opcode": 148, "Name": "JLessLong", "OperandTypes": [ "Addr32", @@ -1469,7 +1487,7 @@ "AbstractDefinition": 29 }, { - "Opcode": 147, + "Opcode": 149, "Name": "JNotLess", "OperandTypes": [ "Addr8", @@ -1480,7 +1498,7 @@ "AbstractDefinition": 30 }, { - "Opcode": 148, + "Opcode": 150, "Name": "JNotLessLong", "OperandTypes": [ "Addr32", @@ -1491,7 +1509,7 @@ "AbstractDefinition": 30 }, { - "Opcode": 149, + "Opcode": 151, "Name": "JLessN", "OperandTypes": [ "Addr8", @@ -1502,7 +1520,7 @@ "AbstractDefinition": 31 }, { - "Opcode": 150, + "Opcode": 152, "Name": "JLessNLong", "OperandTypes": [ "Addr32", @@ -1513,7 +1531,7 @@ "AbstractDefinition": 31 }, { - "Opcode": 151, + "Opcode": 153, "Name": "JNotLessN", "OperandTypes": [ "Addr8", @@ -1524,7 +1542,7 @@ "AbstractDefinition": 32 }, { - "Opcode": 152, + "Opcode": 154, "Name": "JNotLessNLong", "OperandTypes": [ "Addr32", @@ -1535,7 +1553,7 @@ "AbstractDefinition": 32 }, { - "Opcode": 153, + "Opcode": 155, "Name": "JLessEqual", "OperandTypes": [ "Addr8", @@ -1546,7 +1564,7 @@ "AbstractDefinition": 33 }, { - "Opcode": 154, + "Opcode": 156, "Name": "JLessEqualLong", "OperandTypes": [ "Addr32", @@ -1557,7 +1575,7 @@ "AbstractDefinition": 33 }, { - "Opcode": 155, + "Opcode": 157, "Name": "JNotLessEqual", "OperandTypes": [ "Addr8", @@ -1568,7 +1586,7 @@ "AbstractDefinition": 34 }, { - "Opcode": 156, + "Opcode": 158, "Name": "JNotLessEqualLong", "OperandTypes": [ "Addr32", @@ -1579,7 +1597,7 @@ "AbstractDefinition": 34 }, { - "Opcode": 157, + "Opcode": 159, "Name": "JLessEqualN", "OperandTypes": [ "Addr8", @@ -1590,7 +1608,7 @@ "AbstractDefinition": 35 }, { - "Opcode": 158, + "Opcode": 160, "Name": "JLessEqualNLong", "OperandTypes": [ "Addr32", @@ -1601,7 +1619,7 @@ "AbstractDefinition": 35 }, { - "Opcode": 159, + "Opcode": 161, "Name": "JNotLessEqualN", "OperandTypes": [ "Addr8", @@ -1612,7 +1630,7 @@ "AbstractDefinition": 36 }, { - "Opcode": 160, + "Opcode": 162, "Name": "JNotLessEqualNLong", "OperandTypes": [ "Addr32", @@ -1623,7 +1641,7 @@ "AbstractDefinition": 36 }, { - "Opcode": 161, + "Opcode": 163, "Name": "JGreater", "OperandTypes": [ "Addr8", @@ -1634,7 +1652,7 @@ "AbstractDefinition": 37 }, { - "Opcode": 162, + "Opcode": 164, "Name": "JGreaterLong", "OperandTypes": [ "Addr32", @@ -1645,7 +1663,7 @@ "AbstractDefinition": 37 }, { - "Opcode": 163, + "Opcode": 165, "Name": "JNotGreater", "OperandTypes": [ "Addr8", @@ -1656,7 +1674,7 @@ "AbstractDefinition": 38 }, { - "Opcode": 164, + "Opcode": 166, "Name": "JNotGreaterLong", "OperandTypes": [ "Addr32", @@ -1667,7 +1685,7 @@ "AbstractDefinition": 38 }, { - "Opcode": 165, + "Opcode": 167, "Name": "JGreaterN", "OperandTypes": [ "Addr8", @@ -1678,7 +1696,7 @@ "AbstractDefinition": 39 }, { - "Opcode": 166, + "Opcode": 168, "Name": "JGreaterNLong", "OperandTypes": [ "Addr32", @@ -1689,7 +1707,7 @@ "AbstractDefinition": 39 }, { - "Opcode": 167, + "Opcode": 169, "Name": "JNotGreaterN", "OperandTypes": [ "Addr8", @@ -1700,7 +1718,7 @@ "AbstractDefinition": 40 }, { - "Opcode": 168, + "Opcode": 170, "Name": "JNotGreaterNLong", "OperandTypes": [ "Addr32", @@ -1711,7 +1729,7 @@ "AbstractDefinition": 40 }, { - "Opcode": 169, + "Opcode": 171, "Name": "JGreaterEqual", "OperandTypes": [ "Addr8", @@ -1722,7 +1740,7 @@ "AbstractDefinition": 41 }, { - "Opcode": 170, + "Opcode": 172, "Name": "JGreaterEqualLong", "OperandTypes": [ "Addr32", @@ -1733,7 +1751,7 @@ "AbstractDefinition": 41 }, { - "Opcode": 171, + "Opcode": 173, "Name": "JNotGreaterEqual", "OperandTypes": [ "Addr8", @@ -1744,7 +1762,7 @@ "AbstractDefinition": 42 }, { - "Opcode": 172, + "Opcode": 174, "Name": "JNotGreaterEqualLong", "OperandTypes": [ "Addr32", @@ -1755,7 +1773,7 @@ "AbstractDefinition": 42 }, { - "Opcode": 173, + "Opcode": 175, "Name": "JGreaterEqualN", "OperandTypes": [ "Addr8", @@ -1766,7 +1784,7 @@ "AbstractDefinition": 43 }, { - "Opcode": 174, + "Opcode": 176, "Name": "JGreaterEqualNLong", "OperandTypes": [ "Addr32", @@ -1777,7 +1795,7 @@ "AbstractDefinition": 43 }, { - "Opcode": 175, + "Opcode": 177, "Name": "JNotGreaterEqualN", "OperandTypes": [ "Addr8", @@ -1788,7 +1806,7 @@ "AbstractDefinition": 44 }, { - "Opcode": 176, + "Opcode": 178, "Name": "JNotGreaterEqualNLong", "OperandTypes": [ "Addr32", @@ -1799,7 +1817,7 @@ "AbstractDefinition": 44 }, { - "Opcode": 177, + "Opcode": 179, "Name": "JEqual", "OperandTypes": [ "Addr8", @@ -1810,7 +1828,7 @@ "AbstractDefinition": 45 }, { - "Opcode": 178, + "Opcode": 180, "Name": "JEqualLong", "OperandTypes": [ "Addr32", @@ -1821,7 +1839,7 @@ "AbstractDefinition": 45 }, { - "Opcode": 179, + "Opcode": 181, "Name": "JNotEqual", "OperandTypes": [ "Addr8", @@ -1832,7 +1850,7 @@ "AbstractDefinition": 46 }, { - "Opcode": 180, + "Opcode": 182, "Name": "JNotEqualLong", "OperandTypes": [ "Addr32", @@ -1843,7 +1861,7 @@ "AbstractDefinition": 46 }, { - "Opcode": 181, + "Opcode": 183, "Name": "JStrictEqual", "OperandTypes": [ "Addr8", @@ -1854,7 +1872,7 @@ "AbstractDefinition": 47 }, { - "Opcode": 182, + "Opcode": 184, "Name": "JStrictEqualLong", "OperandTypes": [ "Addr32", @@ -1865,7 +1883,7 @@ "AbstractDefinition": 47 }, { - "Opcode": 183, + "Opcode": 185, "Name": "JStrictNotEqual", "OperandTypes": [ "Addr8", @@ -1876,7 +1894,7 @@ "AbstractDefinition": 48 }, { - "Opcode": 184, + "Opcode": 186, "Name": "JStrictNotEqualLong", "OperandTypes": [ "Addr32", @@ -1887,7 +1905,7 @@ "AbstractDefinition": 48 }, { - "Opcode": 185, + "Opcode": 187, "Name": "Add32", "OperandTypes": [ "Reg8", @@ -1897,7 +1915,7 @@ "IsJump": false }, { - "Opcode": 186, + "Opcode": 188, "Name": "Sub32", "OperandTypes": [ "Reg8", @@ -1907,7 +1925,7 @@ "IsJump": false }, { - "Opcode": 187, + "Opcode": 189, "Name": "Mul32", "OperandTypes": [ "Reg8", @@ -1917,7 +1935,7 @@ "IsJump": false }, { - "Opcode": 188, + "Opcode": 190, "Name": "Divi32", "OperandTypes": [ "Reg8", @@ -1927,7 +1945,7 @@ "IsJump": false }, { - "Opcode": 189, + "Opcode": 191, "Name": "Divu32", "OperandTypes": [ "Reg8", @@ -1937,7 +1955,7 @@ "IsJump": false }, { - "Opcode": 190, + "Opcode": 192, "Name": "Loadi8", "OperandTypes": [ "Reg8", @@ -1947,7 +1965,7 @@ "IsJump": false }, { - "Opcode": 191, + "Opcode": 193, "Name": "Loadu8", "OperandTypes": [ "Reg8", @@ -1957,7 +1975,7 @@ "IsJump": false }, { - "Opcode": 192, + "Opcode": 194, "Name": "Loadi16", "OperandTypes": [ "Reg8", @@ -1967,7 +1985,7 @@ "IsJump": false }, { - "Opcode": 193, + "Opcode": 195, "Name": "Loadu16", "OperandTypes": [ "Reg8", @@ -1977,7 +1995,7 @@ "IsJump": false }, { - "Opcode": 194, + "Opcode": 196, "Name": "Loadi32", "OperandTypes": [ "Reg8", @@ -1987,7 +2005,7 @@ "IsJump": false }, { - "Opcode": 195, + "Opcode": 197, "Name": "Loadu32", "OperandTypes": [ "Reg8", @@ -1997,7 +2015,7 @@ "IsJump": false }, { - "Opcode": 196, + "Opcode": 198, "Name": "Store8", "OperandTypes": [ "Reg8", @@ -2007,7 +2025,7 @@ "IsJump": false }, { - "Opcode": 197, + "Opcode": 199, "Name": "Store16", "OperandTypes": [ "Reg8", @@ -2017,7 +2035,7 @@ "IsJump": false }, { - "Opcode": 198, + "Opcode": 200, "Name": "Store32", "OperandTypes": [ "Reg8", @@ -2051,329 +2069,328 @@ }, { "Name": "StoreToEnvironment", - "VariantOpcodes": [ - 40, - 41 - ] - }, - { - "Name": "StoreNPToEnvironment", "VariantOpcodes": [ 42, 43 ] }, { - "Name": "LoadFromEnvironment", + "Name": "StoreNPToEnvironment", "VariantOpcodes": [ 44, 45 ] }, { - "Name": "GetById", + "Name": "LoadFromEnvironment", "VariantOpcodes": [ - 51, - 50, - 52 + 46, + 47 ] }, { - "Name": "TryGetById", + "Name": "GetById", "VariantOpcodes": [ 53, + 52, 54 ] }, { - "Name": "PutById", + "Name": "TryGetById", "VariantOpcodes": [ 55, 56 ] }, { - "Name": "TryPutById", + "Name": "PutById", "VariantOpcodes": [ 57, 58 ] }, { - "Name": "PutNewOwnById", + "Name": "TryPutById", "VariantOpcodes": [ - 60, 59, - 61 + 60 ] }, { - "Name": "PutNewOwnNEById", + "Name": "PutNewOwnById", "VariantOpcodes": [ 62, + 61, 63 ] }, { - "Name": "PutOwnByIndex", + "Name": "PutNewOwnNEById", "VariantOpcodes": [ 64, 65 ] }, + { + "Name": "PutOwnByIndex", + "VariantOpcodes": [ + 66, + 67 + ] + }, { "Name": "DelById", "VariantOpcodes": [ - 67, - 68 + 69, + 70 ] }, { "Name": "Call", "VariantOpcodes": [ - 75, - 82 + 77, + 84 ] }, { "Name": "Construct", "VariantOpcodes": [ - 76, - 83 + 78, + 85 ] }, { "Name": "CallDirect", "VariantOpcodes": [ - 78, - 84 + 80, + 86 ] }, { "Name": "CallBuiltin", "VariantOpcodes": [ - 85, - 86 + 87, + 88 ] }, { "Name": "CreateClosure", "VariantOpcodes": [ - 96, - 97 + 98, + 99 ] }, { "Name": "CreateGeneratorClosure", "VariantOpcodes": [ - 98, - 99 + 100, + 101 ] }, { "Name": "CreateAsyncClosure", "VariantOpcodes": [ - 100, - 101 + 102, + 103 ] }, { "Name": "LoadParam", "VariantOpcodes": [ - 104, - 105 + 106, + 107 ] }, { "Name": "LoadConstString", "VariantOpcodes": [ - 109, - 110 + 111, + 112 ] }, { "Name": "CreateGenerator", "VariantOpcodes": [ - 130, - 131 + 132, + 133 ] }, { "Name": "Jmp", - "VariantOpcodes": [ - 135, - 136 - ] - }, - { - "Name": "JmpTrue", "VariantOpcodes": [ 137, 138 ] }, { - "Name": "JmpFalse", + "Name": "JmpTrue", "VariantOpcodes": [ 139, 140 ] }, { - "Name": "JmpUndefined", + "Name": "JmpFalse", "VariantOpcodes": [ 141, 142 ] }, { - "Name": "SaveGenerator", + "Name": "JmpUndefined", "VariantOpcodes": [ 143, 144 ] }, { - "Name": "JLess", + "Name": "SaveGenerator", "VariantOpcodes": [ 145, 146 ] }, { - "Name": "JNotLess", + "Name": "JLess", "VariantOpcodes": [ 147, 148 ] }, { - "Name": "JLessN", + "Name": "JNotLess", "VariantOpcodes": [ 149, 150 ] }, { - "Name": "JNotLessN", + "Name": "JLessN", "VariantOpcodes": [ 151, 152 ] }, { - "Name": "JLessEqual", + "Name": "JNotLessN", "VariantOpcodes": [ 153, 154 ] }, { - "Name": "JNotLessEqual", + "Name": "JLessEqual", "VariantOpcodes": [ 155, 156 ] }, { - "Name": "JLessEqualN", + "Name": "JNotLessEqual", "VariantOpcodes": [ 157, 158 ] }, { - "Name": "JNotLessEqualN", + "Name": "JLessEqualN", "VariantOpcodes": [ 159, 160 ] }, { - "Name": "JGreater", + "Name": "JNotLessEqualN", "VariantOpcodes": [ 161, 162 ] }, { - "Name": "JNotGreater", + "Name": "JGreater", "VariantOpcodes": [ 163, 164 ] }, { - "Name": "JGreaterN", + "Name": "JNotGreater", "VariantOpcodes": [ 165, 166 ] }, { - "Name": "JNotGreaterN", + "Name": "JGreaterN", "VariantOpcodes": [ 167, 168 ] }, { - "Name": "JGreaterEqual", + "Name": "JNotGreaterN", "VariantOpcodes": [ 169, 170 ] }, { - "Name": "JNotGreaterEqual", + "Name": "JGreaterEqual", "VariantOpcodes": [ 171, 172 ] }, { - "Name": "JGreaterEqualN", + "Name": "JNotGreaterEqual", "VariantOpcodes": [ 173, 174 ] }, { - "Name": "JNotGreaterEqualN", + "Name": "JGreaterEqualN", "VariantOpcodes": [ 175, 176 ] }, { - "Name": "JEqual", + "Name": "JNotGreaterEqualN", "VariantOpcodes": [ 177, 178 ] }, { - "Name": "JNotEqual", + "Name": "JEqual", "VariantOpcodes": [ 179, 180 ] }, { - "Name": "JStrictEqual", + "Name": "JNotEqual", "VariantOpcodes": [ 181, 182 ] }, { - "Name": "JStrictNotEqual", + "Name": "JStrictEqual", "VariantOpcodes": [ 183, 184 ] + }, + { + "Name": "JStrictNotEqual", + "VariantOpcodes": [ + 185, + 186 + ] } ], - "GitTag": "v0.11.0", - "GitCommitHash": "1cc6e722ea9dd9f53def90bb88fbefeca99739b9" + "GitCommitHash": "b74eb2d5bff8ffbfa6914746261c4efd2c4223c5" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode86.json b/hasmer/libhasmer/Resources/Bytecode86.json index ccc6831..85f522f 100644 --- a/hasmer/libhasmer/Resources/Bytecode86.json +++ b/hasmer/libhasmer/Resources/Bytecode86.json @@ -371,6 +371,24 @@ }, { "Opcode": 37, + "Name": "Inc", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 38, + "Name": "Dec", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 39, "Name": "InstanceOf", "OperandTypes": [ "Reg8", @@ -380,7 +398,7 @@ "IsJump": false }, { - "Opcode": 38, + "Opcode": 40, "Name": "IsIn", "OperandTypes": [ "Reg8", @@ -390,7 +408,7 @@ "IsJump": false }, { - "Opcode": 39, + "Opcode": 41, "Name": "GetEnvironment", "OperandTypes": [ "Reg8", @@ -399,7 +417,7 @@ "IsJump": false }, { - "Opcode": 40, + "Opcode": 42, "Name": "StoreToEnvironment", "OperandTypes": [ "Reg8", @@ -410,7 +428,7 @@ "AbstractDefinition": 3 }, { - "Opcode": 41, + "Opcode": 43, "Name": "StoreToEnvironmentL", "OperandTypes": [ "Reg8", @@ -421,7 +439,7 @@ "AbstractDefinition": 3 }, { - "Opcode": 42, + "Opcode": 44, "Name": "StoreNPToEnvironment", "OperandTypes": [ "Reg8", @@ -432,7 +450,7 @@ "AbstractDefinition": 4 }, { - "Opcode": 43, + "Opcode": 45, "Name": "StoreNPToEnvironmentL", "OperandTypes": [ "Reg8", @@ -443,7 +461,7 @@ "AbstractDefinition": 4 }, { - "Opcode": 44, + "Opcode": 46, "Name": "LoadFromEnvironment", "OperandTypes": [ "Reg8", @@ -454,7 +472,7 @@ "AbstractDefinition": 5 }, { - "Opcode": 45, + "Opcode": 47, "Name": "LoadFromEnvironmentL", "OperandTypes": [ "Reg8", @@ -465,7 +483,7 @@ "AbstractDefinition": 5 }, { - "Opcode": 46, + "Opcode": 48, "Name": "GetGlobalObject", "OperandTypes": [ "Reg8" @@ -473,7 +491,7 @@ "IsJump": false }, { - "Opcode": 47, + "Opcode": 49, "Name": "GetNewTarget", "OperandTypes": [ "Reg8" @@ -481,7 +499,7 @@ "IsJump": false }, { - "Opcode": 48, + "Opcode": 50, "Name": "CreateEnvironment", "OperandTypes": [ "Reg8" @@ -489,7 +507,7 @@ "IsJump": false }, { - "Opcode": 49, + "Opcode": 51, "Name": "DeclareGlobalVar", "OperandTypes": [ "UInt32S" @@ -497,7 +515,7 @@ "IsJump": false }, { - "Opcode": 50, + "Opcode": 52, "Name": "GetByIdShort", "OperandTypes": [ "Reg8", @@ -509,7 +527,7 @@ "AbstractDefinition": 6 }, { - "Opcode": 51, + "Opcode": 53, "Name": "GetById", "OperandTypes": [ "Reg8", @@ -521,7 +539,7 @@ "AbstractDefinition": 6 }, { - "Opcode": 52, + "Opcode": 54, "Name": "GetByIdLong", "OperandTypes": [ "Reg8", @@ -533,7 +551,7 @@ "AbstractDefinition": 6 }, { - "Opcode": 53, + "Opcode": 55, "Name": "TryGetById", "OperandTypes": [ "Reg8", @@ -545,7 +563,7 @@ "AbstractDefinition": 7 }, { - "Opcode": 54, + "Opcode": 56, "Name": "TryGetByIdLong", "OperandTypes": [ "Reg8", @@ -557,7 +575,7 @@ "AbstractDefinition": 7 }, { - "Opcode": 55, + "Opcode": 57, "Name": "PutById", "OperandTypes": [ "Reg8", @@ -569,7 +587,7 @@ "AbstractDefinition": 8 }, { - "Opcode": 56, + "Opcode": 58, "Name": "PutByIdLong", "OperandTypes": [ "Reg8", @@ -581,7 +599,7 @@ "AbstractDefinition": 8 }, { - "Opcode": 57, + "Opcode": 59, "Name": "TryPutById", "OperandTypes": [ "Reg8", @@ -593,7 +611,7 @@ "AbstractDefinition": 9 }, { - "Opcode": 58, + "Opcode": 60, "Name": "TryPutByIdLong", "OperandTypes": [ "Reg8", @@ -605,7 +623,7 @@ "AbstractDefinition": 9 }, { - "Opcode": 59, + "Opcode": 61, "Name": "PutNewOwnByIdShort", "OperandTypes": [ "Reg8", @@ -616,7 +634,7 @@ "AbstractDefinition": 10 }, { - "Opcode": 60, + "Opcode": 62, "Name": "PutNewOwnById", "OperandTypes": [ "Reg8", @@ -627,7 +645,7 @@ "AbstractDefinition": 10 }, { - "Opcode": 61, + "Opcode": 63, "Name": "PutNewOwnByIdLong", "OperandTypes": [ "Reg8", @@ -638,7 +656,7 @@ "AbstractDefinition": 10 }, { - "Opcode": 62, + "Opcode": 64, "Name": "PutNewOwnNEById", "OperandTypes": [ "Reg8", @@ -649,7 +667,7 @@ "AbstractDefinition": 11 }, { - "Opcode": 63, + "Opcode": 65, "Name": "PutNewOwnNEByIdLong", "OperandTypes": [ "Reg8", @@ -660,7 +678,7 @@ "AbstractDefinition": 11 }, { - "Opcode": 64, + "Opcode": 66, "Name": "PutOwnByIndex", "OperandTypes": [ "Reg8", @@ -671,7 +689,7 @@ "AbstractDefinition": 12 }, { - "Opcode": 65, + "Opcode": 67, "Name": "PutOwnByIndexL", "OperandTypes": [ "Reg8", @@ -682,7 +700,7 @@ "AbstractDefinition": 12 }, { - "Opcode": 66, + "Opcode": 68, "Name": "PutOwnByVal", "OperandTypes": [ "Reg8", @@ -693,7 +711,7 @@ "IsJump": false }, { - "Opcode": 67, + "Opcode": 69, "Name": "DelById", "OperandTypes": [ "Reg8", @@ -704,7 +722,7 @@ "AbstractDefinition": 13 }, { - "Opcode": 68, + "Opcode": 70, "Name": "DelByIdLong", "OperandTypes": [ "Reg8", @@ -715,7 +733,7 @@ "AbstractDefinition": 13 }, { - "Opcode": 69, + "Opcode": 71, "Name": "GetByVal", "OperandTypes": [ "Reg8", @@ -725,7 +743,7 @@ "IsJump": false }, { - "Opcode": 70, + "Opcode": 72, "Name": "PutByVal", "OperandTypes": [ "Reg8", @@ -735,7 +753,7 @@ "IsJump": false }, { - "Opcode": 71, + "Opcode": 73, "Name": "DelByVal", "OperandTypes": [ "Reg8", @@ -745,7 +763,7 @@ "IsJump": false }, { - "Opcode": 72, + "Opcode": 74, "Name": "PutOwnGetterSetterByVal", "OperandTypes": [ "Reg8", @@ -757,7 +775,7 @@ "IsJump": false }, { - "Opcode": 73, + "Opcode": 75, "Name": "GetPNameList", "OperandTypes": [ "Reg8", @@ -768,7 +786,7 @@ "IsJump": false }, { - "Opcode": 74, + "Opcode": 76, "Name": "GetNextPName", "OperandTypes": [ "Reg8", @@ -780,7 +798,7 @@ "IsJump": false }, { - "Opcode": 75, + "Opcode": 77, "Name": "Call", "OperandTypes": [ "Reg8", @@ -791,7 +809,7 @@ "AbstractDefinition": 14 }, { - "Opcode": 76, + "Opcode": 78, "Name": "Construct", "OperandTypes": [ "Reg8", @@ -802,7 +820,7 @@ "AbstractDefinition": 15 }, { - "Opcode": 77, + "Opcode": 79, "Name": "Call1", "OperandTypes": [ "Reg8", @@ -812,7 +830,7 @@ "IsJump": false }, { - "Opcode": 78, + "Opcode": 80, "Name": "CallDirect", "OperandTypes": [ "Reg8", @@ -823,7 +841,7 @@ "AbstractDefinition": 16 }, { - "Opcode": 79, + "Opcode": 81, "Name": "Call2", "OperandTypes": [ "Reg8", @@ -834,7 +852,7 @@ "IsJump": false }, { - "Opcode": 80, + "Opcode": 82, "Name": "Call3", "OperandTypes": [ "Reg8", @@ -846,7 +864,7 @@ "IsJump": false }, { - "Opcode": 81, + "Opcode": 83, "Name": "Call4", "OperandTypes": [ "Reg8", @@ -859,7 +877,7 @@ "IsJump": false }, { - "Opcode": 82, + "Opcode": 84, "Name": "CallLong", "OperandTypes": [ "Reg8", @@ -870,7 +888,7 @@ "AbstractDefinition": 14 }, { - "Opcode": 83, + "Opcode": 85, "Name": "ConstructLong", "OperandTypes": [ "Reg8", @@ -881,7 +899,7 @@ "AbstractDefinition": 15 }, { - "Opcode": 84, + "Opcode": 86, "Name": "CallDirectLongIndex", "OperandTypes": [ "Reg8", @@ -892,7 +910,7 @@ "AbstractDefinition": 16 }, { - "Opcode": 85, + "Opcode": 87, "Name": "CallBuiltin", "OperandTypes": [ "Reg8", @@ -903,7 +921,7 @@ "AbstractDefinition": 17 }, { - "Opcode": 86, + "Opcode": 88, "Name": "CallBuiltinLong", "OperandTypes": [ "Reg8", @@ -914,7 +932,7 @@ "AbstractDefinition": 17 }, { - "Opcode": 87, + "Opcode": 89, "Name": "GetBuiltinClosure", "OperandTypes": [ "Reg8", @@ -923,7 +941,7 @@ "IsJump": false }, { - "Opcode": 88, + "Opcode": 90, "Name": "Ret", "OperandTypes": [ "Reg8" @@ -931,7 +949,7 @@ "IsJump": false }, { - "Opcode": 89, + "Opcode": 91, "Name": "Catch", "OperandTypes": [ "Reg8" @@ -939,7 +957,7 @@ "IsJump": false }, { - "Opcode": 90, + "Opcode": 92, "Name": "DirectEval", "OperandTypes": [ "Reg8", @@ -948,7 +966,7 @@ "IsJump": false }, { - "Opcode": 91, + "Opcode": 93, "Name": "Throw", "OperandTypes": [ "Reg8" @@ -956,7 +974,7 @@ "IsJump": false }, { - "Opcode": 92, + "Opcode": 94, "Name": "ThrowIfEmpty", "OperandTypes": [ "Reg8", @@ -965,19 +983,19 @@ "IsJump": false }, { - "Opcode": 93, + "Opcode": 95, "Name": "Debugger", "OperandTypes": [], "IsJump": false }, { - "Opcode": 94, + "Opcode": 96, "Name": "AsyncBreakCheck", "OperandTypes": [], "IsJump": false }, { - "Opcode": 95, + "Opcode": 97, "Name": "ProfilePoint", "OperandTypes": [ "UInt16" @@ -985,7 +1003,7 @@ "IsJump": false }, { - "Opcode": 96, + "Opcode": 98, "Name": "CreateClosure", "OperandTypes": [ "Reg8", @@ -996,7 +1014,7 @@ "AbstractDefinition": 18 }, { - "Opcode": 97, + "Opcode": 99, "Name": "CreateClosureLongIndex", "OperandTypes": [ "Reg8", @@ -1007,7 +1025,7 @@ "AbstractDefinition": 18 }, { - "Opcode": 98, + "Opcode": 100, "Name": "CreateGeneratorClosure", "OperandTypes": [ "Reg8", @@ -1018,7 +1036,7 @@ "AbstractDefinition": 19 }, { - "Opcode": 99, + "Opcode": 101, "Name": "CreateGeneratorClosureLongIndex", "OperandTypes": [ "Reg8", @@ -1029,7 +1047,7 @@ "AbstractDefinition": 19 }, { - "Opcode": 100, + "Opcode": 102, "Name": "CreateAsyncClosure", "OperandTypes": [ "Reg8", @@ -1040,7 +1058,7 @@ "AbstractDefinition": 20 }, { - "Opcode": 101, + "Opcode": 103, "Name": "CreateAsyncClosureLongIndex", "OperandTypes": [ "Reg8", @@ -1051,7 +1069,7 @@ "AbstractDefinition": 20 }, { - "Opcode": 102, + "Opcode": 104, "Name": "CreateThis", "OperandTypes": [ "Reg8", @@ -1061,7 +1079,7 @@ "IsJump": false }, { - "Opcode": 103, + "Opcode": 105, "Name": "SelectObject", "OperandTypes": [ "Reg8", @@ -1071,7 +1089,7 @@ "IsJump": false }, { - "Opcode": 104, + "Opcode": 106, "Name": "LoadParam", "OperandTypes": [ "Reg8", @@ -1081,7 +1099,7 @@ "AbstractDefinition": 21 }, { - "Opcode": 105, + "Opcode": 107, "Name": "LoadParamLong", "OperandTypes": [ "Reg8", @@ -1091,7 +1109,7 @@ "AbstractDefinition": 21 }, { - "Opcode": 106, + "Opcode": 108, "Name": "LoadConstUInt8", "OperandTypes": [ "Reg8", @@ -1100,7 +1118,7 @@ "IsJump": false }, { - "Opcode": 107, + "Opcode": 109, "Name": "LoadConstInt", "OperandTypes": [ "Reg8", @@ -1109,7 +1127,7 @@ "IsJump": false }, { - "Opcode": 108, + "Opcode": 110, "Name": "LoadConstDouble", "OperandTypes": [ "Reg8", @@ -1118,7 +1136,7 @@ "IsJump": false }, { - "Opcode": 109, + "Opcode": 111, "Name": "LoadConstString", "OperandTypes": [ "Reg8", @@ -1128,7 +1146,7 @@ "AbstractDefinition": 22 }, { - "Opcode": 110, + "Opcode": 112, "Name": "LoadConstStringLongIndex", "OperandTypes": [ "Reg8", @@ -1138,7 +1156,7 @@ "AbstractDefinition": 22 }, { - "Opcode": 111, + "Opcode": 113, "Name": "LoadConstEmpty", "OperandTypes": [ "Reg8" @@ -1146,7 +1164,7 @@ "IsJump": false }, { - "Opcode": 112, + "Opcode": 114, "Name": "LoadConstUndefined", "OperandTypes": [ "Reg8" @@ -1154,7 +1172,7 @@ "IsJump": false }, { - "Opcode": 113, + "Opcode": 115, "Name": "LoadConstNull", "OperandTypes": [ "Reg8" @@ -1162,7 +1180,7 @@ "IsJump": false }, { - "Opcode": 114, + "Opcode": 116, "Name": "LoadConstTrue", "OperandTypes": [ "Reg8" @@ -1170,7 +1188,7 @@ "IsJump": false }, { - "Opcode": 115, + "Opcode": 117, "Name": "LoadConstFalse", "OperandTypes": [ "Reg8" @@ -1178,7 +1196,7 @@ "IsJump": false }, { - "Opcode": 116, + "Opcode": 118, "Name": "LoadConstZero", "OperandTypes": [ "Reg8" @@ -1186,7 +1204,7 @@ "IsJump": false }, { - "Opcode": 117, + "Opcode": 119, "Name": "CoerceThisNS", "OperandTypes": [ "Reg8", @@ -1195,7 +1213,7 @@ "IsJump": false }, { - "Opcode": 118, + "Opcode": 120, "Name": "LoadThisNS", "OperandTypes": [ "Reg8" @@ -1203,7 +1221,7 @@ "IsJump": false }, { - "Opcode": 119, + "Opcode": 121, "Name": "ToNumber", "OperandTypes": [ "Reg8", @@ -1212,7 +1230,7 @@ "IsJump": false }, { - "Opcode": 120, + "Opcode": 122, "Name": "ToInt32", "OperandTypes": [ "Reg8", @@ -1221,7 +1239,7 @@ "IsJump": false }, { - "Opcode": 121, + "Opcode": 123, "Name": "AddEmptyString", "OperandTypes": [ "Reg8", @@ -1230,7 +1248,7 @@ "IsJump": false }, { - "Opcode": 122, + "Opcode": 124, "Name": "GetArgumentsPropByVal", "OperandTypes": [ "Reg8", @@ -1240,7 +1258,7 @@ "IsJump": false }, { - "Opcode": 123, + "Opcode": 125, "Name": "GetArgumentsLength", "OperandTypes": [ "Reg8", @@ -1249,7 +1267,7 @@ "IsJump": false }, { - "Opcode": 124, + "Opcode": 126, "Name": "ReifyArguments", "OperandTypes": [ "Reg8" @@ -1257,7 +1275,7 @@ "IsJump": false }, { - "Opcode": 125, + "Opcode": 127, "Name": "CreateRegExp", "OperandTypes": [ "Reg8", @@ -1268,7 +1286,7 @@ "IsJump": false }, { - "Opcode": 126, + "Opcode": 128, "Name": "SwitchImm", "OperandTypes": [ "Reg8", @@ -1280,13 +1298,13 @@ "IsJump": false }, { - "Opcode": 127, + "Opcode": 129, "Name": "StartGenerator", "OperandTypes": [], "IsJump": false }, { - "Opcode": 128, + "Opcode": 130, "Name": "ResumeGenerator", "OperandTypes": [ "Reg8", @@ -1295,13 +1313,13 @@ "IsJump": false }, { - "Opcode": 129, + "Opcode": 131, "Name": "CompleteGenerator", "OperandTypes": [], "IsJump": false }, { - "Opcode": 130, + "Opcode": 132, "Name": "CreateGenerator", "OperandTypes": [ "Reg8", @@ -1312,7 +1330,7 @@ "AbstractDefinition": 23 }, { - "Opcode": 131, + "Opcode": 133, "Name": "CreateGeneratorLongIndex", "OperandTypes": [ "Reg8", @@ -1323,7 +1341,7 @@ "AbstractDefinition": 23 }, { - "Opcode": 132, + "Opcode": 134, "Name": "IteratorBegin", "OperandTypes": [ "Reg8", @@ -1332,7 +1350,7 @@ "IsJump": false }, { - "Opcode": 133, + "Opcode": 135, "Name": "IteratorNext", "OperandTypes": [ "Reg8", @@ -1342,7 +1360,7 @@ "IsJump": false }, { - "Opcode": 134, + "Opcode": 136, "Name": "IteratorClose", "OperandTypes": [ "Reg8", @@ -1351,7 +1369,7 @@ "IsJump": false }, { - "Opcode": 135, + "Opcode": 137, "Name": "Jmp", "OperandTypes": [ "Addr8" @@ -1360,7 +1378,7 @@ "AbstractDefinition": 24 }, { - "Opcode": 136, + "Opcode": 138, "Name": "JmpLong", "OperandTypes": [ "Addr32" @@ -1369,7 +1387,7 @@ "AbstractDefinition": 24 }, { - "Opcode": 137, + "Opcode": 139, "Name": "JmpTrue", "OperandTypes": [ "Addr8", @@ -1379,7 +1397,7 @@ "AbstractDefinition": 25 }, { - "Opcode": 138, + "Opcode": 140, "Name": "JmpTrueLong", "OperandTypes": [ "Addr32", @@ -1389,7 +1407,7 @@ "AbstractDefinition": 25 }, { - "Opcode": 139, + "Opcode": 141, "Name": "JmpFalse", "OperandTypes": [ "Addr8", @@ -1399,7 +1417,7 @@ "AbstractDefinition": 26 }, { - "Opcode": 140, + "Opcode": 142, "Name": "JmpFalseLong", "OperandTypes": [ "Addr32", @@ -1409,7 +1427,7 @@ "AbstractDefinition": 26 }, { - "Opcode": 141, + "Opcode": 143, "Name": "JmpUndefined", "OperandTypes": [ "Addr8", @@ -1419,7 +1437,7 @@ "AbstractDefinition": 27 }, { - "Opcode": 142, + "Opcode": 144, "Name": "JmpUndefinedLong", "OperandTypes": [ "Addr32", @@ -1429,7 +1447,7 @@ "AbstractDefinition": 27 }, { - "Opcode": 143, + "Opcode": 145, "Name": "SaveGenerator", "OperandTypes": [ "Addr8" @@ -1438,7 +1456,7 @@ "AbstractDefinition": 28 }, { - "Opcode": 144, + "Opcode": 146, "Name": "SaveGeneratorLong", "OperandTypes": [ "Addr32" @@ -1447,7 +1465,7 @@ "AbstractDefinition": 28 }, { - "Opcode": 145, + "Opcode": 147, "Name": "JLess", "OperandTypes": [ "Addr8", @@ -1458,7 +1476,7 @@ "AbstractDefinition": 29 }, { - "Opcode": 146, + "Opcode": 148, "Name": "JLessLong", "OperandTypes": [ "Addr32", @@ -1469,7 +1487,7 @@ "AbstractDefinition": 29 }, { - "Opcode": 147, + "Opcode": 149, "Name": "JNotLess", "OperandTypes": [ "Addr8", @@ -1480,7 +1498,7 @@ "AbstractDefinition": 30 }, { - "Opcode": 148, + "Opcode": 150, "Name": "JNotLessLong", "OperandTypes": [ "Addr32", @@ -1491,7 +1509,7 @@ "AbstractDefinition": 30 }, { - "Opcode": 149, + "Opcode": 151, "Name": "JLessN", "OperandTypes": [ "Addr8", @@ -1502,7 +1520,7 @@ "AbstractDefinition": 31 }, { - "Opcode": 150, + "Opcode": 152, "Name": "JLessNLong", "OperandTypes": [ "Addr32", @@ -1513,7 +1531,7 @@ "AbstractDefinition": 31 }, { - "Opcode": 151, + "Opcode": 153, "Name": "JNotLessN", "OperandTypes": [ "Addr8", @@ -1524,7 +1542,7 @@ "AbstractDefinition": 32 }, { - "Opcode": 152, + "Opcode": 154, "Name": "JNotLessNLong", "OperandTypes": [ "Addr32", @@ -1535,7 +1553,7 @@ "AbstractDefinition": 32 }, { - "Opcode": 153, + "Opcode": 155, "Name": "JLessEqual", "OperandTypes": [ "Addr8", @@ -1546,7 +1564,7 @@ "AbstractDefinition": 33 }, { - "Opcode": 154, + "Opcode": 156, "Name": "JLessEqualLong", "OperandTypes": [ "Addr32", @@ -1557,7 +1575,7 @@ "AbstractDefinition": 33 }, { - "Opcode": 155, + "Opcode": 157, "Name": "JNotLessEqual", "OperandTypes": [ "Addr8", @@ -1568,7 +1586,7 @@ "AbstractDefinition": 34 }, { - "Opcode": 156, + "Opcode": 158, "Name": "JNotLessEqualLong", "OperandTypes": [ "Addr32", @@ -1579,7 +1597,7 @@ "AbstractDefinition": 34 }, { - "Opcode": 157, + "Opcode": 159, "Name": "JLessEqualN", "OperandTypes": [ "Addr8", @@ -1590,7 +1608,7 @@ "AbstractDefinition": 35 }, { - "Opcode": 158, + "Opcode": 160, "Name": "JLessEqualNLong", "OperandTypes": [ "Addr32", @@ -1601,7 +1619,7 @@ "AbstractDefinition": 35 }, { - "Opcode": 159, + "Opcode": 161, "Name": "JNotLessEqualN", "OperandTypes": [ "Addr8", @@ -1612,7 +1630,7 @@ "AbstractDefinition": 36 }, { - "Opcode": 160, + "Opcode": 162, "Name": "JNotLessEqualNLong", "OperandTypes": [ "Addr32", @@ -1623,7 +1641,7 @@ "AbstractDefinition": 36 }, { - "Opcode": 161, + "Opcode": 163, "Name": "JGreater", "OperandTypes": [ "Addr8", @@ -1634,7 +1652,7 @@ "AbstractDefinition": 37 }, { - "Opcode": 162, + "Opcode": 164, "Name": "JGreaterLong", "OperandTypes": [ "Addr32", @@ -1645,7 +1663,7 @@ "AbstractDefinition": 37 }, { - "Opcode": 163, + "Opcode": 165, "Name": "JNotGreater", "OperandTypes": [ "Addr8", @@ -1656,7 +1674,7 @@ "AbstractDefinition": 38 }, { - "Opcode": 164, + "Opcode": 166, "Name": "JNotGreaterLong", "OperandTypes": [ "Addr32", @@ -1667,7 +1685,7 @@ "AbstractDefinition": 38 }, { - "Opcode": 165, + "Opcode": 167, "Name": "JGreaterN", "OperandTypes": [ "Addr8", @@ -1678,7 +1696,7 @@ "AbstractDefinition": 39 }, { - "Opcode": 166, + "Opcode": 168, "Name": "JGreaterNLong", "OperandTypes": [ "Addr32", @@ -1689,7 +1707,7 @@ "AbstractDefinition": 39 }, { - "Opcode": 167, + "Opcode": 169, "Name": "JNotGreaterN", "OperandTypes": [ "Addr8", @@ -1700,7 +1718,7 @@ "AbstractDefinition": 40 }, { - "Opcode": 168, + "Opcode": 170, "Name": "JNotGreaterNLong", "OperandTypes": [ "Addr32", @@ -1711,7 +1729,7 @@ "AbstractDefinition": 40 }, { - "Opcode": 169, + "Opcode": 171, "Name": "JGreaterEqual", "OperandTypes": [ "Addr8", @@ -1722,7 +1740,7 @@ "AbstractDefinition": 41 }, { - "Opcode": 170, + "Opcode": 172, "Name": "JGreaterEqualLong", "OperandTypes": [ "Addr32", @@ -1733,7 +1751,7 @@ "AbstractDefinition": 41 }, { - "Opcode": 171, + "Opcode": 173, "Name": "JNotGreaterEqual", "OperandTypes": [ "Addr8", @@ -1744,7 +1762,7 @@ "AbstractDefinition": 42 }, { - "Opcode": 172, + "Opcode": 174, "Name": "JNotGreaterEqualLong", "OperandTypes": [ "Addr32", @@ -1755,7 +1773,7 @@ "AbstractDefinition": 42 }, { - "Opcode": 173, + "Opcode": 175, "Name": "JGreaterEqualN", "OperandTypes": [ "Addr8", @@ -1766,7 +1784,7 @@ "AbstractDefinition": 43 }, { - "Opcode": 174, + "Opcode": 176, "Name": "JGreaterEqualNLong", "OperandTypes": [ "Addr32", @@ -1777,7 +1795,7 @@ "AbstractDefinition": 43 }, { - "Opcode": 175, + "Opcode": 177, "Name": "JNotGreaterEqualN", "OperandTypes": [ "Addr8", @@ -1788,7 +1806,7 @@ "AbstractDefinition": 44 }, { - "Opcode": 176, + "Opcode": 178, "Name": "JNotGreaterEqualNLong", "OperandTypes": [ "Addr32", @@ -1799,7 +1817,7 @@ "AbstractDefinition": 44 }, { - "Opcode": 177, + "Opcode": 179, "Name": "JEqual", "OperandTypes": [ "Addr8", @@ -1810,7 +1828,7 @@ "AbstractDefinition": 45 }, { - "Opcode": 178, + "Opcode": 180, "Name": "JEqualLong", "OperandTypes": [ "Addr32", @@ -1821,7 +1839,7 @@ "AbstractDefinition": 45 }, { - "Opcode": 179, + "Opcode": 181, "Name": "JNotEqual", "OperandTypes": [ "Addr8", @@ -1832,7 +1850,7 @@ "AbstractDefinition": 46 }, { - "Opcode": 180, + "Opcode": 182, "Name": "JNotEqualLong", "OperandTypes": [ "Addr32", @@ -1843,7 +1861,7 @@ "AbstractDefinition": 46 }, { - "Opcode": 181, + "Opcode": 183, "Name": "JStrictEqual", "OperandTypes": [ "Addr8", @@ -1854,7 +1872,7 @@ "AbstractDefinition": 47 }, { - "Opcode": 182, + "Opcode": 184, "Name": "JStrictEqualLong", "OperandTypes": [ "Addr32", @@ -1865,7 +1883,7 @@ "AbstractDefinition": 47 }, { - "Opcode": 183, + "Opcode": 185, "Name": "JStrictNotEqual", "OperandTypes": [ "Addr8", @@ -1876,7 +1894,7 @@ "AbstractDefinition": 48 }, { - "Opcode": 184, + "Opcode": 186, "Name": "JStrictNotEqualLong", "OperandTypes": [ "Addr32", @@ -1887,7 +1905,7 @@ "AbstractDefinition": 48 }, { - "Opcode": 185, + "Opcode": 187, "Name": "Add32", "OperandTypes": [ "Reg8", @@ -1897,7 +1915,7 @@ "IsJump": false }, { - "Opcode": 186, + "Opcode": 188, "Name": "Sub32", "OperandTypes": [ "Reg8", @@ -1907,7 +1925,7 @@ "IsJump": false }, { - "Opcode": 187, + "Opcode": 189, "Name": "Mul32", "OperandTypes": [ "Reg8", @@ -1917,7 +1935,7 @@ "IsJump": false }, { - "Opcode": 188, + "Opcode": 190, "Name": "Divi32", "OperandTypes": [ "Reg8", @@ -1927,7 +1945,7 @@ "IsJump": false }, { - "Opcode": 189, + "Opcode": 191, "Name": "Divu32", "OperandTypes": [ "Reg8", @@ -1937,7 +1955,7 @@ "IsJump": false }, { - "Opcode": 190, + "Opcode": 192, "Name": "Loadi8", "OperandTypes": [ "Reg8", @@ -1947,7 +1965,7 @@ "IsJump": false }, { - "Opcode": 191, + "Opcode": 193, "Name": "Loadu8", "OperandTypes": [ "Reg8", @@ -1957,7 +1975,7 @@ "IsJump": false }, { - "Opcode": 192, + "Opcode": 194, "Name": "Loadi16", "OperandTypes": [ "Reg8", @@ -1967,7 +1985,7 @@ "IsJump": false }, { - "Opcode": 193, + "Opcode": 195, "Name": "Loadu16", "OperandTypes": [ "Reg8", @@ -1977,7 +1995,7 @@ "IsJump": false }, { - "Opcode": 194, + "Opcode": 196, "Name": "Loadi32", "OperandTypes": [ "Reg8", @@ -1987,7 +2005,7 @@ "IsJump": false }, { - "Opcode": 195, + "Opcode": 197, "Name": "Loadu32", "OperandTypes": [ "Reg8", @@ -1997,7 +2015,7 @@ "IsJump": false }, { - "Opcode": 196, + "Opcode": 198, "Name": "Store8", "OperandTypes": [ "Reg8", @@ -2007,7 +2025,7 @@ "IsJump": false }, { - "Opcode": 197, + "Opcode": 199, "Name": "Store16", "OperandTypes": [ "Reg8", @@ -2017,7 +2035,7 @@ "IsJump": false }, { - "Opcode": 198, + "Opcode": 200, "Name": "Store32", "OperandTypes": [ "Reg8", @@ -2051,329 +2069,328 @@ }, { "Name": "StoreToEnvironment", - "VariantOpcodes": [ - 40, - 41 - ] - }, - { - "Name": "StoreNPToEnvironment", "VariantOpcodes": [ 42, 43 ] }, { - "Name": "LoadFromEnvironment", + "Name": "StoreNPToEnvironment", "VariantOpcodes": [ 44, 45 ] }, { - "Name": "GetById", + "Name": "LoadFromEnvironment", "VariantOpcodes": [ - 51, - 50, - 52 + 46, + 47 ] }, { - "Name": "TryGetById", + "Name": "GetById", "VariantOpcodes": [ 53, + 52, 54 ] }, { - "Name": "PutById", + "Name": "TryGetById", "VariantOpcodes": [ 55, 56 ] }, { - "Name": "TryPutById", + "Name": "PutById", "VariantOpcodes": [ 57, 58 ] }, { - "Name": "PutNewOwnById", + "Name": "TryPutById", "VariantOpcodes": [ - 60, 59, - 61 + 60 ] }, { - "Name": "PutNewOwnNEById", + "Name": "PutNewOwnById", "VariantOpcodes": [ 62, + 61, 63 ] }, { - "Name": "PutOwnByIndex", + "Name": "PutNewOwnNEById", "VariantOpcodes": [ 64, 65 ] }, + { + "Name": "PutOwnByIndex", + "VariantOpcodes": [ + 66, + 67 + ] + }, { "Name": "DelById", "VariantOpcodes": [ - 67, - 68 + 69, + 70 ] }, { "Name": "Call", "VariantOpcodes": [ - 75, - 82 + 77, + 84 ] }, { "Name": "Construct", "VariantOpcodes": [ - 76, - 83 + 78, + 85 ] }, { "Name": "CallDirect", "VariantOpcodes": [ - 78, - 84 + 80, + 86 ] }, { "Name": "CallBuiltin", "VariantOpcodes": [ - 85, - 86 + 87, + 88 ] }, { "Name": "CreateClosure", "VariantOpcodes": [ - 96, - 97 + 98, + 99 ] }, { "Name": "CreateGeneratorClosure", "VariantOpcodes": [ - 98, - 99 + 100, + 101 ] }, { "Name": "CreateAsyncClosure", "VariantOpcodes": [ - 100, - 101 + 102, + 103 ] }, { "Name": "LoadParam", "VariantOpcodes": [ - 104, - 105 + 106, + 107 ] }, { "Name": "LoadConstString", "VariantOpcodes": [ - 109, - 110 + 111, + 112 ] }, { "Name": "CreateGenerator", "VariantOpcodes": [ - 130, - 131 + 132, + 133 ] }, { "Name": "Jmp", - "VariantOpcodes": [ - 135, - 136 - ] - }, - { - "Name": "JmpTrue", "VariantOpcodes": [ 137, 138 ] }, { - "Name": "JmpFalse", + "Name": "JmpTrue", "VariantOpcodes": [ 139, 140 ] }, { - "Name": "JmpUndefined", + "Name": "JmpFalse", "VariantOpcodes": [ 141, 142 ] }, { - "Name": "SaveGenerator", + "Name": "JmpUndefined", "VariantOpcodes": [ 143, 144 ] }, { - "Name": "JLess", + "Name": "SaveGenerator", "VariantOpcodes": [ 145, 146 ] }, { - "Name": "JNotLess", + "Name": "JLess", "VariantOpcodes": [ 147, 148 ] }, { - "Name": "JLessN", + "Name": "JNotLess", "VariantOpcodes": [ 149, 150 ] }, { - "Name": "JNotLessN", + "Name": "JLessN", "VariantOpcodes": [ 151, 152 ] }, { - "Name": "JLessEqual", + "Name": "JNotLessN", "VariantOpcodes": [ 153, 154 ] }, { - "Name": "JNotLessEqual", + "Name": "JLessEqual", "VariantOpcodes": [ 155, 156 ] }, { - "Name": "JLessEqualN", + "Name": "JNotLessEqual", "VariantOpcodes": [ 157, 158 ] }, { - "Name": "JNotLessEqualN", + "Name": "JLessEqualN", "VariantOpcodes": [ 159, 160 ] }, { - "Name": "JGreater", + "Name": "JNotLessEqualN", "VariantOpcodes": [ 161, 162 ] }, { - "Name": "JNotGreater", + "Name": "JGreater", "VariantOpcodes": [ 163, 164 ] }, { - "Name": "JGreaterN", + "Name": "JNotGreater", "VariantOpcodes": [ 165, 166 ] }, { - "Name": "JNotGreaterN", + "Name": "JGreaterN", "VariantOpcodes": [ 167, 168 ] }, { - "Name": "JGreaterEqual", + "Name": "JNotGreaterN", "VariantOpcodes": [ 169, 170 ] }, { - "Name": "JNotGreaterEqual", + "Name": "JGreaterEqual", "VariantOpcodes": [ 171, 172 ] }, { - "Name": "JGreaterEqualN", + "Name": "JNotGreaterEqual", "VariantOpcodes": [ 173, 174 ] }, { - "Name": "JNotGreaterEqualN", + "Name": "JGreaterEqualN", "VariantOpcodes": [ 175, 176 ] }, { - "Name": "JEqual", + "Name": "JNotGreaterEqualN", "VariantOpcodes": [ 177, 178 ] }, { - "Name": "JNotEqual", + "Name": "JEqual", "VariantOpcodes": [ 179, 180 ] }, { - "Name": "JStrictEqual", + "Name": "JNotEqual", "VariantOpcodes": [ 181, 182 ] }, { - "Name": "JStrictNotEqual", + "Name": "JStrictEqual", "VariantOpcodes": [ 183, 184 ] + }, + { + "Name": "JStrictNotEqual", + "VariantOpcodes": [ + 185, + 186 + ] } ], - "GitTag": "v0.11.0", - "GitCommitHash": "c4f2fc3f499f7891958b9e6d7ab39fcb6ead93c8" + "GitCommitHash": "b8235156c0bfb0eea550243e67c5018661ff3185" } \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode87.json b/hasmer/libhasmer/Resources/Bytecode87.json new file mode 100644 index 0000000..a0d177c --- /dev/null +++ b/hasmer/libhasmer/Resources/Bytecode87.json @@ -0,0 +1,2432 @@ +{ + "Version": 87, + "Definitions": [ + { + "Opcode": 0, + "Name": "Unreachable", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 1, + "Name": "NewObjectWithBuffer", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt16", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 0 + }, + { + "Opcode": 2, + "Name": "NewObjectWithBufferLong", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt32", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 0 + }, + { + "Opcode": 3, + "Name": "NewObject", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 4, + "Name": "NewObjectWithParent", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 5, + "Name": "NewArrayWithBuffer", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 1 + }, + { + "Opcode": 6, + "Name": "NewArrayWithBufferLong", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 1 + }, + { + "Opcode": 7, + "Name": "NewArray", + "OperandTypes": [ + "Reg8", + "UInt16" + ], + "IsJump": false + }, + { + "Opcode": 8, + "Name": "Mov", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 2 + }, + { + "Opcode": 9, + "Name": "MovLong", + "OperandTypes": [ + "Reg32", + "Reg32" + ], + "IsJump": false, + "AbstractDefinition": 2 + }, + { + "Opcode": 10, + "Name": "Negate", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 11, + "Name": "Not", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 12, + "Name": "BitNot", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 13, + "Name": "TypeOf", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 14, + "Name": "Eq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 15, + "Name": "StrictEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 16, + "Name": "Neq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 17, + "Name": "StrictNeq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 18, + "Name": "Less", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 19, + "Name": "LessEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 20, + "Name": "Greater", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 21, + "Name": "GreaterEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 22, + "Name": "Add", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 23, + "Name": "AddN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 24, + "Name": "Mul", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 25, + "Name": "MulN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 26, + "Name": "Div", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 27, + "Name": "DivN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 28, + "Name": "Mod", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 29, + "Name": "Sub", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 30, + "Name": "SubN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 31, + "Name": "LShift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 32, + "Name": "RShift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 33, + "Name": "URshift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 34, + "Name": "BitAnd", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 35, + "Name": "BitXor", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 36, + "Name": "BitOr", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 37, + "Name": "Inc", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 38, + "Name": "Dec", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 39, + "Name": "InstanceOf", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 40, + "Name": "IsIn", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 41, + "Name": "GetEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 42, + "Name": "StoreToEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 3 + }, + { + "Opcode": 43, + "Name": "StoreToEnvironmentL", + "OperandTypes": [ + "Reg8", + "UInt16", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 3 + }, + { + "Opcode": 44, + "Name": "StoreNPToEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 4 + }, + { + "Opcode": 45, + "Name": "StoreNPToEnvironmentL", + "OperandTypes": [ + "Reg8", + "UInt16", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 4 + }, + { + "Opcode": 46, + "Name": "LoadFromEnvironment", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 5 + }, + { + "Opcode": 47, + "Name": "LoadFromEnvironmentL", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 5 + }, + { + "Opcode": 48, + "Name": "GetGlobalObject", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 49, + "Name": "GetNewTarget", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 50, + "Name": "CreateEnvironment", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 51, + "Name": "DeclareGlobalVar", + "OperandTypes": [ + "UInt32S" + ], + "IsJump": false + }, + { + "Opcode": 52, + "Name": "GetByIdShort", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt8S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 53, + "Name": "GetById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 54, + "Name": "GetByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 55, + "Name": "TryGetById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 7 + }, + { + "Opcode": 56, + "Name": "TryGetByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 7 + }, + { + "Opcode": 57, + "Name": "PutById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 8 + }, + { + "Opcode": 58, + "Name": "PutByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 8 + }, + { + "Opcode": 59, + "Name": "TryPutById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 9 + }, + { + "Opcode": 60, + "Name": "TryPutByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 9 + }, + { + "Opcode": 61, + "Name": "PutNewOwnByIdShort", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 62, + "Name": "PutNewOwnById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 63, + "Name": "PutNewOwnByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 64, + "Name": "PutNewOwnNEById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 11 + }, + { + "Opcode": 65, + "Name": "PutNewOwnNEByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 11 + }, + { + "Opcode": 66, + "Name": "PutOwnByIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 12 + }, + { + "Opcode": 67, + "Name": "PutOwnByIndexL", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 12 + }, + { + "Opcode": 68, + "Name": "PutOwnByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 69, + "Name": "DelById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 13 + }, + { + "Opcode": 70, + "Name": "DelByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 13 + }, + { + "Opcode": 71, + "Name": "GetByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 72, + "Name": "PutByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 73, + "Name": "DelByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 74, + "Name": "PutOwnGetterSetterByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 75, + "Name": "GetPNameList", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 76, + "Name": "GetNextPName", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 77, + "Name": "Call", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 14 + }, + { + "Opcode": 78, + "Name": "Construct", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 15 + }, + { + "Opcode": 79, + "Name": "Call1", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 80, + "Name": "CallDirect", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 16 + }, + { + "Opcode": 81, + "Name": "Call2", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 82, + "Name": "Call3", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 83, + "Name": "Call4", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 84, + "Name": "CallLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 14 + }, + { + "Opcode": 85, + "Name": "ConstructLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 15 + }, + { + "Opcode": 86, + "Name": "CallDirectLongIndex", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 16 + }, + { + "Opcode": 87, + "Name": "CallBuiltin", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 17 + }, + { + "Opcode": 88, + "Name": "CallBuiltinLong", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 17 + }, + { + "Opcode": 89, + "Name": "GetBuiltinClosure", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 90, + "Name": "Ret", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 91, + "Name": "Catch", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 92, + "Name": "DirectEval", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 93, + "Name": "Throw", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 94, + "Name": "ThrowIfEmpty", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 95, + "Name": "Debugger", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 96, + "Name": "AsyncBreakCheck", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 97, + "Name": "ProfilePoint", + "OperandTypes": [ + "UInt16" + ], + "IsJump": false + }, + { + "Opcode": 98, + "Name": "CreateClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 18 + }, + { + "Opcode": 99, + "Name": "CreateClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 18 + }, + { + "Opcode": 100, + "Name": "CreateGeneratorClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 19 + }, + { + "Opcode": 101, + "Name": "CreateGeneratorClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 19 + }, + { + "Opcode": 102, + "Name": "CreateAsyncClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 20 + }, + { + "Opcode": 103, + "Name": "CreateAsyncClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 20 + }, + { + "Opcode": 104, + "Name": "CreateThis", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 105, + "Name": "SelectObject", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 106, + "Name": "LoadParam", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 21 + }, + { + "Opcode": 107, + "Name": "LoadParamLong", + "OperandTypes": [ + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 21 + }, + { + "Opcode": 108, + "Name": "LoadConstUInt8", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 109, + "Name": "LoadConstInt", + "OperandTypes": [ + "Reg8", + "Imm32" + ], + "IsJump": false + }, + { + "Opcode": 110, + "Name": "LoadConstDouble", + "OperandTypes": [ + "Reg8", + "Double" + ], + "IsJump": false + }, + { + "Opcode": 111, + "Name": "LoadConstBigInt", + "OperandTypes": [ + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 22 + }, + { + "Opcode": 112, + "Name": "LoadConstBigIntLongIndex", + "OperandTypes": [ + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 22 + }, + { + "Opcode": 113, + "Name": "LoadConstString", + "OperandTypes": [ + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 23 + }, + { + "Opcode": 114, + "Name": "LoadConstStringLongIndex", + "OperandTypes": [ + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 23 + }, + { + "Opcode": 115, + "Name": "LoadConstEmpty", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 116, + "Name": "LoadConstUndefined", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 117, + "Name": "LoadConstNull", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 118, + "Name": "LoadConstTrue", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 119, + "Name": "LoadConstFalse", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 120, + "Name": "LoadConstZero", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 121, + "Name": "CoerceThisNS", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 122, + "Name": "LoadThisNS", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 123, + "Name": "ToNumber", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 124, + "Name": "ToNumeric", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 125, + "Name": "ToInt32", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 126, + "Name": "AddEmptyString", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 127, + "Name": "GetArgumentsPropByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 128, + "Name": "GetArgumentsLength", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 129, + "Name": "ReifyArguments", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 130, + "Name": "CreateRegExp", + "OperandTypes": [ + "Reg8", + "UInt32S", + "UInt32S", + "UInt32" + ], + "IsJump": false + }, + { + "Opcode": 131, + "Name": "SwitchImm", + "OperandTypes": [ + "Reg8", + "UInt32", + "Addr32", + "UInt32", + "UInt32" + ], + "IsJump": false + }, + { + "Opcode": 132, + "Name": "StartGenerator", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 133, + "Name": "ResumeGenerator", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 134, + "Name": "CompleteGenerator", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 135, + "Name": "CreateGenerator", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 24 + }, + { + "Opcode": 136, + "Name": "CreateGeneratorLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 24 + }, + { + "Opcode": 137, + "Name": "IteratorBegin", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 138, + "Name": "IteratorNext", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 139, + "Name": "IteratorClose", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 140, + "Name": "Jmp", + "OperandTypes": [ + "Addr8" + ], + "IsJump": true, + "AbstractDefinition": 25 + }, + { + "Opcode": 141, + "Name": "JmpLong", + "OperandTypes": [ + "Addr32" + ], + "IsJump": true, + "AbstractDefinition": 25 + }, + { + "Opcode": 142, + "Name": "JmpTrue", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 26 + }, + { + "Opcode": 143, + "Name": "JmpTrueLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 26 + }, + { + "Opcode": 144, + "Name": "JmpFalse", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 27 + }, + { + "Opcode": 145, + "Name": "JmpFalseLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 27 + }, + { + "Opcode": 146, + "Name": "JmpUndefined", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 28 + }, + { + "Opcode": 147, + "Name": "JmpUndefinedLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 28 + }, + { + "Opcode": 148, + "Name": "SaveGenerator", + "OperandTypes": [ + "Addr8" + ], + "IsJump": true, + "AbstractDefinition": 29 + }, + { + "Opcode": 149, + "Name": "SaveGeneratorLong", + "OperandTypes": [ + "Addr32" + ], + "IsJump": true, + "AbstractDefinition": 29 + }, + { + "Opcode": 150, + "Name": "JLess", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 30 + }, + { + "Opcode": 151, + "Name": "JLessLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 30 + }, + { + "Opcode": 152, + "Name": "JNotLess", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 31 + }, + { + "Opcode": 153, + "Name": "JNotLessLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 31 + }, + { + "Opcode": 154, + "Name": "JLessN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 32 + }, + { + "Opcode": 155, + "Name": "JLessNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 32 + }, + { + "Opcode": 156, + "Name": "JNotLessN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 33 + }, + { + "Opcode": 157, + "Name": "JNotLessNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 33 + }, + { + "Opcode": 158, + "Name": "JLessEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 34 + }, + { + "Opcode": 159, + "Name": "JLessEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 34 + }, + { + "Opcode": 160, + "Name": "JNotLessEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 35 + }, + { + "Opcode": 161, + "Name": "JNotLessEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 35 + }, + { + "Opcode": 162, + "Name": "JLessEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 36 + }, + { + "Opcode": 163, + "Name": "JLessEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 36 + }, + { + "Opcode": 164, + "Name": "JNotLessEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 37 + }, + { + "Opcode": 165, + "Name": "JNotLessEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 37 + }, + { + "Opcode": 166, + "Name": "JGreater", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 38 + }, + { + "Opcode": 167, + "Name": "JGreaterLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 38 + }, + { + "Opcode": 168, + "Name": "JNotGreater", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 39 + }, + { + "Opcode": 169, + "Name": "JNotGreaterLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 39 + }, + { + "Opcode": 170, + "Name": "JGreaterN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 40 + }, + { + "Opcode": 171, + "Name": "JGreaterNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 40 + }, + { + "Opcode": 172, + "Name": "JNotGreaterN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 41 + }, + { + "Opcode": 173, + "Name": "JNotGreaterNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 41 + }, + { + "Opcode": 174, + "Name": "JGreaterEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 42 + }, + { + "Opcode": 175, + "Name": "JGreaterEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 42 + }, + { + "Opcode": 176, + "Name": "JNotGreaterEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 43 + }, + { + "Opcode": 177, + "Name": "JNotGreaterEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 43 + }, + { + "Opcode": 178, + "Name": "JGreaterEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 44 + }, + { + "Opcode": 179, + "Name": "JGreaterEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 44 + }, + { + "Opcode": 180, + "Name": "JNotGreaterEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 45 + }, + { + "Opcode": 181, + "Name": "JNotGreaterEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 45 + }, + { + "Opcode": 182, + "Name": "JEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 46 + }, + { + "Opcode": 183, + "Name": "JEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 46 + }, + { + "Opcode": 184, + "Name": "JNotEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 47 + }, + { + "Opcode": 185, + "Name": "JNotEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 47 + }, + { + "Opcode": 186, + "Name": "JStrictEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 48 + }, + { + "Opcode": 187, + "Name": "JStrictEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 48 + }, + { + "Opcode": 188, + "Name": "JStrictNotEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 49 + }, + { + "Opcode": 189, + "Name": "JStrictNotEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 49 + }, + { + "Opcode": 190, + "Name": "Add32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 191, + "Name": "Sub32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 192, + "Name": "Mul32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 193, + "Name": "Divi32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 194, + "Name": "Divu32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 195, + "Name": "Loadi8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 196, + "Name": "Loadu8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 197, + "Name": "Loadi16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 198, + "Name": "Loadu16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 199, + "Name": "Loadi32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 200, + "Name": "Loadu32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 201, + "Name": "Store8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 202, + "Name": "Store16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 203, + "Name": "Store32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + } + ], + "AbstractDefinitions": [ + { + "Name": "NewObjectWithBuffer", + "VariantOpcodes": [ + 1, + 2 + ] + }, + { + "Name": "NewArrayWithBuffer", + "VariantOpcodes": [ + 5, + 6 + ] + }, + { + "Name": "Mov", + "VariantOpcodes": [ + 8, + 9 + ] + }, + { + "Name": "StoreToEnvironment", + "VariantOpcodes": [ + 42, + 43 + ] + }, + { + "Name": "StoreNPToEnvironment", + "VariantOpcodes": [ + 44, + 45 + ] + }, + { + "Name": "LoadFromEnvironment", + "VariantOpcodes": [ + 46, + 47 + ] + }, + { + "Name": "GetById", + "VariantOpcodes": [ + 53, + 52, + 54 + ] + }, + { + "Name": "TryGetById", + "VariantOpcodes": [ + 55, + 56 + ] + }, + { + "Name": "PutById", + "VariantOpcodes": [ + 57, + 58 + ] + }, + { + "Name": "TryPutById", + "VariantOpcodes": [ + 59, + 60 + ] + }, + { + "Name": "PutNewOwnById", + "VariantOpcodes": [ + 62, + 61, + 63 + ] + }, + { + "Name": "PutNewOwnNEById", + "VariantOpcodes": [ + 64, + 65 + ] + }, + { + "Name": "PutOwnByIndex", + "VariantOpcodes": [ + 66, + 67 + ] + }, + { + "Name": "DelById", + "VariantOpcodes": [ + 69, + 70 + ] + }, + { + "Name": "Call", + "VariantOpcodes": [ + 77, + 84 + ] + }, + { + "Name": "Construct", + "VariantOpcodes": [ + 78, + 85 + ] + }, + { + "Name": "CallDirect", + "VariantOpcodes": [ + 80, + 86 + ] + }, + { + "Name": "CallBuiltin", + "VariantOpcodes": [ + 87, + 88 + ] + }, + { + "Name": "CreateClosure", + "VariantOpcodes": [ + 98, + 99 + ] + }, + { + "Name": "CreateGeneratorClosure", + "VariantOpcodes": [ + 100, + 101 + ] + }, + { + "Name": "CreateAsyncClosure", + "VariantOpcodes": [ + 102, + 103 + ] + }, + { + "Name": "LoadParam", + "VariantOpcodes": [ + 106, + 107 + ] + }, + { + "Name": "LoadConstBigInt", + "VariantOpcodes": [ + 111, + 112 + ] + }, + { + "Name": "LoadConstString", + "VariantOpcodes": [ + 113, + 114 + ] + }, + { + "Name": "CreateGenerator", + "VariantOpcodes": [ + 135, + 136 + ] + }, + { + "Name": "Jmp", + "VariantOpcodes": [ + 140, + 141 + ] + }, + { + "Name": "JmpTrue", + "VariantOpcodes": [ + 142, + 143 + ] + }, + { + "Name": "JmpFalse", + "VariantOpcodes": [ + 144, + 145 + ] + }, + { + "Name": "JmpUndefined", + "VariantOpcodes": [ + 146, + 147 + ] + }, + { + "Name": "SaveGenerator", + "VariantOpcodes": [ + 148, + 149 + ] + }, + { + "Name": "JLess", + "VariantOpcodes": [ + 150, + 151 + ] + }, + { + "Name": "JNotLess", + "VariantOpcodes": [ + 152, + 153 + ] + }, + { + "Name": "JLessN", + "VariantOpcodes": [ + 154, + 155 + ] + }, + { + "Name": "JNotLessN", + "VariantOpcodes": [ + 156, + 157 + ] + }, + { + "Name": "JLessEqual", + "VariantOpcodes": [ + 158, + 159 + ] + }, + { + "Name": "JNotLessEqual", + "VariantOpcodes": [ + 160, + 161 + ] + }, + { + "Name": "JLessEqualN", + "VariantOpcodes": [ + 162, + 163 + ] + }, + { + "Name": "JNotLessEqualN", + "VariantOpcodes": [ + 164, + 165 + ] + }, + { + "Name": "JGreater", + "VariantOpcodes": [ + 166, + 167 + ] + }, + { + "Name": "JNotGreater", + "VariantOpcodes": [ + 168, + 169 + ] + }, + { + "Name": "JGreaterN", + "VariantOpcodes": [ + 170, + 171 + ] + }, + { + "Name": "JNotGreaterN", + "VariantOpcodes": [ + 172, + 173 + ] + }, + { + "Name": "JGreaterEqual", + "VariantOpcodes": [ + 174, + 175 + ] + }, + { + "Name": "JNotGreaterEqual", + "VariantOpcodes": [ + 176, + 177 + ] + }, + { + "Name": "JGreaterEqualN", + "VariantOpcodes": [ + 178, + 179 + ] + }, + { + "Name": "JNotGreaterEqualN", + "VariantOpcodes": [ + 180, + 181 + ] + }, + { + "Name": "JEqual", + "VariantOpcodes": [ + 182, + 183 + ] + }, + { + "Name": "JNotEqual", + "VariantOpcodes": [ + 184, + 185 + ] + }, + { + "Name": "JStrictEqual", + "VariantOpcodes": [ + 186, + 187 + ] + }, + { + "Name": "JStrictNotEqual", + "VariantOpcodes": [ + 188, + 189 + ] + } + ], + "GitCommitHash": "41752c6589227694ae3a96a34e932c74c9ce3699" +} \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode88.json b/hasmer/libhasmer/Resources/Bytecode88.json new file mode 100644 index 0000000..beb5020 --- /dev/null +++ b/hasmer/libhasmer/Resources/Bytecode88.json @@ -0,0 +1,2432 @@ +{ + "Version": 88, + "Definitions": [ + { + "Opcode": 0, + "Name": "Unreachable", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 1, + "Name": "NewObjectWithBuffer", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt16", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 0 + }, + { + "Opcode": 2, + "Name": "NewObjectWithBufferLong", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt32", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 0 + }, + { + "Opcode": 3, + "Name": "NewObject", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 4, + "Name": "NewObjectWithParent", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 5, + "Name": "NewArrayWithBuffer", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 1 + }, + { + "Opcode": 6, + "Name": "NewArrayWithBufferLong", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 1 + }, + { + "Opcode": 7, + "Name": "NewArray", + "OperandTypes": [ + "Reg8", + "UInt16" + ], + "IsJump": false + }, + { + "Opcode": 8, + "Name": "Mov", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 2 + }, + { + "Opcode": 9, + "Name": "MovLong", + "OperandTypes": [ + "Reg32", + "Reg32" + ], + "IsJump": false, + "AbstractDefinition": 2 + }, + { + "Opcode": 10, + "Name": "Negate", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 11, + "Name": "Not", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 12, + "Name": "BitNot", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 13, + "Name": "TypeOf", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 14, + "Name": "Eq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 15, + "Name": "StrictEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 16, + "Name": "Neq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 17, + "Name": "StrictNeq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 18, + "Name": "Less", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 19, + "Name": "LessEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 20, + "Name": "Greater", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 21, + "Name": "GreaterEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 22, + "Name": "Add", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 23, + "Name": "AddN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 24, + "Name": "Mul", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 25, + "Name": "MulN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 26, + "Name": "Div", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 27, + "Name": "DivN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 28, + "Name": "Mod", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 29, + "Name": "Sub", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 30, + "Name": "SubN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 31, + "Name": "LShift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 32, + "Name": "RShift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 33, + "Name": "URshift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 34, + "Name": "BitAnd", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 35, + "Name": "BitXor", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 36, + "Name": "BitOr", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 37, + "Name": "Inc", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 38, + "Name": "Dec", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 39, + "Name": "InstanceOf", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 40, + "Name": "IsIn", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 41, + "Name": "GetEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 42, + "Name": "StoreToEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 3 + }, + { + "Opcode": 43, + "Name": "StoreToEnvironmentL", + "OperandTypes": [ + "Reg8", + "UInt16", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 3 + }, + { + "Opcode": 44, + "Name": "StoreNPToEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 4 + }, + { + "Opcode": 45, + "Name": "StoreNPToEnvironmentL", + "OperandTypes": [ + "Reg8", + "UInt16", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 4 + }, + { + "Opcode": 46, + "Name": "LoadFromEnvironment", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 5 + }, + { + "Opcode": 47, + "Name": "LoadFromEnvironmentL", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 5 + }, + { + "Opcode": 48, + "Name": "GetGlobalObject", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 49, + "Name": "GetNewTarget", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 50, + "Name": "CreateEnvironment", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 51, + "Name": "DeclareGlobalVar", + "OperandTypes": [ + "UInt32S" + ], + "IsJump": false + }, + { + "Opcode": 52, + "Name": "GetByIdShort", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt8S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 53, + "Name": "GetById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 54, + "Name": "GetByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 55, + "Name": "TryGetById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 7 + }, + { + "Opcode": 56, + "Name": "TryGetByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 7 + }, + { + "Opcode": 57, + "Name": "PutById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 8 + }, + { + "Opcode": 58, + "Name": "PutByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 8 + }, + { + "Opcode": 59, + "Name": "TryPutById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 9 + }, + { + "Opcode": 60, + "Name": "TryPutByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 9 + }, + { + "Opcode": 61, + "Name": "PutNewOwnByIdShort", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 62, + "Name": "PutNewOwnById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 63, + "Name": "PutNewOwnByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 64, + "Name": "PutNewOwnNEById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 11 + }, + { + "Opcode": 65, + "Name": "PutNewOwnNEByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 11 + }, + { + "Opcode": 66, + "Name": "PutOwnByIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 12 + }, + { + "Opcode": 67, + "Name": "PutOwnByIndexL", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 12 + }, + { + "Opcode": 68, + "Name": "PutOwnByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 69, + "Name": "DelById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 13 + }, + { + "Opcode": 70, + "Name": "DelByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 13 + }, + { + "Opcode": 71, + "Name": "GetByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 72, + "Name": "PutByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 73, + "Name": "DelByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 74, + "Name": "PutOwnGetterSetterByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 75, + "Name": "GetPNameList", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 76, + "Name": "GetNextPName", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 77, + "Name": "Call", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 14 + }, + { + "Opcode": 78, + "Name": "Construct", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 15 + }, + { + "Opcode": 79, + "Name": "Call1", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 80, + "Name": "CallDirect", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 16 + }, + { + "Opcode": 81, + "Name": "Call2", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 82, + "Name": "Call3", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 83, + "Name": "Call4", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 84, + "Name": "CallLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 14 + }, + { + "Opcode": 85, + "Name": "ConstructLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 15 + }, + { + "Opcode": 86, + "Name": "CallDirectLongIndex", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 16 + }, + { + "Opcode": 87, + "Name": "CallBuiltin", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 17 + }, + { + "Opcode": 88, + "Name": "CallBuiltinLong", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 17 + }, + { + "Opcode": 89, + "Name": "GetBuiltinClosure", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 90, + "Name": "Ret", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 91, + "Name": "Catch", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 92, + "Name": "DirectEval", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 93, + "Name": "Throw", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 94, + "Name": "ThrowIfEmpty", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 95, + "Name": "Debugger", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 96, + "Name": "AsyncBreakCheck", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 97, + "Name": "ProfilePoint", + "OperandTypes": [ + "UInt16" + ], + "IsJump": false + }, + { + "Opcode": 98, + "Name": "CreateClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 18 + }, + { + "Opcode": 99, + "Name": "CreateClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 18 + }, + { + "Opcode": 100, + "Name": "CreateGeneratorClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 19 + }, + { + "Opcode": 101, + "Name": "CreateGeneratorClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 19 + }, + { + "Opcode": 102, + "Name": "CreateAsyncClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 20 + }, + { + "Opcode": 103, + "Name": "CreateAsyncClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 20 + }, + { + "Opcode": 104, + "Name": "CreateThis", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 105, + "Name": "SelectObject", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 106, + "Name": "LoadParam", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 21 + }, + { + "Opcode": 107, + "Name": "LoadParamLong", + "OperandTypes": [ + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 21 + }, + { + "Opcode": 108, + "Name": "LoadConstUInt8", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 109, + "Name": "LoadConstInt", + "OperandTypes": [ + "Reg8", + "Imm32" + ], + "IsJump": false + }, + { + "Opcode": 110, + "Name": "LoadConstDouble", + "OperandTypes": [ + "Reg8", + "Double" + ], + "IsJump": false + }, + { + "Opcode": 111, + "Name": "LoadConstBigInt", + "OperandTypes": [ + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 22 + }, + { + "Opcode": 112, + "Name": "LoadConstBigIntLongIndex", + "OperandTypes": [ + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 22 + }, + { + "Opcode": 113, + "Name": "LoadConstString", + "OperandTypes": [ + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 23 + }, + { + "Opcode": 114, + "Name": "LoadConstStringLongIndex", + "OperandTypes": [ + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 23 + }, + { + "Opcode": 115, + "Name": "LoadConstEmpty", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 116, + "Name": "LoadConstUndefined", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 117, + "Name": "LoadConstNull", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 118, + "Name": "LoadConstTrue", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 119, + "Name": "LoadConstFalse", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 120, + "Name": "LoadConstZero", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 121, + "Name": "CoerceThisNS", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 122, + "Name": "LoadThisNS", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 123, + "Name": "ToNumber", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 124, + "Name": "ToNumeric", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 125, + "Name": "ToInt32", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 126, + "Name": "AddEmptyString", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 127, + "Name": "GetArgumentsPropByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 128, + "Name": "GetArgumentsLength", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 129, + "Name": "ReifyArguments", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 130, + "Name": "CreateRegExp", + "OperandTypes": [ + "Reg8", + "UInt32S", + "UInt32S", + "UInt32" + ], + "IsJump": false + }, + { + "Opcode": 131, + "Name": "SwitchImm", + "OperandTypes": [ + "Reg8", + "UInt32", + "Addr32", + "UInt32", + "UInt32" + ], + "IsJump": false + }, + { + "Opcode": 132, + "Name": "StartGenerator", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 133, + "Name": "ResumeGenerator", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 134, + "Name": "CompleteGenerator", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 135, + "Name": "CreateGenerator", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 24 + }, + { + "Opcode": 136, + "Name": "CreateGeneratorLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 24 + }, + { + "Opcode": 137, + "Name": "IteratorBegin", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 138, + "Name": "IteratorNext", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 139, + "Name": "IteratorClose", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 140, + "Name": "Jmp", + "OperandTypes": [ + "Addr8" + ], + "IsJump": true, + "AbstractDefinition": 25 + }, + { + "Opcode": 141, + "Name": "JmpLong", + "OperandTypes": [ + "Addr32" + ], + "IsJump": true, + "AbstractDefinition": 25 + }, + { + "Opcode": 142, + "Name": "JmpTrue", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 26 + }, + { + "Opcode": 143, + "Name": "JmpTrueLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 26 + }, + { + "Opcode": 144, + "Name": "JmpFalse", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 27 + }, + { + "Opcode": 145, + "Name": "JmpFalseLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 27 + }, + { + "Opcode": 146, + "Name": "JmpUndefined", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 28 + }, + { + "Opcode": 147, + "Name": "JmpUndefinedLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 28 + }, + { + "Opcode": 148, + "Name": "SaveGenerator", + "OperandTypes": [ + "Addr8" + ], + "IsJump": true, + "AbstractDefinition": 29 + }, + { + "Opcode": 149, + "Name": "SaveGeneratorLong", + "OperandTypes": [ + "Addr32" + ], + "IsJump": true, + "AbstractDefinition": 29 + }, + { + "Opcode": 150, + "Name": "JLess", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 30 + }, + { + "Opcode": 151, + "Name": "JLessLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 30 + }, + { + "Opcode": 152, + "Name": "JNotLess", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 31 + }, + { + "Opcode": 153, + "Name": "JNotLessLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 31 + }, + { + "Opcode": 154, + "Name": "JLessN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 32 + }, + { + "Opcode": 155, + "Name": "JLessNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 32 + }, + { + "Opcode": 156, + "Name": "JNotLessN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 33 + }, + { + "Opcode": 157, + "Name": "JNotLessNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 33 + }, + { + "Opcode": 158, + "Name": "JLessEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 34 + }, + { + "Opcode": 159, + "Name": "JLessEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 34 + }, + { + "Opcode": 160, + "Name": "JNotLessEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 35 + }, + { + "Opcode": 161, + "Name": "JNotLessEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 35 + }, + { + "Opcode": 162, + "Name": "JLessEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 36 + }, + { + "Opcode": 163, + "Name": "JLessEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 36 + }, + { + "Opcode": 164, + "Name": "JNotLessEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 37 + }, + { + "Opcode": 165, + "Name": "JNotLessEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 37 + }, + { + "Opcode": 166, + "Name": "JGreater", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 38 + }, + { + "Opcode": 167, + "Name": "JGreaterLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 38 + }, + { + "Opcode": 168, + "Name": "JNotGreater", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 39 + }, + { + "Opcode": 169, + "Name": "JNotGreaterLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 39 + }, + { + "Opcode": 170, + "Name": "JGreaterN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 40 + }, + { + "Opcode": 171, + "Name": "JGreaterNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 40 + }, + { + "Opcode": 172, + "Name": "JNotGreaterN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 41 + }, + { + "Opcode": 173, + "Name": "JNotGreaterNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 41 + }, + { + "Opcode": 174, + "Name": "JGreaterEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 42 + }, + { + "Opcode": 175, + "Name": "JGreaterEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 42 + }, + { + "Opcode": 176, + "Name": "JNotGreaterEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 43 + }, + { + "Opcode": 177, + "Name": "JNotGreaterEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 43 + }, + { + "Opcode": 178, + "Name": "JGreaterEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 44 + }, + { + "Opcode": 179, + "Name": "JGreaterEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 44 + }, + { + "Opcode": 180, + "Name": "JNotGreaterEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 45 + }, + { + "Opcode": 181, + "Name": "JNotGreaterEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 45 + }, + { + "Opcode": 182, + "Name": "JEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 46 + }, + { + "Opcode": 183, + "Name": "JEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 46 + }, + { + "Opcode": 184, + "Name": "JNotEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 47 + }, + { + "Opcode": 185, + "Name": "JNotEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 47 + }, + { + "Opcode": 186, + "Name": "JStrictEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 48 + }, + { + "Opcode": 187, + "Name": "JStrictEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 48 + }, + { + "Opcode": 188, + "Name": "JStrictNotEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 49 + }, + { + "Opcode": 189, + "Name": "JStrictNotEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 49 + }, + { + "Opcode": 190, + "Name": "Add32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 191, + "Name": "Sub32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 192, + "Name": "Mul32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 193, + "Name": "Divi32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 194, + "Name": "Divu32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 195, + "Name": "Loadi8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 196, + "Name": "Loadu8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 197, + "Name": "Loadi16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 198, + "Name": "Loadu16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 199, + "Name": "Loadi32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 200, + "Name": "Loadu32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 201, + "Name": "Store8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 202, + "Name": "Store16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 203, + "Name": "Store32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + } + ], + "AbstractDefinitions": [ + { + "Name": "NewObjectWithBuffer", + "VariantOpcodes": [ + 1, + 2 + ] + }, + { + "Name": "NewArrayWithBuffer", + "VariantOpcodes": [ + 5, + 6 + ] + }, + { + "Name": "Mov", + "VariantOpcodes": [ + 8, + 9 + ] + }, + { + "Name": "StoreToEnvironment", + "VariantOpcodes": [ + 42, + 43 + ] + }, + { + "Name": "StoreNPToEnvironment", + "VariantOpcodes": [ + 44, + 45 + ] + }, + { + "Name": "LoadFromEnvironment", + "VariantOpcodes": [ + 46, + 47 + ] + }, + { + "Name": "GetById", + "VariantOpcodes": [ + 53, + 52, + 54 + ] + }, + { + "Name": "TryGetById", + "VariantOpcodes": [ + 55, + 56 + ] + }, + { + "Name": "PutById", + "VariantOpcodes": [ + 57, + 58 + ] + }, + { + "Name": "TryPutById", + "VariantOpcodes": [ + 59, + 60 + ] + }, + { + "Name": "PutNewOwnById", + "VariantOpcodes": [ + 62, + 61, + 63 + ] + }, + { + "Name": "PutNewOwnNEById", + "VariantOpcodes": [ + 64, + 65 + ] + }, + { + "Name": "PutOwnByIndex", + "VariantOpcodes": [ + 66, + 67 + ] + }, + { + "Name": "DelById", + "VariantOpcodes": [ + 69, + 70 + ] + }, + { + "Name": "Call", + "VariantOpcodes": [ + 77, + 84 + ] + }, + { + "Name": "Construct", + "VariantOpcodes": [ + 78, + 85 + ] + }, + { + "Name": "CallDirect", + "VariantOpcodes": [ + 80, + 86 + ] + }, + { + "Name": "CallBuiltin", + "VariantOpcodes": [ + 87, + 88 + ] + }, + { + "Name": "CreateClosure", + "VariantOpcodes": [ + 98, + 99 + ] + }, + { + "Name": "CreateGeneratorClosure", + "VariantOpcodes": [ + 100, + 101 + ] + }, + { + "Name": "CreateAsyncClosure", + "VariantOpcodes": [ + 102, + 103 + ] + }, + { + "Name": "LoadParam", + "VariantOpcodes": [ + 106, + 107 + ] + }, + { + "Name": "LoadConstBigInt", + "VariantOpcodes": [ + 111, + 112 + ] + }, + { + "Name": "LoadConstString", + "VariantOpcodes": [ + 113, + 114 + ] + }, + { + "Name": "CreateGenerator", + "VariantOpcodes": [ + 135, + 136 + ] + }, + { + "Name": "Jmp", + "VariantOpcodes": [ + 140, + 141 + ] + }, + { + "Name": "JmpTrue", + "VariantOpcodes": [ + 142, + 143 + ] + }, + { + "Name": "JmpFalse", + "VariantOpcodes": [ + 144, + 145 + ] + }, + { + "Name": "JmpUndefined", + "VariantOpcodes": [ + 146, + 147 + ] + }, + { + "Name": "SaveGenerator", + "VariantOpcodes": [ + 148, + 149 + ] + }, + { + "Name": "JLess", + "VariantOpcodes": [ + 150, + 151 + ] + }, + { + "Name": "JNotLess", + "VariantOpcodes": [ + 152, + 153 + ] + }, + { + "Name": "JLessN", + "VariantOpcodes": [ + 154, + 155 + ] + }, + { + "Name": "JNotLessN", + "VariantOpcodes": [ + 156, + 157 + ] + }, + { + "Name": "JLessEqual", + "VariantOpcodes": [ + 158, + 159 + ] + }, + { + "Name": "JNotLessEqual", + "VariantOpcodes": [ + 160, + 161 + ] + }, + { + "Name": "JLessEqualN", + "VariantOpcodes": [ + 162, + 163 + ] + }, + { + "Name": "JNotLessEqualN", + "VariantOpcodes": [ + 164, + 165 + ] + }, + { + "Name": "JGreater", + "VariantOpcodes": [ + 166, + 167 + ] + }, + { + "Name": "JNotGreater", + "VariantOpcodes": [ + 168, + 169 + ] + }, + { + "Name": "JGreaterN", + "VariantOpcodes": [ + 170, + 171 + ] + }, + { + "Name": "JNotGreaterN", + "VariantOpcodes": [ + 172, + 173 + ] + }, + { + "Name": "JGreaterEqual", + "VariantOpcodes": [ + 174, + 175 + ] + }, + { + "Name": "JNotGreaterEqual", + "VariantOpcodes": [ + 176, + 177 + ] + }, + { + "Name": "JGreaterEqualN", + "VariantOpcodes": [ + 178, + 179 + ] + }, + { + "Name": "JNotGreaterEqualN", + "VariantOpcodes": [ + 180, + 181 + ] + }, + { + "Name": "JEqual", + "VariantOpcodes": [ + 182, + 183 + ] + }, + { + "Name": "JNotEqual", + "VariantOpcodes": [ + 184, + 185 + ] + }, + { + "Name": "JStrictEqual", + "VariantOpcodes": [ + 186, + 187 + ] + }, + { + "Name": "JStrictNotEqual", + "VariantOpcodes": [ + 188, + 189 + ] + } + ], + "GitCommitHash": "2a55135bce3d41778ec3f56d8b43ad3b57b51b19" +} \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode89.json b/hasmer/libhasmer/Resources/Bytecode89.json new file mode 100644 index 0000000..5143624 --- /dev/null +++ b/hasmer/libhasmer/Resources/Bytecode89.json @@ -0,0 +1,2432 @@ +{ + "Version": 89, + "Definitions": [ + { + "Opcode": 0, + "Name": "Unreachable", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 1, + "Name": "NewObjectWithBuffer", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt16", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 0 + }, + { + "Opcode": 2, + "Name": "NewObjectWithBufferLong", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt32", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 0 + }, + { + "Opcode": 3, + "Name": "NewObject", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 4, + "Name": "NewObjectWithParent", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 5, + "Name": "NewArrayWithBuffer", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 1 + }, + { + "Opcode": 6, + "Name": "NewArrayWithBufferLong", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 1 + }, + { + "Opcode": 7, + "Name": "NewArray", + "OperandTypes": [ + "Reg8", + "UInt16" + ], + "IsJump": false + }, + { + "Opcode": 8, + "Name": "Mov", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 2 + }, + { + "Opcode": 9, + "Name": "MovLong", + "OperandTypes": [ + "Reg32", + "Reg32" + ], + "IsJump": false, + "AbstractDefinition": 2 + }, + { + "Opcode": 10, + "Name": "Negate", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 11, + "Name": "Not", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 12, + "Name": "BitNot", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 13, + "Name": "TypeOf", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 14, + "Name": "Eq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 15, + "Name": "StrictEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 16, + "Name": "Neq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 17, + "Name": "StrictNeq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 18, + "Name": "Less", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 19, + "Name": "LessEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 20, + "Name": "Greater", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 21, + "Name": "GreaterEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 22, + "Name": "Add", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 23, + "Name": "AddN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 24, + "Name": "Mul", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 25, + "Name": "MulN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 26, + "Name": "Div", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 27, + "Name": "DivN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 28, + "Name": "Mod", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 29, + "Name": "Sub", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 30, + "Name": "SubN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 31, + "Name": "LShift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 32, + "Name": "RShift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 33, + "Name": "URshift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 34, + "Name": "BitAnd", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 35, + "Name": "BitXor", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 36, + "Name": "BitOr", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 37, + "Name": "Inc", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 38, + "Name": "Dec", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 39, + "Name": "InstanceOf", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 40, + "Name": "IsIn", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 41, + "Name": "GetEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 42, + "Name": "StoreToEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 3 + }, + { + "Opcode": 43, + "Name": "StoreToEnvironmentL", + "OperandTypes": [ + "Reg8", + "UInt16", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 3 + }, + { + "Opcode": 44, + "Name": "StoreNPToEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 4 + }, + { + "Opcode": 45, + "Name": "StoreNPToEnvironmentL", + "OperandTypes": [ + "Reg8", + "UInt16", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 4 + }, + { + "Opcode": 46, + "Name": "LoadFromEnvironment", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 5 + }, + { + "Opcode": 47, + "Name": "LoadFromEnvironmentL", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 5 + }, + { + "Opcode": 48, + "Name": "GetGlobalObject", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 49, + "Name": "GetNewTarget", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 50, + "Name": "CreateEnvironment", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 51, + "Name": "DeclareGlobalVar", + "OperandTypes": [ + "UInt32S" + ], + "IsJump": false + }, + { + "Opcode": 52, + "Name": "GetByIdShort", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt8S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 53, + "Name": "GetById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 54, + "Name": "GetByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 55, + "Name": "TryGetById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 7 + }, + { + "Opcode": 56, + "Name": "TryGetByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 7 + }, + { + "Opcode": 57, + "Name": "PutById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 8 + }, + { + "Opcode": 58, + "Name": "PutByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 8 + }, + { + "Opcode": 59, + "Name": "TryPutById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 9 + }, + { + "Opcode": 60, + "Name": "TryPutByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 9 + }, + { + "Opcode": 61, + "Name": "PutNewOwnByIdShort", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 62, + "Name": "PutNewOwnById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 63, + "Name": "PutNewOwnByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 64, + "Name": "PutNewOwnNEById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 11 + }, + { + "Opcode": 65, + "Name": "PutNewOwnNEByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 11 + }, + { + "Opcode": 66, + "Name": "PutOwnByIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 12 + }, + { + "Opcode": 67, + "Name": "PutOwnByIndexL", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 12 + }, + { + "Opcode": 68, + "Name": "PutOwnByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 69, + "Name": "DelById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 13 + }, + { + "Opcode": 70, + "Name": "DelByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 13 + }, + { + "Opcode": 71, + "Name": "GetByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 72, + "Name": "PutByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 73, + "Name": "DelByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 74, + "Name": "PutOwnGetterSetterByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 75, + "Name": "GetPNameList", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 76, + "Name": "GetNextPName", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 77, + "Name": "Call", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 14 + }, + { + "Opcode": 78, + "Name": "Construct", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 15 + }, + { + "Opcode": 79, + "Name": "Call1", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 80, + "Name": "CallDirect", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 16 + }, + { + "Opcode": 81, + "Name": "Call2", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 82, + "Name": "Call3", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 83, + "Name": "Call4", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 84, + "Name": "CallLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 14 + }, + { + "Opcode": 85, + "Name": "ConstructLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 15 + }, + { + "Opcode": 86, + "Name": "CallDirectLongIndex", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 16 + }, + { + "Opcode": 87, + "Name": "CallBuiltin", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 17 + }, + { + "Opcode": 88, + "Name": "CallBuiltinLong", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 17 + }, + { + "Opcode": 89, + "Name": "GetBuiltinClosure", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 90, + "Name": "Ret", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 91, + "Name": "Catch", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 92, + "Name": "DirectEval", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 93, + "Name": "Throw", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 94, + "Name": "ThrowIfEmpty", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 95, + "Name": "Debugger", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 96, + "Name": "AsyncBreakCheck", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 97, + "Name": "ProfilePoint", + "OperandTypes": [ + "UInt16" + ], + "IsJump": false + }, + { + "Opcode": 98, + "Name": "CreateClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 18 + }, + { + "Opcode": 99, + "Name": "CreateClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 18 + }, + { + "Opcode": 100, + "Name": "CreateGeneratorClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 19 + }, + { + "Opcode": 101, + "Name": "CreateGeneratorClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 19 + }, + { + "Opcode": 102, + "Name": "CreateAsyncClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 20 + }, + { + "Opcode": 103, + "Name": "CreateAsyncClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 20 + }, + { + "Opcode": 104, + "Name": "CreateThis", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 105, + "Name": "SelectObject", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 106, + "Name": "LoadParam", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 21 + }, + { + "Opcode": 107, + "Name": "LoadParamLong", + "OperandTypes": [ + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 21 + }, + { + "Opcode": 108, + "Name": "LoadConstUInt8", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 109, + "Name": "LoadConstInt", + "OperandTypes": [ + "Reg8", + "Imm32" + ], + "IsJump": false + }, + { + "Opcode": 110, + "Name": "LoadConstDouble", + "OperandTypes": [ + "Reg8", + "Double" + ], + "IsJump": false + }, + { + "Opcode": 111, + "Name": "LoadConstBigInt", + "OperandTypes": [ + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 22 + }, + { + "Opcode": 112, + "Name": "LoadConstBigIntLongIndex", + "OperandTypes": [ + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 22 + }, + { + "Opcode": 113, + "Name": "LoadConstString", + "OperandTypes": [ + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 23 + }, + { + "Opcode": 114, + "Name": "LoadConstStringLongIndex", + "OperandTypes": [ + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 23 + }, + { + "Opcode": 115, + "Name": "LoadConstEmpty", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 116, + "Name": "LoadConstUndefined", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 117, + "Name": "LoadConstNull", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 118, + "Name": "LoadConstTrue", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 119, + "Name": "LoadConstFalse", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 120, + "Name": "LoadConstZero", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 121, + "Name": "CoerceThisNS", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 122, + "Name": "LoadThisNS", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 123, + "Name": "ToNumber", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 124, + "Name": "ToNumeric", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 125, + "Name": "ToInt32", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 126, + "Name": "AddEmptyString", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 127, + "Name": "GetArgumentsPropByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 128, + "Name": "GetArgumentsLength", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 129, + "Name": "ReifyArguments", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 130, + "Name": "CreateRegExp", + "OperandTypes": [ + "Reg8", + "UInt32S", + "UInt32S", + "UInt32" + ], + "IsJump": false + }, + { + "Opcode": 131, + "Name": "SwitchImm", + "OperandTypes": [ + "Reg8", + "UInt32", + "Addr32", + "UInt32", + "UInt32" + ], + "IsJump": false + }, + { + "Opcode": 132, + "Name": "StartGenerator", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 133, + "Name": "ResumeGenerator", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 134, + "Name": "CompleteGenerator", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 135, + "Name": "CreateGenerator", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 24 + }, + { + "Opcode": 136, + "Name": "CreateGeneratorLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 24 + }, + { + "Opcode": 137, + "Name": "IteratorBegin", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 138, + "Name": "IteratorNext", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 139, + "Name": "IteratorClose", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 140, + "Name": "Jmp", + "OperandTypes": [ + "Addr8" + ], + "IsJump": true, + "AbstractDefinition": 25 + }, + { + "Opcode": 141, + "Name": "JmpLong", + "OperandTypes": [ + "Addr32" + ], + "IsJump": true, + "AbstractDefinition": 25 + }, + { + "Opcode": 142, + "Name": "JmpTrue", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 26 + }, + { + "Opcode": 143, + "Name": "JmpTrueLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 26 + }, + { + "Opcode": 144, + "Name": "JmpFalse", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 27 + }, + { + "Opcode": 145, + "Name": "JmpFalseLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 27 + }, + { + "Opcode": 146, + "Name": "JmpUndefined", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 28 + }, + { + "Opcode": 147, + "Name": "JmpUndefinedLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 28 + }, + { + "Opcode": 148, + "Name": "SaveGenerator", + "OperandTypes": [ + "Addr8" + ], + "IsJump": true, + "AbstractDefinition": 29 + }, + { + "Opcode": 149, + "Name": "SaveGeneratorLong", + "OperandTypes": [ + "Addr32" + ], + "IsJump": true, + "AbstractDefinition": 29 + }, + { + "Opcode": 150, + "Name": "JLess", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 30 + }, + { + "Opcode": 151, + "Name": "JLessLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 30 + }, + { + "Opcode": 152, + "Name": "JNotLess", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 31 + }, + { + "Opcode": 153, + "Name": "JNotLessLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 31 + }, + { + "Opcode": 154, + "Name": "JLessN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 32 + }, + { + "Opcode": 155, + "Name": "JLessNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 32 + }, + { + "Opcode": 156, + "Name": "JNotLessN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 33 + }, + { + "Opcode": 157, + "Name": "JNotLessNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 33 + }, + { + "Opcode": 158, + "Name": "JLessEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 34 + }, + { + "Opcode": 159, + "Name": "JLessEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 34 + }, + { + "Opcode": 160, + "Name": "JNotLessEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 35 + }, + { + "Opcode": 161, + "Name": "JNotLessEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 35 + }, + { + "Opcode": 162, + "Name": "JLessEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 36 + }, + { + "Opcode": 163, + "Name": "JLessEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 36 + }, + { + "Opcode": 164, + "Name": "JNotLessEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 37 + }, + { + "Opcode": 165, + "Name": "JNotLessEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 37 + }, + { + "Opcode": 166, + "Name": "JGreater", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 38 + }, + { + "Opcode": 167, + "Name": "JGreaterLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 38 + }, + { + "Opcode": 168, + "Name": "JNotGreater", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 39 + }, + { + "Opcode": 169, + "Name": "JNotGreaterLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 39 + }, + { + "Opcode": 170, + "Name": "JGreaterN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 40 + }, + { + "Opcode": 171, + "Name": "JGreaterNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 40 + }, + { + "Opcode": 172, + "Name": "JNotGreaterN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 41 + }, + { + "Opcode": 173, + "Name": "JNotGreaterNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 41 + }, + { + "Opcode": 174, + "Name": "JGreaterEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 42 + }, + { + "Opcode": 175, + "Name": "JGreaterEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 42 + }, + { + "Opcode": 176, + "Name": "JNotGreaterEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 43 + }, + { + "Opcode": 177, + "Name": "JNotGreaterEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 43 + }, + { + "Opcode": 178, + "Name": "JGreaterEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 44 + }, + { + "Opcode": 179, + "Name": "JGreaterEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 44 + }, + { + "Opcode": 180, + "Name": "JNotGreaterEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 45 + }, + { + "Opcode": 181, + "Name": "JNotGreaterEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 45 + }, + { + "Opcode": 182, + "Name": "JEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 46 + }, + { + "Opcode": 183, + "Name": "JEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 46 + }, + { + "Opcode": 184, + "Name": "JNotEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 47 + }, + { + "Opcode": 185, + "Name": "JNotEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 47 + }, + { + "Opcode": 186, + "Name": "JStrictEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 48 + }, + { + "Opcode": 187, + "Name": "JStrictEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 48 + }, + { + "Opcode": 188, + "Name": "JStrictNotEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 49 + }, + { + "Opcode": 189, + "Name": "JStrictNotEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 49 + }, + { + "Opcode": 190, + "Name": "Add32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 191, + "Name": "Sub32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 192, + "Name": "Mul32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 193, + "Name": "Divi32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 194, + "Name": "Divu32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 195, + "Name": "Loadi8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 196, + "Name": "Loadu8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 197, + "Name": "Loadi16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 198, + "Name": "Loadu16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 199, + "Name": "Loadi32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 200, + "Name": "Loadu32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 201, + "Name": "Store8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 202, + "Name": "Store16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 203, + "Name": "Store32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + } + ], + "AbstractDefinitions": [ + { + "Name": "NewObjectWithBuffer", + "VariantOpcodes": [ + 1, + 2 + ] + }, + { + "Name": "NewArrayWithBuffer", + "VariantOpcodes": [ + 5, + 6 + ] + }, + { + "Name": "Mov", + "VariantOpcodes": [ + 8, + 9 + ] + }, + { + "Name": "StoreToEnvironment", + "VariantOpcodes": [ + 42, + 43 + ] + }, + { + "Name": "StoreNPToEnvironment", + "VariantOpcodes": [ + 44, + 45 + ] + }, + { + "Name": "LoadFromEnvironment", + "VariantOpcodes": [ + 46, + 47 + ] + }, + { + "Name": "GetById", + "VariantOpcodes": [ + 53, + 52, + 54 + ] + }, + { + "Name": "TryGetById", + "VariantOpcodes": [ + 55, + 56 + ] + }, + { + "Name": "PutById", + "VariantOpcodes": [ + 57, + 58 + ] + }, + { + "Name": "TryPutById", + "VariantOpcodes": [ + 59, + 60 + ] + }, + { + "Name": "PutNewOwnById", + "VariantOpcodes": [ + 62, + 61, + 63 + ] + }, + { + "Name": "PutNewOwnNEById", + "VariantOpcodes": [ + 64, + 65 + ] + }, + { + "Name": "PutOwnByIndex", + "VariantOpcodes": [ + 66, + 67 + ] + }, + { + "Name": "DelById", + "VariantOpcodes": [ + 69, + 70 + ] + }, + { + "Name": "Call", + "VariantOpcodes": [ + 77, + 84 + ] + }, + { + "Name": "Construct", + "VariantOpcodes": [ + 78, + 85 + ] + }, + { + "Name": "CallDirect", + "VariantOpcodes": [ + 80, + 86 + ] + }, + { + "Name": "CallBuiltin", + "VariantOpcodes": [ + 87, + 88 + ] + }, + { + "Name": "CreateClosure", + "VariantOpcodes": [ + 98, + 99 + ] + }, + { + "Name": "CreateGeneratorClosure", + "VariantOpcodes": [ + 100, + 101 + ] + }, + { + "Name": "CreateAsyncClosure", + "VariantOpcodes": [ + 102, + 103 + ] + }, + { + "Name": "LoadParam", + "VariantOpcodes": [ + 106, + 107 + ] + }, + { + "Name": "LoadConstBigInt", + "VariantOpcodes": [ + 111, + 112 + ] + }, + { + "Name": "LoadConstString", + "VariantOpcodes": [ + 113, + 114 + ] + }, + { + "Name": "CreateGenerator", + "VariantOpcodes": [ + 135, + 136 + ] + }, + { + "Name": "Jmp", + "VariantOpcodes": [ + 140, + 141 + ] + }, + { + "Name": "JmpTrue", + "VariantOpcodes": [ + 142, + 143 + ] + }, + { + "Name": "JmpFalse", + "VariantOpcodes": [ + 144, + 145 + ] + }, + { + "Name": "JmpUndefined", + "VariantOpcodes": [ + 146, + 147 + ] + }, + { + "Name": "SaveGenerator", + "VariantOpcodes": [ + 148, + 149 + ] + }, + { + "Name": "JLess", + "VariantOpcodes": [ + 150, + 151 + ] + }, + { + "Name": "JNotLess", + "VariantOpcodes": [ + 152, + 153 + ] + }, + { + "Name": "JLessN", + "VariantOpcodes": [ + 154, + 155 + ] + }, + { + "Name": "JNotLessN", + "VariantOpcodes": [ + 156, + 157 + ] + }, + { + "Name": "JLessEqual", + "VariantOpcodes": [ + 158, + 159 + ] + }, + { + "Name": "JNotLessEqual", + "VariantOpcodes": [ + 160, + 161 + ] + }, + { + "Name": "JLessEqualN", + "VariantOpcodes": [ + 162, + 163 + ] + }, + { + "Name": "JNotLessEqualN", + "VariantOpcodes": [ + 164, + 165 + ] + }, + { + "Name": "JGreater", + "VariantOpcodes": [ + 166, + 167 + ] + }, + { + "Name": "JNotGreater", + "VariantOpcodes": [ + 168, + 169 + ] + }, + { + "Name": "JGreaterN", + "VariantOpcodes": [ + 170, + 171 + ] + }, + { + "Name": "JNotGreaterN", + "VariantOpcodes": [ + 172, + 173 + ] + }, + { + "Name": "JGreaterEqual", + "VariantOpcodes": [ + 174, + 175 + ] + }, + { + "Name": "JNotGreaterEqual", + "VariantOpcodes": [ + 176, + 177 + ] + }, + { + "Name": "JGreaterEqualN", + "VariantOpcodes": [ + 178, + 179 + ] + }, + { + "Name": "JNotGreaterEqualN", + "VariantOpcodes": [ + 180, + 181 + ] + }, + { + "Name": "JEqual", + "VariantOpcodes": [ + 182, + 183 + ] + }, + { + "Name": "JNotEqual", + "VariantOpcodes": [ + 184, + 185 + ] + }, + { + "Name": "JStrictEqual", + "VariantOpcodes": [ + 186, + 187 + ] + }, + { + "Name": "JStrictNotEqual", + "VariantOpcodes": [ + 188, + 189 + ] + } + ], + "GitCommitHash": "498f7cb64a8c59a3e95f074035ad2d23d1fde5cc" +} \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode90.json b/hasmer/libhasmer/Resources/Bytecode90.json new file mode 100644 index 0000000..df06c04 --- /dev/null +++ b/hasmer/libhasmer/Resources/Bytecode90.json @@ -0,0 +1,2432 @@ +{ + "Version": 90, + "Definitions": [ + { + "Opcode": 0, + "Name": "Unreachable", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 1, + "Name": "NewObjectWithBuffer", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt16", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 0 + }, + { + "Opcode": 2, + "Name": "NewObjectWithBufferLong", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt32", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 0 + }, + { + "Opcode": 3, + "Name": "NewObject", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 4, + "Name": "NewObjectWithParent", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 5, + "Name": "NewArrayWithBuffer", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 1 + }, + { + "Opcode": 6, + "Name": "NewArrayWithBufferLong", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 1 + }, + { + "Opcode": 7, + "Name": "NewArray", + "OperandTypes": [ + "Reg8", + "UInt16" + ], + "IsJump": false + }, + { + "Opcode": 8, + "Name": "Mov", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 2 + }, + { + "Opcode": 9, + "Name": "MovLong", + "OperandTypes": [ + "Reg32", + "Reg32" + ], + "IsJump": false, + "AbstractDefinition": 2 + }, + { + "Opcode": 10, + "Name": "Negate", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 11, + "Name": "Not", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 12, + "Name": "BitNot", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 13, + "Name": "TypeOf", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 14, + "Name": "Eq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 15, + "Name": "StrictEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 16, + "Name": "Neq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 17, + "Name": "StrictNeq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 18, + "Name": "Less", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 19, + "Name": "LessEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 20, + "Name": "Greater", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 21, + "Name": "GreaterEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 22, + "Name": "Add", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 23, + "Name": "AddN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 24, + "Name": "Mul", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 25, + "Name": "MulN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 26, + "Name": "Div", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 27, + "Name": "DivN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 28, + "Name": "Mod", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 29, + "Name": "Sub", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 30, + "Name": "SubN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 31, + "Name": "LShift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 32, + "Name": "RShift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 33, + "Name": "URshift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 34, + "Name": "BitAnd", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 35, + "Name": "BitXor", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 36, + "Name": "BitOr", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 37, + "Name": "Inc", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 38, + "Name": "Dec", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 39, + "Name": "InstanceOf", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 40, + "Name": "IsIn", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 41, + "Name": "GetEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 42, + "Name": "StoreToEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 3 + }, + { + "Opcode": 43, + "Name": "StoreToEnvironmentL", + "OperandTypes": [ + "Reg8", + "UInt16", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 3 + }, + { + "Opcode": 44, + "Name": "StoreNPToEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 4 + }, + { + "Opcode": 45, + "Name": "StoreNPToEnvironmentL", + "OperandTypes": [ + "Reg8", + "UInt16", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 4 + }, + { + "Opcode": 46, + "Name": "LoadFromEnvironment", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 5 + }, + { + "Opcode": 47, + "Name": "LoadFromEnvironmentL", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 5 + }, + { + "Opcode": 48, + "Name": "GetGlobalObject", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 49, + "Name": "GetNewTarget", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 50, + "Name": "CreateEnvironment", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 51, + "Name": "DeclareGlobalVar", + "OperandTypes": [ + "UInt32S" + ], + "IsJump": false + }, + { + "Opcode": 52, + "Name": "GetByIdShort", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt8S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 53, + "Name": "GetById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 54, + "Name": "GetByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 55, + "Name": "TryGetById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 7 + }, + { + "Opcode": 56, + "Name": "TryGetByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 7 + }, + { + "Opcode": 57, + "Name": "PutById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 8 + }, + { + "Opcode": 58, + "Name": "PutByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 8 + }, + { + "Opcode": 59, + "Name": "TryPutById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 9 + }, + { + "Opcode": 60, + "Name": "TryPutByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 9 + }, + { + "Opcode": 61, + "Name": "PutNewOwnByIdShort", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 62, + "Name": "PutNewOwnById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 63, + "Name": "PutNewOwnByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 64, + "Name": "PutNewOwnNEById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 11 + }, + { + "Opcode": 65, + "Name": "PutNewOwnNEByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 11 + }, + { + "Opcode": 66, + "Name": "PutOwnByIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 12 + }, + { + "Opcode": 67, + "Name": "PutOwnByIndexL", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 12 + }, + { + "Opcode": 68, + "Name": "PutOwnByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 69, + "Name": "DelById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 13 + }, + { + "Opcode": 70, + "Name": "DelByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 13 + }, + { + "Opcode": 71, + "Name": "GetByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 72, + "Name": "PutByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 73, + "Name": "DelByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 74, + "Name": "PutOwnGetterSetterByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 75, + "Name": "GetPNameList", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 76, + "Name": "GetNextPName", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 77, + "Name": "Call", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 14 + }, + { + "Opcode": 78, + "Name": "Construct", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 15 + }, + { + "Opcode": 79, + "Name": "Call1", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 80, + "Name": "CallDirect", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 16 + }, + { + "Opcode": 81, + "Name": "Call2", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 82, + "Name": "Call3", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 83, + "Name": "Call4", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 84, + "Name": "CallLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 14 + }, + { + "Opcode": 85, + "Name": "ConstructLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 15 + }, + { + "Opcode": 86, + "Name": "CallDirectLongIndex", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 16 + }, + { + "Opcode": 87, + "Name": "CallBuiltin", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 17 + }, + { + "Opcode": 88, + "Name": "CallBuiltinLong", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 17 + }, + { + "Opcode": 89, + "Name": "GetBuiltinClosure", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 90, + "Name": "Ret", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 91, + "Name": "Catch", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 92, + "Name": "DirectEval", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 93, + "Name": "Throw", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 94, + "Name": "ThrowIfEmpty", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 95, + "Name": "Debugger", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 96, + "Name": "AsyncBreakCheck", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 97, + "Name": "ProfilePoint", + "OperandTypes": [ + "UInt16" + ], + "IsJump": false + }, + { + "Opcode": 98, + "Name": "CreateClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 18 + }, + { + "Opcode": 99, + "Name": "CreateClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 18 + }, + { + "Opcode": 100, + "Name": "CreateGeneratorClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 19 + }, + { + "Opcode": 101, + "Name": "CreateGeneratorClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 19 + }, + { + "Opcode": 102, + "Name": "CreateAsyncClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 20 + }, + { + "Opcode": 103, + "Name": "CreateAsyncClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 20 + }, + { + "Opcode": 104, + "Name": "CreateThis", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 105, + "Name": "SelectObject", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 106, + "Name": "LoadParam", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 21 + }, + { + "Opcode": 107, + "Name": "LoadParamLong", + "OperandTypes": [ + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 21 + }, + { + "Opcode": 108, + "Name": "LoadConstUInt8", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 109, + "Name": "LoadConstInt", + "OperandTypes": [ + "Reg8", + "Imm32" + ], + "IsJump": false + }, + { + "Opcode": 110, + "Name": "LoadConstDouble", + "OperandTypes": [ + "Reg8", + "Double" + ], + "IsJump": false + }, + { + "Opcode": 111, + "Name": "LoadConstBigInt", + "OperandTypes": [ + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 22 + }, + { + "Opcode": 112, + "Name": "LoadConstBigIntLongIndex", + "OperandTypes": [ + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 22 + }, + { + "Opcode": 113, + "Name": "LoadConstString", + "OperandTypes": [ + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 23 + }, + { + "Opcode": 114, + "Name": "LoadConstStringLongIndex", + "OperandTypes": [ + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 23 + }, + { + "Opcode": 115, + "Name": "LoadConstEmpty", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 116, + "Name": "LoadConstUndefined", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 117, + "Name": "LoadConstNull", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 118, + "Name": "LoadConstTrue", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 119, + "Name": "LoadConstFalse", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 120, + "Name": "LoadConstZero", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 121, + "Name": "CoerceThisNS", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 122, + "Name": "LoadThisNS", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 123, + "Name": "ToNumber", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 124, + "Name": "ToNumeric", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 125, + "Name": "ToInt32", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 126, + "Name": "AddEmptyString", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 127, + "Name": "GetArgumentsPropByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 128, + "Name": "GetArgumentsLength", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 129, + "Name": "ReifyArguments", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 130, + "Name": "CreateRegExp", + "OperandTypes": [ + "Reg8", + "UInt32S", + "UInt32S", + "UInt32" + ], + "IsJump": false + }, + { + "Opcode": 131, + "Name": "SwitchImm", + "OperandTypes": [ + "Reg8", + "UInt32", + "Addr32", + "UInt32", + "UInt32" + ], + "IsJump": false + }, + { + "Opcode": 132, + "Name": "StartGenerator", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 133, + "Name": "ResumeGenerator", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 134, + "Name": "CompleteGenerator", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 135, + "Name": "CreateGenerator", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 24 + }, + { + "Opcode": 136, + "Name": "CreateGeneratorLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 24 + }, + { + "Opcode": 137, + "Name": "IteratorBegin", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 138, + "Name": "IteratorNext", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 139, + "Name": "IteratorClose", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 140, + "Name": "Jmp", + "OperandTypes": [ + "Addr8" + ], + "IsJump": true, + "AbstractDefinition": 25 + }, + { + "Opcode": 141, + "Name": "JmpLong", + "OperandTypes": [ + "Addr32" + ], + "IsJump": true, + "AbstractDefinition": 25 + }, + { + "Opcode": 142, + "Name": "JmpTrue", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 26 + }, + { + "Opcode": 143, + "Name": "JmpTrueLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 26 + }, + { + "Opcode": 144, + "Name": "JmpFalse", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 27 + }, + { + "Opcode": 145, + "Name": "JmpFalseLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 27 + }, + { + "Opcode": 146, + "Name": "JmpUndefined", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 28 + }, + { + "Opcode": 147, + "Name": "JmpUndefinedLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 28 + }, + { + "Opcode": 148, + "Name": "SaveGenerator", + "OperandTypes": [ + "Addr8" + ], + "IsJump": true, + "AbstractDefinition": 29 + }, + { + "Opcode": 149, + "Name": "SaveGeneratorLong", + "OperandTypes": [ + "Addr32" + ], + "IsJump": true, + "AbstractDefinition": 29 + }, + { + "Opcode": 150, + "Name": "JLess", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 30 + }, + { + "Opcode": 151, + "Name": "JLessLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 30 + }, + { + "Opcode": 152, + "Name": "JNotLess", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 31 + }, + { + "Opcode": 153, + "Name": "JNotLessLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 31 + }, + { + "Opcode": 154, + "Name": "JLessN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 32 + }, + { + "Opcode": 155, + "Name": "JLessNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 32 + }, + { + "Opcode": 156, + "Name": "JNotLessN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 33 + }, + { + "Opcode": 157, + "Name": "JNotLessNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 33 + }, + { + "Opcode": 158, + "Name": "JLessEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 34 + }, + { + "Opcode": 159, + "Name": "JLessEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 34 + }, + { + "Opcode": 160, + "Name": "JNotLessEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 35 + }, + { + "Opcode": 161, + "Name": "JNotLessEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 35 + }, + { + "Opcode": 162, + "Name": "JLessEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 36 + }, + { + "Opcode": 163, + "Name": "JLessEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 36 + }, + { + "Opcode": 164, + "Name": "JNotLessEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 37 + }, + { + "Opcode": 165, + "Name": "JNotLessEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 37 + }, + { + "Opcode": 166, + "Name": "JGreater", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 38 + }, + { + "Opcode": 167, + "Name": "JGreaterLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 38 + }, + { + "Opcode": 168, + "Name": "JNotGreater", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 39 + }, + { + "Opcode": 169, + "Name": "JNotGreaterLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 39 + }, + { + "Opcode": 170, + "Name": "JGreaterN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 40 + }, + { + "Opcode": 171, + "Name": "JGreaterNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 40 + }, + { + "Opcode": 172, + "Name": "JNotGreaterN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 41 + }, + { + "Opcode": 173, + "Name": "JNotGreaterNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 41 + }, + { + "Opcode": 174, + "Name": "JGreaterEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 42 + }, + { + "Opcode": 175, + "Name": "JGreaterEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 42 + }, + { + "Opcode": 176, + "Name": "JNotGreaterEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 43 + }, + { + "Opcode": 177, + "Name": "JNotGreaterEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 43 + }, + { + "Opcode": 178, + "Name": "JGreaterEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 44 + }, + { + "Opcode": 179, + "Name": "JGreaterEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 44 + }, + { + "Opcode": 180, + "Name": "JNotGreaterEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 45 + }, + { + "Opcode": 181, + "Name": "JNotGreaterEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 45 + }, + { + "Opcode": 182, + "Name": "JEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 46 + }, + { + "Opcode": 183, + "Name": "JEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 46 + }, + { + "Opcode": 184, + "Name": "JNotEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 47 + }, + { + "Opcode": 185, + "Name": "JNotEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 47 + }, + { + "Opcode": 186, + "Name": "JStrictEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 48 + }, + { + "Opcode": 187, + "Name": "JStrictEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 48 + }, + { + "Opcode": 188, + "Name": "JStrictNotEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 49 + }, + { + "Opcode": 189, + "Name": "JStrictNotEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 49 + }, + { + "Opcode": 190, + "Name": "Add32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 191, + "Name": "Sub32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 192, + "Name": "Mul32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 193, + "Name": "Divi32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 194, + "Name": "Divu32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 195, + "Name": "Loadi8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 196, + "Name": "Loadu8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 197, + "Name": "Loadi16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 198, + "Name": "Loadu16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 199, + "Name": "Loadi32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 200, + "Name": "Loadu32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 201, + "Name": "Store8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 202, + "Name": "Store16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 203, + "Name": "Store32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + } + ], + "AbstractDefinitions": [ + { + "Name": "NewObjectWithBuffer", + "VariantOpcodes": [ + 1, + 2 + ] + }, + { + "Name": "NewArrayWithBuffer", + "VariantOpcodes": [ + 5, + 6 + ] + }, + { + "Name": "Mov", + "VariantOpcodes": [ + 8, + 9 + ] + }, + { + "Name": "StoreToEnvironment", + "VariantOpcodes": [ + 42, + 43 + ] + }, + { + "Name": "StoreNPToEnvironment", + "VariantOpcodes": [ + 44, + 45 + ] + }, + { + "Name": "LoadFromEnvironment", + "VariantOpcodes": [ + 46, + 47 + ] + }, + { + "Name": "GetById", + "VariantOpcodes": [ + 53, + 52, + 54 + ] + }, + { + "Name": "TryGetById", + "VariantOpcodes": [ + 55, + 56 + ] + }, + { + "Name": "PutById", + "VariantOpcodes": [ + 57, + 58 + ] + }, + { + "Name": "TryPutById", + "VariantOpcodes": [ + 59, + 60 + ] + }, + { + "Name": "PutNewOwnById", + "VariantOpcodes": [ + 62, + 61, + 63 + ] + }, + { + "Name": "PutNewOwnNEById", + "VariantOpcodes": [ + 64, + 65 + ] + }, + { + "Name": "PutOwnByIndex", + "VariantOpcodes": [ + 66, + 67 + ] + }, + { + "Name": "DelById", + "VariantOpcodes": [ + 69, + 70 + ] + }, + { + "Name": "Call", + "VariantOpcodes": [ + 77, + 84 + ] + }, + { + "Name": "Construct", + "VariantOpcodes": [ + 78, + 85 + ] + }, + { + "Name": "CallDirect", + "VariantOpcodes": [ + 80, + 86 + ] + }, + { + "Name": "CallBuiltin", + "VariantOpcodes": [ + 87, + 88 + ] + }, + { + "Name": "CreateClosure", + "VariantOpcodes": [ + 98, + 99 + ] + }, + { + "Name": "CreateGeneratorClosure", + "VariantOpcodes": [ + 100, + 101 + ] + }, + { + "Name": "CreateAsyncClosure", + "VariantOpcodes": [ + 102, + 103 + ] + }, + { + "Name": "LoadParam", + "VariantOpcodes": [ + 106, + 107 + ] + }, + { + "Name": "LoadConstBigInt", + "VariantOpcodes": [ + 111, + 112 + ] + }, + { + "Name": "LoadConstString", + "VariantOpcodes": [ + 113, + 114 + ] + }, + { + "Name": "CreateGenerator", + "VariantOpcodes": [ + 135, + 136 + ] + }, + { + "Name": "Jmp", + "VariantOpcodes": [ + 140, + 141 + ] + }, + { + "Name": "JmpTrue", + "VariantOpcodes": [ + 142, + 143 + ] + }, + { + "Name": "JmpFalse", + "VariantOpcodes": [ + 144, + 145 + ] + }, + { + "Name": "JmpUndefined", + "VariantOpcodes": [ + 146, + 147 + ] + }, + { + "Name": "SaveGenerator", + "VariantOpcodes": [ + 148, + 149 + ] + }, + { + "Name": "JLess", + "VariantOpcodes": [ + 150, + 151 + ] + }, + { + "Name": "JNotLess", + "VariantOpcodes": [ + 152, + 153 + ] + }, + { + "Name": "JLessN", + "VariantOpcodes": [ + 154, + 155 + ] + }, + { + "Name": "JNotLessN", + "VariantOpcodes": [ + 156, + 157 + ] + }, + { + "Name": "JLessEqual", + "VariantOpcodes": [ + 158, + 159 + ] + }, + { + "Name": "JNotLessEqual", + "VariantOpcodes": [ + 160, + 161 + ] + }, + { + "Name": "JLessEqualN", + "VariantOpcodes": [ + 162, + 163 + ] + }, + { + "Name": "JNotLessEqualN", + "VariantOpcodes": [ + 164, + 165 + ] + }, + { + "Name": "JGreater", + "VariantOpcodes": [ + 166, + 167 + ] + }, + { + "Name": "JNotGreater", + "VariantOpcodes": [ + 168, + 169 + ] + }, + { + "Name": "JGreaterN", + "VariantOpcodes": [ + 170, + 171 + ] + }, + { + "Name": "JNotGreaterN", + "VariantOpcodes": [ + 172, + 173 + ] + }, + { + "Name": "JGreaterEqual", + "VariantOpcodes": [ + 174, + 175 + ] + }, + { + "Name": "JNotGreaterEqual", + "VariantOpcodes": [ + 176, + 177 + ] + }, + { + "Name": "JGreaterEqualN", + "VariantOpcodes": [ + 178, + 179 + ] + }, + { + "Name": "JNotGreaterEqualN", + "VariantOpcodes": [ + 180, + 181 + ] + }, + { + "Name": "JEqual", + "VariantOpcodes": [ + 182, + 183 + ] + }, + { + "Name": "JNotEqual", + "VariantOpcodes": [ + 184, + 185 + ] + }, + { + "Name": "JStrictEqual", + "VariantOpcodes": [ + 186, + 187 + ] + }, + { + "Name": "JStrictNotEqual", + "VariantOpcodes": [ + 188, + 189 + ] + } + ], + "GitCommitHash": "0763eee4bf461df30ffefe0180d09835bb6bb58d" +} \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode91.json b/hasmer/libhasmer/Resources/Bytecode91.json new file mode 100644 index 0000000..53369bf --- /dev/null +++ b/hasmer/libhasmer/Resources/Bytecode91.json @@ -0,0 +1,2432 @@ +{ + "Version": 91, + "Definitions": [ + { + "Opcode": 0, + "Name": "Unreachable", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 1, + "Name": "NewObjectWithBuffer", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt16", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 0 + }, + { + "Opcode": 2, + "Name": "NewObjectWithBufferLong", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt32", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 0 + }, + { + "Opcode": 3, + "Name": "NewObject", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 4, + "Name": "NewObjectWithParent", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 5, + "Name": "NewArrayWithBuffer", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 1 + }, + { + "Opcode": 6, + "Name": "NewArrayWithBufferLong", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 1 + }, + { + "Opcode": 7, + "Name": "NewArray", + "OperandTypes": [ + "Reg8", + "UInt16" + ], + "IsJump": false + }, + { + "Opcode": 8, + "Name": "Mov", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 2 + }, + { + "Opcode": 9, + "Name": "MovLong", + "OperandTypes": [ + "Reg32", + "Reg32" + ], + "IsJump": false, + "AbstractDefinition": 2 + }, + { + "Opcode": 10, + "Name": "Negate", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 11, + "Name": "Not", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 12, + "Name": "BitNot", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 13, + "Name": "TypeOf", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 14, + "Name": "Eq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 15, + "Name": "StrictEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 16, + "Name": "Neq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 17, + "Name": "StrictNeq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 18, + "Name": "Less", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 19, + "Name": "LessEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 20, + "Name": "Greater", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 21, + "Name": "GreaterEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 22, + "Name": "Add", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 23, + "Name": "AddN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 24, + "Name": "Mul", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 25, + "Name": "MulN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 26, + "Name": "Div", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 27, + "Name": "DivN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 28, + "Name": "Mod", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 29, + "Name": "Sub", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 30, + "Name": "SubN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 31, + "Name": "LShift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 32, + "Name": "RShift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 33, + "Name": "URshift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 34, + "Name": "BitAnd", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 35, + "Name": "BitXor", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 36, + "Name": "BitOr", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 37, + "Name": "Inc", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 38, + "Name": "Dec", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 39, + "Name": "InstanceOf", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 40, + "Name": "IsIn", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 41, + "Name": "GetEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 42, + "Name": "StoreToEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 3 + }, + { + "Opcode": 43, + "Name": "StoreToEnvironmentL", + "OperandTypes": [ + "Reg8", + "UInt16", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 3 + }, + { + "Opcode": 44, + "Name": "StoreNPToEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 4 + }, + { + "Opcode": 45, + "Name": "StoreNPToEnvironmentL", + "OperandTypes": [ + "Reg8", + "UInt16", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 4 + }, + { + "Opcode": 46, + "Name": "LoadFromEnvironment", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 5 + }, + { + "Opcode": 47, + "Name": "LoadFromEnvironmentL", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 5 + }, + { + "Opcode": 48, + "Name": "GetGlobalObject", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 49, + "Name": "GetNewTarget", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 50, + "Name": "CreateEnvironment", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 51, + "Name": "DeclareGlobalVar", + "OperandTypes": [ + "UInt32S" + ], + "IsJump": false + }, + { + "Opcode": 52, + "Name": "GetByIdShort", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt8S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 53, + "Name": "GetById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 54, + "Name": "GetByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 55, + "Name": "TryGetById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 7 + }, + { + "Opcode": 56, + "Name": "TryGetByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 7 + }, + { + "Opcode": 57, + "Name": "PutById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 8 + }, + { + "Opcode": 58, + "Name": "PutByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 8 + }, + { + "Opcode": 59, + "Name": "TryPutById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 9 + }, + { + "Opcode": 60, + "Name": "TryPutByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 9 + }, + { + "Opcode": 61, + "Name": "PutNewOwnByIdShort", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 62, + "Name": "PutNewOwnById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 63, + "Name": "PutNewOwnByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 64, + "Name": "PutNewOwnNEById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 11 + }, + { + "Opcode": 65, + "Name": "PutNewOwnNEByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 11 + }, + { + "Opcode": 66, + "Name": "PutOwnByIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 12 + }, + { + "Opcode": 67, + "Name": "PutOwnByIndexL", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 12 + }, + { + "Opcode": 68, + "Name": "PutOwnByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 69, + "Name": "DelById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 13 + }, + { + "Opcode": 70, + "Name": "DelByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 13 + }, + { + "Opcode": 71, + "Name": "GetByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 72, + "Name": "PutByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 73, + "Name": "DelByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 74, + "Name": "PutOwnGetterSetterByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 75, + "Name": "GetPNameList", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 76, + "Name": "GetNextPName", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 77, + "Name": "Call", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 14 + }, + { + "Opcode": 78, + "Name": "Construct", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 15 + }, + { + "Opcode": 79, + "Name": "Call1", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 80, + "Name": "CallDirect", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 16 + }, + { + "Opcode": 81, + "Name": "Call2", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 82, + "Name": "Call3", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 83, + "Name": "Call4", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 84, + "Name": "CallLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 14 + }, + { + "Opcode": 85, + "Name": "ConstructLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 15 + }, + { + "Opcode": 86, + "Name": "CallDirectLongIndex", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 16 + }, + { + "Opcode": 87, + "Name": "CallBuiltin", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 17 + }, + { + "Opcode": 88, + "Name": "CallBuiltinLong", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 17 + }, + { + "Opcode": 89, + "Name": "GetBuiltinClosure", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 90, + "Name": "Ret", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 91, + "Name": "Catch", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 92, + "Name": "DirectEval", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 93, + "Name": "Throw", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 94, + "Name": "ThrowIfEmpty", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 95, + "Name": "Debugger", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 96, + "Name": "AsyncBreakCheck", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 97, + "Name": "ProfilePoint", + "OperandTypes": [ + "UInt16" + ], + "IsJump": false + }, + { + "Opcode": 98, + "Name": "CreateClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 18 + }, + { + "Opcode": 99, + "Name": "CreateClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 18 + }, + { + "Opcode": 100, + "Name": "CreateGeneratorClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 19 + }, + { + "Opcode": 101, + "Name": "CreateGeneratorClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 19 + }, + { + "Opcode": 102, + "Name": "CreateAsyncClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 20 + }, + { + "Opcode": 103, + "Name": "CreateAsyncClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 20 + }, + { + "Opcode": 104, + "Name": "CreateThis", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 105, + "Name": "SelectObject", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 106, + "Name": "LoadParam", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 21 + }, + { + "Opcode": 107, + "Name": "LoadParamLong", + "OperandTypes": [ + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 21 + }, + { + "Opcode": 108, + "Name": "LoadConstUInt8", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 109, + "Name": "LoadConstInt", + "OperandTypes": [ + "Reg8", + "Imm32" + ], + "IsJump": false + }, + { + "Opcode": 110, + "Name": "LoadConstDouble", + "OperandTypes": [ + "Reg8", + "Double" + ], + "IsJump": false + }, + { + "Opcode": 111, + "Name": "LoadConstBigInt", + "OperandTypes": [ + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 22 + }, + { + "Opcode": 112, + "Name": "LoadConstBigIntLongIndex", + "OperandTypes": [ + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 22 + }, + { + "Opcode": 113, + "Name": "LoadConstString", + "OperandTypes": [ + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 23 + }, + { + "Opcode": 114, + "Name": "LoadConstStringLongIndex", + "OperandTypes": [ + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 23 + }, + { + "Opcode": 115, + "Name": "LoadConstEmpty", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 116, + "Name": "LoadConstUndefined", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 117, + "Name": "LoadConstNull", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 118, + "Name": "LoadConstTrue", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 119, + "Name": "LoadConstFalse", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 120, + "Name": "LoadConstZero", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 121, + "Name": "CoerceThisNS", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 122, + "Name": "LoadThisNS", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 123, + "Name": "ToNumber", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 124, + "Name": "ToNumeric", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 125, + "Name": "ToInt32", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 126, + "Name": "AddEmptyString", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 127, + "Name": "GetArgumentsPropByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 128, + "Name": "GetArgumentsLength", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 129, + "Name": "ReifyArguments", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 130, + "Name": "CreateRegExp", + "OperandTypes": [ + "Reg8", + "UInt32S", + "UInt32S", + "UInt32" + ], + "IsJump": false + }, + { + "Opcode": 131, + "Name": "SwitchImm", + "OperandTypes": [ + "Reg8", + "UInt32", + "Addr32", + "UInt32", + "UInt32" + ], + "IsJump": false + }, + { + "Opcode": 132, + "Name": "StartGenerator", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 133, + "Name": "ResumeGenerator", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 134, + "Name": "CompleteGenerator", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 135, + "Name": "CreateGenerator", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 24 + }, + { + "Opcode": 136, + "Name": "CreateGeneratorLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 24 + }, + { + "Opcode": 137, + "Name": "IteratorBegin", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 138, + "Name": "IteratorNext", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 139, + "Name": "IteratorClose", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 140, + "Name": "Jmp", + "OperandTypes": [ + "Addr8" + ], + "IsJump": true, + "AbstractDefinition": 25 + }, + { + "Opcode": 141, + "Name": "JmpLong", + "OperandTypes": [ + "Addr32" + ], + "IsJump": true, + "AbstractDefinition": 25 + }, + { + "Opcode": 142, + "Name": "JmpTrue", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 26 + }, + { + "Opcode": 143, + "Name": "JmpTrueLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 26 + }, + { + "Opcode": 144, + "Name": "JmpFalse", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 27 + }, + { + "Opcode": 145, + "Name": "JmpFalseLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 27 + }, + { + "Opcode": 146, + "Name": "JmpUndefined", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 28 + }, + { + "Opcode": 147, + "Name": "JmpUndefinedLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 28 + }, + { + "Opcode": 148, + "Name": "SaveGenerator", + "OperandTypes": [ + "Addr8" + ], + "IsJump": true, + "AbstractDefinition": 29 + }, + { + "Opcode": 149, + "Name": "SaveGeneratorLong", + "OperandTypes": [ + "Addr32" + ], + "IsJump": true, + "AbstractDefinition": 29 + }, + { + "Opcode": 150, + "Name": "JLess", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 30 + }, + { + "Opcode": 151, + "Name": "JLessLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 30 + }, + { + "Opcode": 152, + "Name": "JNotLess", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 31 + }, + { + "Opcode": 153, + "Name": "JNotLessLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 31 + }, + { + "Opcode": 154, + "Name": "JLessN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 32 + }, + { + "Opcode": 155, + "Name": "JLessNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 32 + }, + { + "Opcode": 156, + "Name": "JNotLessN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 33 + }, + { + "Opcode": 157, + "Name": "JNotLessNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 33 + }, + { + "Opcode": 158, + "Name": "JLessEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 34 + }, + { + "Opcode": 159, + "Name": "JLessEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 34 + }, + { + "Opcode": 160, + "Name": "JNotLessEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 35 + }, + { + "Opcode": 161, + "Name": "JNotLessEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 35 + }, + { + "Opcode": 162, + "Name": "JLessEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 36 + }, + { + "Opcode": 163, + "Name": "JLessEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 36 + }, + { + "Opcode": 164, + "Name": "JNotLessEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 37 + }, + { + "Opcode": 165, + "Name": "JNotLessEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 37 + }, + { + "Opcode": 166, + "Name": "JGreater", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 38 + }, + { + "Opcode": 167, + "Name": "JGreaterLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 38 + }, + { + "Opcode": 168, + "Name": "JNotGreater", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 39 + }, + { + "Opcode": 169, + "Name": "JNotGreaterLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 39 + }, + { + "Opcode": 170, + "Name": "JGreaterN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 40 + }, + { + "Opcode": 171, + "Name": "JGreaterNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 40 + }, + { + "Opcode": 172, + "Name": "JNotGreaterN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 41 + }, + { + "Opcode": 173, + "Name": "JNotGreaterNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 41 + }, + { + "Opcode": 174, + "Name": "JGreaterEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 42 + }, + { + "Opcode": 175, + "Name": "JGreaterEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 42 + }, + { + "Opcode": 176, + "Name": "JNotGreaterEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 43 + }, + { + "Opcode": 177, + "Name": "JNotGreaterEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 43 + }, + { + "Opcode": 178, + "Name": "JGreaterEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 44 + }, + { + "Opcode": 179, + "Name": "JGreaterEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 44 + }, + { + "Opcode": 180, + "Name": "JNotGreaterEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 45 + }, + { + "Opcode": 181, + "Name": "JNotGreaterEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 45 + }, + { + "Opcode": 182, + "Name": "JEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 46 + }, + { + "Opcode": 183, + "Name": "JEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 46 + }, + { + "Opcode": 184, + "Name": "JNotEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 47 + }, + { + "Opcode": 185, + "Name": "JNotEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 47 + }, + { + "Opcode": 186, + "Name": "JStrictEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 48 + }, + { + "Opcode": 187, + "Name": "JStrictEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 48 + }, + { + "Opcode": 188, + "Name": "JStrictNotEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 49 + }, + { + "Opcode": 189, + "Name": "JStrictNotEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 49 + }, + { + "Opcode": 190, + "Name": "Add32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 191, + "Name": "Sub32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 192, + "Name": "Mul32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 193, + "Name": "Divi32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 194, + "Name": "Divu32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 195, + "Name": "Loadi8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 196, + "Name": "Loadu8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 197, + "Name": "Loadi16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 198, + "Name": "Loadu16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 199, + "Name": "Loadi32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 200, + "Name": "Loadu32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 201, + "Name": "Store8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 202, + "Name": "Store16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 203, + "Name": "Store32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + } + ], + "AbstractDefinitions": [ + { + "Name": "NewObjectWithBuffer", + "VariantOpcodes": [ + 1, + 2 + ] + }, + { + "Name": "NewArrayWithBuffer", + "VariantOpcodes": [ + 5, + 6 + ] + }, + { + "Name": "Mov", + "VariantOpcodes": [ + 8, + 9 + ] + }, + { + "Name": "StoreToEnvironment", + "VariantOpcodes": [ + 42, + 43 + ] + }, + { + "Name": "StoreNPToEnvironment", + "VariantOpcodes": [ + 44, + 45 + ] + }, + { + "Name": "LoadFromEnvironment", + "VariantOpcodes": [ + 46, + 47 + ] + }, + { + "Name": "GetById", + "VariantOpcodes": [ + 53, + 52, + 54 + ] + }, + { + "Name": "TryGetById", + "VariantOpcodes": [ + 55, + 56 + ] + }, + { + "Name": "PutById", + "VariantOpcodes": [ + 57, + 58 + ] + }, + { + "Name": "TryPutById", + "VariantOpcodes": [ + 59, + 60 + ] + }, + { + "Name": "PutNewOwnById", + "VariantOpcodes": [ + 62, + 61, + 63 + ] + }, + { + "Name": "PutNewOwnNEById", + "VariantOpcodes": [ + 64, + 65 + ] + }, + { + "Name": "PutOwnByIndex", + "VariantOpcodes": [ + 66, + 67 + ] + }, + { + "Name": "DelById", + "VariantOpcodes": [ + 69, + 70 + ] + }, + { + "Name": "Call", + "VariantOpcodes": [ + 77, + 84 + ] + }, + { + "Name": "Construct", + "VariantOpcodes": [ + 78, + 85 + ] + }, + { + "Name": "CallDirect", + "VariantOpcodes": [ + 80, + 86 + ] + }, + { + "Name": "CallBuiltin", + "VariantOpcodes": [ + 87, + 88 + ] + }, + { + "Name": "CreateClosure", + "VariantOpcodes": [ + 98, + 99 + ] + }, + { + "Name": "CreateGeneratorClosure", + "VariantOpcodes": [ + 100, + 101 + ] + }, + { + "Name": "CreateAsyncClosure", + "VariantOpcodes": [ + 102, + 103 + ] + }, + { + "Name": "LoadParam", + "VariantOpcodes": [ + 106, + 107 + ] + }, + { + "Name": "LoadConstBigInt", + "VariantOpcodes": [ + 111, + 112 + ] + }, + { + "Name": "LoadConstString", + "VariantOpcodes": [ + 113, + 114 + ] + }, + { + "Name": "CreateGenerator", + "VariantOpcodes": [ + 135, + 136 + ] + }, + { + "Name": "Jmp", + "VariantOpcodes": [ + 140, + 141 + ] + }, + { + "Name": "JmpTrue", + "VariantOpcodes": [ + 142, + 143 + ] + }, + { + "Name": "JmpFalse", + "VariantOpcodes": [ + 144, + 145 + ] + }, + { + "Name": "JmpUndefined", + "VariantOpcodes": [ + 146, + 147 + ] + }, + { + "Name": "SaveGenerator", + "VariantOpcodes": [ + 148, + 149 + ] + }, + { + "Name": "JLess", + "VariantOpcodes": [ + 150, + 151 + ] + }, + { + "Name": "JNotLess", + "VariantOpcodes": [ + 152, + 153 + ] + }, + { + "Name": "JLessN", + "VariantOpcodes": [ + 154, + 155 + ] + }, + { + "Name": "JNotLessN", + "VariantOpcodes": [ + 156, + 157 + ] + }, + { + "Name": "JLessEqual", + "VariantOpcodes": [ + 158, + 159 + ] + }, + { + "Name": "JNotLessEqual", + "VariantOpcodes": [ + 160, + 161 + ] + }, + { + "Name": "JLessEqualN", + "VariantOpcodes": [ + 162, + 163 + ] + }, + { + "Name": "JNotLessEqualN", + "VariantOpcodes": [ + 164, + 165 + ] + }, + { + "Name": "JGreater", + "VariantOpcodes": [ + 166, + 167 + ] + }, + { + "Name": "JNotGreater", + "VariantOpcodes": [ + 168, + 169 + ] + }, + { + "Name": "JGreaterN", + "VariantOpcodes": [ + 170, + 171 + ] + }, + { + "Name": "JNotGreaterN", + "VariantOpcodes": [ + 172, + 173 + ] + }, + { + "Name": "JGreaterEqual", + "VariantOpcodes": [ + 174, + 175 + ] + }, + { + "Name": "JNotGreaterEqual", + "VariantOpcodes": [ + 176, + 177 + ] + }, + { + "Name": "JGreaterEqualN", + "VariantOpcodes": [ + 178, + 179 + ] + }, + { + "Name": "JNotGreaterEqualN", + "VariantOpcodes": [ + 180, + 181 + ] + }, + { + "Name": "JEqual", + "VariantOpcodes": [ + 182, + 183 + ] + }, + { + "Name": "JNotEqual", + "VariantOpcodes": [ + 184, + 185 + ] + }, + { + "Name": "JStrictEqual", + "VariantOpcodes": [ + 186, + 187 + ] + }, + { + "Name": "JStrictNotEqual", + "VariantOpcodes": [ + 188, + 189 + ] + } + ], + "GitCommitHash": "6ce4457fefdb50c6ce431b371e514914848fb128" +} \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode92.json b/hasmer/libhasmer/Resources/Bytecode92.json new file mode 100644 index 0000000..399d19e --- /dev/null +++ b/hasmer/libhasmer/Resources/Bytecode92.json @@ -0,0 +1,2450 @@ +{ + "Version": 92, + "Definitions": [ + { + "Opcode": 0, + "Name": "Unreachable", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 1, + "Name": "NewObjectWithBuffer", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt16", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 0 + }, + { + "Opcode": 2, + "Name": "NewObjectWithBufferLong", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt32", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 0 + }, + { + "Opcode": 3, + "Name": "NewObject", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 4, + "Name": "NewObjectWithParent", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 5, + "Name": "NewArrayWithBuffer", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 1 + }, + { + "Opcode": 6, + "Name": "NewArrayWithBufferLong", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 1 + }, + { + "Opcode": 7, + "Name": "NewArray", + "OperandTypes": [ + "Reg8", + "UInt16" + ], + "IsJump": false + }, + { + "Opcode": 8, + "Name": "Mov", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 2 + }, + { + "Opcode": 9, + "Name": "MovLong", + "OperandTypes": [ + "Reg32", + "Reg32" + ], + "IsJump": false, + "AbstractDefinition": 2 + }, + { + "Opcode": 10, + "Name": "Negate", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 11, + "Name": "Not", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 12, + "Name": "BitNot", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 13, + "Name": "TypeOf", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 14, + "Name": "Eq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 15, + "Name": "StrictEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 16, + "Name": "Neq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 17, + "Name": "StrictNeq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 18, + "Name": "Less", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 19, + "Name": "LessEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 20, + "Name": "Greater", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 21, + "Name": "GreaterEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 22, + "Name": "Add", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 23, + "Name": "AddN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 24, + "Name": "Mul", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 25, + "Name": "MulN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 26, + "Name": "Div", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 27, + "Name": "DivN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 28, + "Name": "Mod", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 29, + "Name": "Sub", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 30, + "Name": "SubN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 31, + "Name": "LShift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 32, + "Name": "RShift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 33, + "Name": "URshift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 34, + "Name": "BitAnd", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 35, + "Name": "BitXor", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 36, + "Name": "BitOr", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 37, + "Name": "Inc", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 38, + "Name": "Dec", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 39, + "Name": "InstanceOf", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 40, + "Name": "IsIn", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 41, + "Name": "GetEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 42, + "Name": "StoreToEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 3 + }, + { + "Opcode": 43, + "Name": "StoreToEnvironmentL", + "OperandTypes": [ + "Reg8", + "UInt16", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 3 + }, + { + "Opcode": 44, + "Name": "StoreNPToEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 4 + }, + { + "Opcode": 45, + "Name": "StoreNPToEnvironmentL", + "OperandTypes": [ + "Reg8", + "UInt16", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 4 + }, + { + "Opcode": 46, + "Name": "LoadFromEnvironment", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 5 + }, + { + "Opcode": 47, + "Name": "LoadFromEnvironmentL", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 5 + }, + { + "Opcode": 48, + "Name": "GetGlobalObject", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 49, + "Name": "GetNewTarget", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 50, + "Name": "CreateEnvironment", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 51, + "Name": "CreateInnerEnvironment", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false + }, + { + "Opcode": 52, + "Name": "DeclareGlobalVar", + "OperandTypes": [ + "UInt32S" + ], + "IsJump": false + }, + { + "Opcode": 53, + "Name": "ThrowIfHasRestrictedGlobalProperty", + "OperandTypes": [ + "UInt32S" + ], + "IsJump": false + }, + { + "Opcode": 54, + "Name": "GetByIdShort", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt8S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 55, + "Name": "GetById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 56, + "Name": "GetByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 57, + "Name": "TryGetById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 7 + }, + { + "Opcode": 58, + "Name": "TryGetByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 7 + }, + { + "Opcode": 59, + "Name": "PutById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 8 + }, + { + "Opcode": 60, + "Name": "PutByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 8 + }, + { + "Opcode": 61, + "Name": "TryPutById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 9 + }, + { + "Opcode": 62, + "Name": "TryPutByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 9 + }, + { + "Opcode": 63, + "Name": "PutNewOwnByIdShort", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 64, + "Name": "PutNewOwnById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 65, + "Name": "PutNewOwnByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 66, + "Name": "PutNewOwnNEById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 11 + }, + { + "Opcode": 67, + "Name": "PutNewOwnNEByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 11 + }, + { + "Opcode": 68, + "Name": "PutOwnByIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 12 + }, + { + "Opcode": 69, + "Name": "PutOwnByIndexL", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 12 + }, + { + "Opcode": 70, + "Name": "PutOwnByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 71, + "Name": "DelById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 13 + }, + { + "Opcode": 72, + "Name": "DelByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 13 + }, + { + "Opcode": 73, + "Name": "GetByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 74, + "Name": "PutByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 75, + "Name": "DelByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 76, + "Name": "PutOwnGetterSetterByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 77, + "Name": "GetPNameList", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 78, + "Name": "GetNextPName", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 79, + "Name": "Call", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 14 + }, + { + "Opcode": 80, + "Name": "Construct", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 15 + }, + { + "Opcode": 81, + "Name": "Call1", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 82, + "Name": "CallDirect", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 16 + }, + { + "Opcode": 83, + "Name": "Call2", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 84, + "Name": "Call3", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 85, + "Name": "Call4", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 86, + "Name": "CallLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 14 + }, + { + "Opcode": 87, + "Name": "ConstructLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 15 + }, + { + "Opcode": 88, + "Name": "CallDirectLongIndex", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 16 + }, + { + "Opcode": 89, + "Name": "CallBuiltin", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 17 + }, + { + "Opcode": 90, + "Name": "CallBuiltinLong", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 17 + }, + { + "Opcode": 91, + "Name": "GetBuiltinClosure", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 92, + "Name": "Ret", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 93, + "Name": "Catch", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 94, + "Name": "DirectEval", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 95, + "Name": "Throw", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 96, + "Name": "ThrowIfEmpty", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 97, + "Name": "Debugger", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 98, + "Name": "AsyncBreakCheck", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 99, + "Name": "ProfilePoint", + "OperandTypes": [ + "UInt16" + ], + "IsJump": false + }, + { + "Opcode": 100, + "Name": "CreateClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 18 + }, + { + "Opcode": 101, + "Name": "CreateClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 18 + }, + { + "Opcode": 102, + "Name": "CreateGeneratorClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 19 + }, + { + "Opcode": 103, + "Name": "CreateGeneratorClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 19 + }, + { + "Opcode": 104, + "Name": "CreateAsyncClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 20 + }, + { + "Opcode": 105, + "Name": "CreateAsyncClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 20 + }, + { + "Opcode": 106, + "Name": "CreateThis", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 107, + "Name": "SelectObject", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 108, + "Name": "LoadParam", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 21 + }, + { + "Opcode": 109, + "Name": "LoadParamLong", + "OperandTypes": [ + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 21 + }, + { + "Opcode": 110, + "Name": "LoadConstUInt8", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 111, + "Name": "LoadConstInt", + "OperandTypes": [ + "Reg8", + "Imm32" + ], + "IsJump": false + }, + { + "Opcode": 112, + "Name": "LoadConstDouble", + "OperandTypes": [ + "Reg8", + "Double" + ], + "IsJump": false + }, + { + "Opcode": 113, + "Name": "LoadConstBigInt", + "OperandTypes": [ + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 22 + }, + { + "Opcode": 114, + "Name": "LoadConstBigIntLongIndex", + "OperandTypes": [ + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 22 + }, + { + "Opcode": 115, + "Name": "LoadConstString", + "OperandTypes": [ + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 23 + }, + { + "Opcode": 116, + "Name": "LoadConstStringLongIndex", + "OperandTypes": [ + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 23 + }, + { + "Opcode": 117, + "Name": "LoadConstEmpty", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 118, + "Name": "LoadConstUndefined", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 119, + "Name": "LoadConstNull", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 120, + "Name": "LoadConstTrue", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 121, + "Name": "LoadConstFalse", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 122, + "Name": "LoadConstZero", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 123, + "Name": "CoerceThisNS", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 124, + "Name": "LoadThisNS", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 125, + "Name": "ToNumber", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 126, + "Name": "ToNumeric", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 127, + "Name": "ToInt32", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 128, + "Name": "AddEmptyString", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 129, + "Name": "GetArgumentsPropByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 130, + "Name": "GetArgumentsLength", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 131, + "Name": "ReifyArguments", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 132, + "Name": "CreateRegExp", + "OperandTypes": [ + "Reg8", + "UInt32S", + "UInt32S", + "UInt32" + ], + "IsJump": false + }, + { + "Opcode": 133, + "Name": "SwitchImm", + "OperandTypes": [ + "Reg8", + "UInt32", + "Addr32", + "UInt32", + "UInt32" + ], + "IsJump": false + }, + { + "Opcode": 134, + "Name": "StartGenerator", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 135, + "Name": "ResumeGenerator", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 136, + "Name": "CompleteGenerator", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 137, + "Name": "CreateGenerator", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 24 + }, + { + "Opcode": 138, + "Name": "CreateGeneratorLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 24 + }, + { + "Opcode": 139, + "Name": "IteratorBegin", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 140, + "Name": "IteratorNext", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 141, + "Name": "IteratorClose", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 142, + "Name": "Jmp", + "OperandTypes": [ + "Addr8" + ], + "IsJump": true, + "AbstractDefinition": 25 + }, + { + "Opcode": 143, + "Name": "JmpLong", + "OperandTypes": [ + "Addr32" + ], + "IsJump": true, + "AbstractDefinition": 25 + }, + { + "Opcode": 144, + "Name": "JmpTrue", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 26 + }, + { + "Opcode": 145, + "Name": "JmpTrueLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 26 + }, + { + "Opcode": 146, + "Name": "JmpFalse", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 27 + }, + { + "Opcode": 147, + "Name": "JmpFalseLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 27 + }, + { + "Opcode": 148, + "Name": "JmpUndefined", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 28 + }, + { + "Opcode": 149, + "Name": "JmpUndefinedLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 28 + }, + { + "Opcode": 150, + "Name": "SaveGenerator", + "OperandTypes": [ + "Addr8" + ], + "IsJump": true, + "AbstractDefinition": 29 + }, + { + "Opcode": 151, + "Name": "SaveGeneratorLong", + "OperandTypes": [ + "Addr32" + ], + "IsJump": true, + "AbstractDefinition": 29 + }, + { + "Opcode": 152, + "Name": "JLess", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 30 + }, + { + "Opcode": 153, + "Name": "JLessLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 30 + }, + { + "Opcode": 154, + "Name": "JNotLess", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 31 + }, + { + "Opcode": 155, + "Name": "JNotLessLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 31 + }, + { + "Opcode": 156, + "Name": "JLessN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 32 + }, + { + "Opcode": 157, + "Name": "JLessNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 32 + }, + { + "Opcode": 158, + "Name": "JNotLessN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 33 + }, + { + "Opcode": 159, + "Name": "JNotLessNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 33 + }, + { + "Opcode": 160, + "Name": "JLessEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 34 + }, + { + "Opcode": 161, + "Name": "JLessEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 34 + }, + { + "Opcode": 162, + "Name": "JNotLessEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 35 + }, + { + "Opcode": 163, + "Name": "JNotLessEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 35 + }, + { + "Opcode": 164, + "Name": "JLessEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 36 + }, + { + "Opcode": 165, + "Name": "JLessEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 36 + }, + { + "Opcode": 166, + "Name": "JNotLessEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 37 + }, + { + "Opcode": 167, + "Name": "JNotLessEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 37 + }, + { + "Opcode": 168, + "Name": "JGreater", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 38 + }, + { + "Opcode": 169, + "Name": "JGreaterLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 38 + }, + { + "Opcode": 170, + "Name": "JNotGreater", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 39 + }, + { + "Opcode": 171, + "Name": "JNotGreaterLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 39 + }, + { + "Opcode": 172, + "Name": "JGreaterN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 40 + }, + { + "Opcode": 173, + "Name": "JGreaterNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 40 + }, + { + "Opcode": 174, + "Name": "JNotGreaterN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 41 + }, + { + "Opcode": 175, + "Name": "JNotGreaterNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 41 + }, + { + "Opcode": 176, + "Name": "JGreaterEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 42 + }, + { + "Opcode": 177, + "Name": "JGreaterEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 42 + }, + { + "Opcode": 178, + "Name": "JNotGreaterEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 43 + }, + { + "Opcode": 179, + "Name": "JNotGreaterEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 43 + }, + { + "Opcode": 180, + "Name": "JGreaterEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 44 + }, + { + "Opcode": 181, + "Name": "JGreaterEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 44 + }, + { + "Opcode": 182, + "Name": "JNotGreaterEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 45 + }, + { + "Opcode": 183, + "Name": "JNotGreaterEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 45 + }, + { + "Opcode": 184, + "Name": "JEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 46 + }, + { + "Opcode": 185, + "Name": "JEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 46 + }, + { + "Opcode": 186, + "Name": "JNotEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 47 + }, + { + "Opcode": 187, + "Name": "JNotEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 47 + }, + { + "Opcode": 188, + "Name": "JStrictEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 48 + }, + { + "Opcode": 189, + "Name": "JStrictEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 48 + }, + { + "Opcode": 190, + "Name": "JStrictNotEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 49 + }, + { + "Opcode": 191, + "Name": "JStrictNotEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 49 + }, + { + "Opcode": 192, + "Name": "Add32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 193, + "Name": "Sub32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 194, + "Name": "Mul32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 195, + "Name": "Divi32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 196, + "Name": "Divu32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 197, + "Name": "Loadi8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 198, + "Name": "Loadu8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 199, + "Name": "Loadi16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 200, + "Name": "Loadu16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 201, + "Name": "Loadi32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 202, + "Name": "Loadu32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 203, + "Name": "Store8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 204, + "Name": "Store16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 205, + "Name": "Store32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + } + ], + "AbstractDefinitions": [ + { + "Name": "NewObjectWithBuffer", + "VariantOpcodes": [ + 1, + 2 + ] + }, + { + "Name": "NewArrayWithBuffer", + "VariantOpcodes": [ + 5, + 6 + ] + }, + { + "Name": "Mov", + "VariantOpcodes": [ + 8, + 9 + ] + }, + { + "Name": "StoreToEnvironment", + "VariantOpcodes": [ + 42, + 43 + ] + }, + { + "Name": "StoreNPToEnvironment", + "VariantOpcodes": [ + 44, + 45 + ] + }, + { + "Name": "LoadFromEnvironment", + "VariantOpcodes": [ + 46, + 47 + ] + }, + { + "Name": "GetById", + "VariantOpcodes": [ + 55, + 54, + 56 + ] + }, + { + "Name": "TryGetById", + "VariantOpcodes": [ + 57, + 58 + ] + }, + { + "Name": "PutById", + "VariantOpcodes": [ + 59, + 60 + ] + }, + { + "Name": "TryPutById", + "VariantOpcodes": [ + 61, + 62 + ] + }, + { + "Name": "PutNewOwnById", + "VariantOpcodes": [ + 64, + 63, + 65 + ] + }, + { + "Name": "PutNewOwnNEById", + "VariantOpcodes": [ + 66, + 67 + ] + }, + { + "Name": "PutOwnByIndex", + "VariantOpcodes": [ + 68, + 69 + ] + }, + { + "Name": "DelById", + "VariantOpcodes": [ + 71, + 72 + ] + }, + { + "Name": "Call", + "VariantOpcodes": [ + 79, + 86 + ] + }, + { + "Name": "Construct", + "VariantOpcodes": [ + 80, + 87 + ] + }, + { + "Name": "CallDirect", + "VariantOpcodes": [ + 82, + 88 + ] + }, + { + "Name": "CallBuiltin", + "VariantOpcodes": [ + 89, + 90 + ] + }, + { + "Name": "CreateClosure", + "VariantOpcodes": [ + 100, + 101 + ] + }, + { + "Name": "CreateGeneratorClosure", + "VariantOpcodes": [ + 102, + 103 + ] + }, + { + "Name": "CreateAsyncClosure", + "VariantOpcodes": [ + 104, + 105 + ] + }, + { + "Name": "LoadParam", + "VariantOpcodes": [ + 108, + 109 + ] + }, + { + "Name": "LoadConstBigInt", + "VariantOpcodes": [ + 113, + 114 + ] + }, + { + "Name": "LoadConstString", + "VariantOpcodes": [ + 115, + 116 + ] + }, + { + "Name": "CreateGenerator", + "VariantOpcodes": [ + 137, + 138 + ] + }, + { + "Name": "Jmp", + "VariantOpcodes": [ + 142, + 143 + ] + }, + { + "Name": "JmpTrue", + "VariantOpcodes": [ + 144, + 145 + ] + }, + { + "Name": "JmpFalse", + "VariantOpcodes": [ + 146, + 147 + ] + }, + { + "Name": "JmpUndefined", + "VariantOpcodes": [ + 148, + 149 + ] + }, + { + "Name": "SaveGenerator", + "VariantOpcodes": [ + 150, + 151 + ] + }, + { + "Name": "JLess", + "VariantOpcodes": [ + 152, + 153 + ] + }, + { + "Name": "JNotLess", + "VariantOpcodes": [ + 154, + 155 + ] + }, + { + "Name": "JLessN", + "VariantOpcodes": [ + 156, + 157 + ] + }, + { + "Name": "JNotLessN", + "VariantOpcodes": [ + 158, + 159 + ] + }, + { + "Name": "JLessEqual", + "VariantOpcodes": [ + 160, + 161 + ] + }, + { + "Name": "JNotLessEqual", + "VariantOpcodes": [ + 162, + 163 + ] + }, + { + "Name": "JLessEqualN", + "VariantOpcodes": [ + 164, + 165 + ] + }, + { + "Name": "JNotLessEqualN", + "VariantOpcodes": [ + 166, + 167 + ] + }, + { + "Name": "JGreater", + "VariantOpcodes": [ + 168, + 169 + ] + }, + { + "Name": "JNotGreater", + "VariantOpcodes": [ + 170, + 171 + ] + }, + { + "Name": "JGreaterN", + "VariantOpcodes": [ + 172, + 173 + ] + }, + { + "Name": "JNotGreaterN", + "VariantOpcodes": [ + 174, + 175 + ] + }, + { + "Name": "JGreaterEqual", + "VariantOpcodes": [ + 176, + 177 + ] + }, + { + "Name": "JNotGreaterEqual", + "VariantOpcodes": [ + 178, + 179 + ] + }, + { + "Name": "JGreaterEqualN", + "VariantOpcodes": [ + 180, + 181 + ] + }, + { + "Name": "JNotGreaterEqualN", + "VariantOpcodes": [ + 182, + 183 + ] + }, + { + "Name": "JEqual", + "VariantOpcodes": [ + 184, + 185 + ] + }, + { + "Name": "JNotEqual", + "VariantOpcodes": [ + 186, + 187 + ] + }, + { + "Name": "JStrictEqual", + "VariantOpcodes": [ + 188, + 189 + ] + }, + { + "Name": "JStrictNotEqual", + "VariantOpcodes": [ + 190, + 191 + ] + } + ], + "GitCommitHash": "b544ff4a587586a296c5e15e3901c22be45c145f" +} \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode93.json b/hasmer/libhasmer/Resources/Bytecode93.json new file mode 100644 index 0000000..ec552c5 --- /dev/null +++ b/hasmer/libhasmer/Resources/Bytecode93.json @@ -0,0 +1,2432 @@ +{ + "Version": 93, + "Definitions": [ + { + "Opcode": 0, + "Name": "Unreachable", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 1, + "Name": "NewObjectWithBuffer", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt16", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 0 + }, + { + "Opcode": 2, + "Name": "NewObjectWithBufferLong", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt32", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 0 + }, + { + "Opcode": 3, + "Name": "NewObject", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 4, + "Name": "NewObjectWithParent", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 5, + "Name": "NewArrayWithBuffer", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 1 + }, + { + "Opcode": 6, + "Name": "NewArrayWithBufferLong", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 1 + }, + { + "Opcode": 7, + "Name": "NewArray", + "OperandTypes": [ + "Reg8", + "UInt16" + ], + "IsJump": false + }, + { + "Opcode": 8, + "Name": "Mov", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 2 + }, + { + "Opcode": 9, + "Name": "MovLong", + "OperandTypes": [ + "Reg32", + "Reg32" + ], + "IsJump": false, + "AbstractDefinition": 2 + }, + { + "Opcode": 10, + "Name": "Negate", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 11, + "Name": "Not", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 12, + "Name": "BitNot", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 13, + "Name": "TypeOf", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 14, + "Name": "Eq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 15, + "Name": "StrictEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 16, + "Name": "Neq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 17, + "Name": "StrictNeq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 18, + "Name": "Less", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 19, + "Name": "LessEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 20, + "Name": "Greater", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 21, + "Name": "GreaterEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 22, + "Name": "Add", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 23, + "Name": "AddN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 24, + "Name": "Mul", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 25, + "Name": "MulN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 26, + "Name": "Div", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 27, + "Name": "DivN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 28, + "Name": "Mod", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 29, + "Name": "Sub", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 30, + "Name": "SubN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 31, + "Name": "LShift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 32, + "Name": "RShift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 33, + "Name": "URshift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 34, + "Name": "BitAnd", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 35, + "Name": "BitXor", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 36, + "Name": "BitOr", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 37, + "Name": "Inc", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 38, + "Name": "Dec", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 39, + "Name": "InstanceOf", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 40, + "Name": "IsIn", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 41, + "Name": "GetEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 42, + "Name": "StoreToEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 3 + }, + { + "Opcode": 43, + "Name": "StoreToEnvironmentL", + "OperandTypes": [ + "Reg8", + "UInt16", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 3 + }, + { + "Opcode": 44, + "Name": "StoreNPToEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 4 + }, + { + "Opcode": 45, + "Name": "StoreNPToEnvironmentL", + "OperandTypes": [ + "Reg8", + "UInt16", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 4 + }, + { + "Opcode": 46, + "Name": "LoadFromEnvironment", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 5 + }, + { + "Opcode": 47, + "Name": "LoadFromEnvironmentL", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 5 + }, + { + "Opcode": 48, + "Name": "GetGlobalObject", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 49, + "Name": "GetNewTarget", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 50, + "Name": "CreateEnvironment", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 51, + "Name": "DeclareGlobalVar", + "OperandTypes": [ + "UInt32S" + ], + "IsJump": false + }, + { + "Opcode": 52, + "Name": "GetByIdShort", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt8S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 53, + "Name": "GetById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 54, + "Name": "GetByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 55, + "Name": "TryGetById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 7 + }, + { + "Opcode": 56, + "Name": "TryGetByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 7 + }, + { + "Opcode": 57, + "Name": "PutById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 8 + }, + { + "Opcode": 58, + "Name": "PutByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 8 + }, + { + "Opcode": 59, + "Name": "TryPutById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 9 + }, + { + "Opcode": 60, + "Name": "TryPutByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 9 + }, + { + "Opcode": 61, + "Name": "PutNewOwnByIdShort", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 62, + "Name": "PutNewOwnById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 63, + "Name": "PutNewOwnByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 64, + "Name": "PutNewOwnNEById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 11 + }, + { + "Opcode": 65, + "Name": "PutNewOwnNEByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 11 + }, + { + "Opcode": 66, + "Name": "PutOwnByIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 12 + }, + { + "Opcode": 67, + "Name": "PutOwnByIndexL", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 12 + }, + { + "Opcode": 68, + "Name": "PutOwnByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 69, + "Name": "DelById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 13 + }, + { + "Opcode": 70, + "Name": "DelByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 13 + }, + { + "Opcode": 71, + "Name": "GetByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 72, + "Name": "PutByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 73, + "Name": "DelByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 74, + "Name": "PutOwnGetterSetterByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 75, + "Name": "GetPNameList", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 76, + "Name": "GetNextPName", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 77, + "Name": "Call", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 14 + }, + { + "Opcode": 78, + "Name": "Construct", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 15 + }, + { + "Opcode": 79, + "Name": "Call1", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 80, + "Name": "CallDirect", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 16 + }, + { + "Opcode": 81, + "Name": "Call2", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 82, + "Name": "Call3", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 83, + "Name": "Call4", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 84, + "Name": "CallLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 14 + }, + { + "Opcode": 85, + "Name": "ConstructLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 15 + }, + { + "Opcode": 86, + "Name": "CallDirectLongIndex", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 16 + }, + { + "Opcode": 87, + "Name": "CallBuiltin", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 17 + }, + { + "Opcode": 88, + "Name": "CallBuiltinLong", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 17 + }, + { + "Opcode": 89, + "Name": "GetBuiltinClosure", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 90, + "Name": "Ret", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 91, + "Name": "Catch", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 92, + "Name": "DirectEval", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 93, + "Name": "Throw", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 94, + "Name": "ThrowIfEmpty", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 95, + "Name": "Debugger", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 96, + "Name": "AsyncBreakCheck", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 97, + "Name": "ProfilePoint", + "OperandTypes": [ + "UInt16" + ], + "IsJump": false + }, + { + "Opcode": 98, + "Name": "CreateClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 18 + }, + { + "Opcode": 99, + "Name": "CreateClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 18 + }, + { + "Opcode": 100, + "Name": "CreateGeneratorClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 19 + }, + { + "Opcode": 101, + "Name": "CreateGeneratorClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 19 + }, + { + "Opcode": 102, + "Name": "CreateAsyncClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 20 + }, + { + "Opcode": 103, + "Name": "CreateAsyncClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 20 + }, + { + "Opcode": 104, + "Name": "CreateThis", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 105, + "Name": "SelectObject", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 106, + "Name": "LoadParam", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 21 + }, + { + "Opcode": 107, + "Name": "LoadParamLong", + "OperandTypes": [ + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 21 + }, + { + "Opcode": 108, + "Name": "LoadConstUInt8", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 109, + "Name": "LoadConstInt", + "OperandTypes": [ + "Reg8", + "Imm32" + ], + "IsJump": false + }, + { + "Opcode": 110, + "Name": "LoadConstDouble", + "OperandTypes": [ + "Reg8", + "Double" + ], + "IsJump": false + }, + { + "Opcode": 111, + "Name": "LoadConstBigInt", + "OperandTypes": [ + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 22 + }, + { + "Opcode": 112, + "Name": "LoadConstBigIntLongIndex", + "OperandTypes": [ + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 22 + }, + { + "Opcode": 113, + "Name": "LoadConstString", + "OperandTypes": [ + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 23 + }, + { + "Opcode": 114, + "Name": "LoadConstStringLongIndex", + "OperandTypes": [ + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 23 + }, + { + "Opcode": 115, + "Name": "LoadConstEmpty", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 116, + "Name": "LoadConstUndefined", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 117, + "Name": "LoadConstNull", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 118, + "Name": "LoadConstTrue", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 119, + "Name": "LoadConstFalse", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 120, + "Name": "LoadConstZero", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 121, + "Name": "CoerceThisNS", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 122, + "Name": "LoadThisNS", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 123, + "Name": "ToNumber", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 124, + "Name": "ToNumeric", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 125, + "Name": "ToInt32", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 126, + "Name": "AddEmptyString", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 127, + "Name": "GetArgumentsPropByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 128, + "Name": "GetArgumentsLength", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 129, + "Name": "ReifyArguments", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 130, + "Name": "CreateRegExp", + "OperandTypes": [ + "Reg8", + "UInt32S", + "UInt32S", + "UInt32" + ], + "IsJump": false + }, + { + "Opcode": 131, + "Name": "SwitchImm", + "OperandTypes": [ + "Reg8", + "UInt32", + "Addr32", + "UInt32", + "UInt32" + ], + "IsJump": false + }, + { + "Opcode": 132, + "Name": "StartGenerator", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 133, + "Name": "ResumeGenerator", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 134, + "Name": "CompleteGenerator", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 135, + "Name": "CreateGenerator", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 24 + }, + { + "Opcode": 136, + "Name": "CreateGeneratorLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 24 + }, + { + "Opcode": 137, + "Name": "IteratorBegin", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 138, + "Name": "IteratorNext", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 139, + "Name": "IteratorClose", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 140, + "Name": "Jmp", + "OperandTypes": [ + "Addr8" + ], + "IsJump": true, + "AbstractDefinition": 25 + }, + { + "Opcode": 141, + "Name": "JmpLong", + "OperandTypes": [ + "Addr32" + ], + "IsJump": true, + "AbstractDefinition": 25 + }, + { + "Opcode": 142, + "Name": "JmpTrue", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 26 + }, + { + "Opcode": 143, + "Name": "JmpTrueLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 26 + }, + { + "Opcode": 144, + "Name": "JmpFalse", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 27 + }, + { + "Opcode": 145, + "Name": "JmpFalseLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 27 + }, + { + "Opcode": 146, + "Name": "JmpUndefined", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 28 + }, + { + "Opcode": 147, + "Name": "JmpUndefinedLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 28 + }, + { + "Opcode": 148, + "Name": "SaveGenerator", + "OperandTypes": [ + "Addr8" + ], + "IsJump": true, + "AbstractDefinition": 29 + }, + { + "Opcode": 149, + "Name": "SaveGeneratorLong", + "OperandTypes": [ + "Addr32" + ], + "IsJump": true, + "AbstractDefinition": 29 + }, + { + "Opcode": 150, + "Name": "JLess", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 30 + }, + { + "Opcode": 151, + "Name": "JLessLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 30 + }, + { + "Opcode": 152, + "Name": "JNotLess", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 31 + }, + { + "Opcode": 153, + "Name": "JNotLessLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 31 + }, + { + "Opcode": 154, + "Name": "JLessN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 32 + }, + { + "Opcode": 155, + "Name": "JLessNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 32 + }, + { + "Opcode": 156, + "Name": "JNotLessN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 33 + }, + { + "Opcode": 157, + "Name": "JNotLessNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 33 + }, + { + "Opcode": 158, + "Name": "JLessEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 34 + }, + { + "Opcode": 159, + "Name": "JLessEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 34 + }, + { + "Opcode": 160, + "Name": "JNotLessEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 35 + }, + { + "Opcode": 161, + "Name": "JNotLessEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 35 + }, + { + "Opcode": 162, + "Name": "JLessEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 36 + }, + { + "Opcode": 163, + "Name": "JLessEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 36 + }, + { + "Opcode": 164, + "Name": "JNotLessEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 37 + }, + { + "Opcode": 165, + "Name": "JNotLessEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 37 + }, + { + "Opcode": 166, + "Name": "JGreater", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 38 + }, + { + "Opcode": 167, + "Name": "JGreaterLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 38 + }, + { + "Opcode": 168, + "Name": "JNotGreater", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 39 + }, + { + "Opcode": 169, + "Name": "JNotGreaterLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 39 + }, + { + "Opcode": 170, + "Name": "JGreaterN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 40 + }, + { + "Opcode": 171, + "Name": "JGreaterNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 40 + }, + { + "Opcode": 172, + "Name": "JNotGreaterN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 41 + }, + { + "Opcode": 173, + "Name": "JNotGreaterNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 41 + }, + { + "Opcode": 174, + "Name": "JGreaterEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 42 + }, + { + "Opcode": 175, + "Name": "JGreaterEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 42 + }, + { + "Opcode": 176, + "Name": "JNotGreaterEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 43 + }, + { + "Opcode": 177, + "Name": "JNotGreaterEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 43 + }, + { + "Opcode": 178, + "Name": "JGreaterEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 44 + }, + { + "Opcode": 179, + "Name": "JGreaterEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 44 + }, + { + "Opcode": 180, + "Name": "JNotGreaterEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 45 + }, + { + "Opcode": 181, + "Name": "JNotGreaterEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 45 + }, + { + "Opcode": 182, + "Name": "JEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 46 + }, + { + "Opcode": 183, + "Name": "JEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 46 + }, + { + "Opcode": 184, + "Name": "JNotEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 47 + }, + { + "Opcode": 185, + "Name": "JNotEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 47 + }, + { + "Opcode": 186, + "Name": "JStrictEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 48 + }, + { + "Opcode": 187, + "Name": "JStrictEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 48 + }, + { + "Opcode": 188, + "Name": "JStrictNotEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 49 + }, + { + "Opcode": 189, + "Name": "JStrictNotEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 49 + }, + { + "Opcode": 190, + "Name": "Add32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 191, + "Name": "Sub32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 192, + "Name": "Mul32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 193, + "Name": "Divi32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 194, + "Name": "Divu32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 195, + "Name": "Loadi8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 196, + "Name": "Loadu8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 197, + "Name": "Loadi16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 198, + "Name": "Loadu16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 199, + "Name": "Loadi32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 200, + "Name": "Loadu32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 201, + "Name": "Store8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 202, + "Name": "Store16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 203, + "Name": "Store32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + } + ], + "AbstractDefinitions": [ + { + "Name": "NewObjectWithBuffer", + "VariantOpcodes": [ + 1, + 2 + ] + }, + { + "Name": "NewArrayWithBuffer", + "VariantOpcodes": [ + 5, + 6 + ] + }, + { + "Name": "Mov", + "VariantOpcodes": [ + 8, + 9 + ] + }, + { + "Name": "StoreToEnvironment", + "VariantOpcodes": [ + 42, + 43 + ] + }, + { + "Name": "StoreNPToEnvironment", + "VariantOpcodes": [ + 44, + 45 + ] + }, + { + "Name": "LoadFromEnvironment", + "VariantOpcodes": [ + 46, + 47 + ] + }, + { + "Name": "GetById", + "VariantOpcodes": [ + 53, + 52, + 54 + ] + }, + { + "Name": "TryGetById", + "VariantOpcodes": [ + 55, + 56 + ] + }, + { + "Name": "PutById", + "VariantOpcodes": [ + 57, + 58 + ] + }, + { + "Name": "TryPutById", + "VariantOpcodes": [ + 59, + 60 + ] + }, + { + "Name": "PutNewOwnById", + "VariantOpcodes": [ + 62, + 61, + 63 + ] + }, + { + "Name": "PutNewOwnNEById", + "VariantOpcodes": [ + 64, + 65 + ] + }, + { + "Name": "PutOwnByIndex", + "VariantOpcodes": [ + 66, + 67 + ] + }, + { + "Name": "DelById", + "VariantOpcodes": [ + 69, + 70 + ] + }, + { + "Name": "Call", + "VariantOpcodes": [ + 77, + 84 + ] + }, + { + "Name": "Construct", + "VariantOpcodes": [ + 78, + 85 + ] + }, + { + "Name": "CallDirect", + "VariantOpcodes": [ + 80, + 86 + ] + }, + { + "Name": "CallBuiltin", + "VariantOpcodes": [ + 87, + 88 + ] + }, + { + "Name": "CreateClosure", + "VariantOpcodes": [ + 98, + 99 + ] + }, + { + "Name": "CreateGeneratorClosure", + "VariantOpcodes": [ + 100, + 101 + ] + }, + { + "Name": "CreateAsyncClosure", + "VariantOpcodes": [ + 102, + 103 + ] + }, + { + "Name": "LoadParam", + "VariantOpcodes": [ + 106, + 107 + ] + }, + { + "Name": "LoadConstBigInt", + "VariantOpcodes": [ + 111, + 112 + ] + }, + { + "Name": "LoadConstString", + "VariantOpcodes": [ + 113, + 114 + ] + }, + { + "Name": "CreateGenerator", + "VariantOpcodes": [ + 135, + 136 + ] + }, + { + "Name": "Jmp", + "VariantOpcodes": [ + 140, + 141 + ] + }, + { + "Name": "JmpTrue", + "VariantOpcodes": [ + 142, + 143 + ] + }, + { + "Name": "JmpFalse", + "VariantOpcodes": [ + 144, + 145 + ] + }, + { + "Name": "JmpUndefined", + "VariantOpcodes": [ + 146, + 147 + ] + }, + { + "Name": "SaveGenerator", + "VariantOpcodes": [ + 148, + 149 + ] + }, + { + "Name": "JLess", + "VariantOpcodes": [ + 150, + 151 + ] + }, + { + "Name": "JNotLess", + "VariantOpcodes": [ + 152, + 153 + ] + }, + { + "Name": "JLessN", + "VariantOpcodes": [ + 154, + 155 + ] + }, + { + "Name": "JNotLessN", + "VariantOpcodes": [ + 156, + 157 + ] + }, + { + "Name": "JLessEqual", + "VariantOpcodes": [ + 158, + 159 + ] + }, + { + "Name": "JNotLessEqual", + "VariantOpcodes": [ + 160, + 161 + ] + }, + { + "Name": "JLessEqualN", + "VariantOpcodes": [ + 162, + 163 + ] + }, + { + "Name": "JNotLessEqualN", + "VariantOpcodes": [ + 164, + 165 + ] + }, + { + "Name": "JGreater", + "VariantOpcodes": [ + 166, + 167 + ] + }, + { + "Name": "JNotGreater", + "VariantOpcodes": [ + 168, + 169 + ] + }, + { + "Name": "JGreaterN", + "VariantOpcodes": [ + 170, + 171 + ] + }, + { + "Name": "JNotGreaterN", + "VariantOpcodes": [ + 172, + 173 + ] + }, + { + "Name": "JGreaterEqual", + "VariantOpcodes": [ + 174, + 175 + ] + }, + { + "Name": "JNotGreaterEqual", + "VariantOpcodes": [ + 176, + 177 + ] + }, + { + "Name": "JGreaterEqualN", + "VariantOpcodes": [ + 178, + 179 + ] + }, + { + "Name": "JNotGreaterEqualN", + "VariantOpcodes": [ + 180, + 181 + ] + }, + { + "Name": "JEqual", + "VariantOpcodes": [ + 182, + 183 + ] + }, + { + "Name": "JNotEqual", + "VariantOpcodes": [ + 184, + 185 + ] + }, + { + "Name": "JStrictEqual", + "VariantOpcodes": [ + 186, + 187 + ] + }, + { + "Name": "JStrictNotEqual", + "VariantOpcodes": [ + 188, + 189 + ] + } + ], + "GitCommitHash": "760d8659d8a8c703831144de4511e0f0ac41e391" +} \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode94.json b/hasmer/libhasmer/Resources/Bytecode94.json new file mode 100644 index 0000000..3f8dd7f --- /dev/null +++ b/hasmer/libhasmer/Resources/Bytecode94.json @@ -0,0 +1,2450 @@ +{ + "Version": 94, + "Definitions": [ + { + "Opcode": 0, + "Name": "Unreachable", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 1, + "Name": "NewObjectWithBuffer", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt16", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 0 + }, + { + "Opcode": 2, + "Name": "NewObjectWithBufferLong", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt32", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 0 + }, + { + "Opcode": 3, + "Name": "NewObject", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 4, + "Name": "NewObjectWithParent", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 5, + "Name": "NewArrayWithBuffer", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 1 + }, + { + "Opcode": 6, + "Name": "NewArrayWithBufferLong", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 1 + }, + { + "Opcode": 7, + "Name": "NewArray", + "OperandTypes": [ + "Reg8", + "UInt16" + ], + "IsJump": false + }, + { + "Opcode": 8, + "Name": "Mov", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 2 + }, + { + "Opcode": 9, + "Name": "MovLong", + "OperandTypes": [ + "Reg32", + "Reg32" + ], + "IsJump": false, + "AbstractDefinition": 2 + }, + { + "Opcode": 10, + "Name": "Negate", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 11, + "Name": "Not", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 12, + "Name": "BitNot", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 13, + "Name": "TypeOf", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 14, + "Name": "Eq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 15, + "Name": "StrictEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 16, + "Name": "Neq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 17, + "Name": "StrictNeq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 18, + "Name": "Less", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 19, + "Name": "LessEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 20, + "Name": "Greater", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 21, + "Name": "GreaterEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 22, + "Name": "Add", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 23, + "Name": "AddN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 24, + "Name": "Mul", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 25, + "Name": "MulN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 26, + "Name": "Div", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 27, + "Name": "DivN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 28, + "Name": "Mod", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 29, + "Name": "Sub", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 30, + "Name": "SubN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 31, + "Name": "LShift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 32, + "Name": "RShift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 33, + "Name": "URshift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 34, + "Name": "BitAnd", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 35, + "Name": "BitXor", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 36, + "Name": "BitOr", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 37, + "Name": "Inc", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 38, + "Name": "Dec", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 39, + "Name": "InstanceOf", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 40, + "Name": "IsIn", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 41, + "Name": "GetEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 42, + "Name": "StoreToEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 3 + }, + { + "Opcode": 43, + "Name": "StoreToEnvironmentL", + "OperandTypes": [ + "Reg8", + "UInt16", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 3 + }, + { + "Opcode": 44, + "Name": "StoreNPToEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 4 + }, + { + "Opcode": 45, + "Name": "StoreNPToEnvironmentL", + "OperandTypes": [ + "Reg8", + "UInt16", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 4 + }, + { + "Opcode": 46, + "Name": "LoadFromEnvironment", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 5 + }, + { + "Opcode": 47, + "Name": "LoadFromEnvironmentL", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 5 + }, + { + "Opcode": 48, + "Name": "GetGlobalObject", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 49, + "Name": "GetNewTarget", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 50, + "Name": "CreateEnvironment", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 51, + "Name": "CreateInnerEnvironment", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false + }, + { + "Opcode": 52, + "Name": "DeclareGlobalVar", + "OperandTypes": [ + "UInt32S" + ], + "IsJump": false + }, + { + "Opcode": 53, + "Name": "ThrowIfHasRestrictedGlobalProperty", + "OperandTypes": [ + "UInt32S" + ], + "IsJump": false + }, + { + "Opcode": 54, + "Name": "GetByIdShort", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt8S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 55, + "Name": "GetById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 56, + "Name": "GetByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 57, + "Name": "TryGetById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 7 + }, + { + "Opcode": 58, + "Name": "TryGetByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 7 + }, + { + "Opcode": 59, + "Name": "PutById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 8 + }, + { + "Opcode": 60, + "Name": "PutByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 8 + }, + { + "Opcode": 61, + "Name": "TryPutById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 9 + }, + { + "Opcode": 62, + "Name": "TryPutByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 9 + }, + { + "Opcode": 63, + "Name": "PutNewOwnByIdShort", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 64, + "Name": "PutNewOwnById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 65, + "Name": "PutNewOwnByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 66, + "Name": "PutNewOwnNEById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 11 + }, + { + "Opcode": 67, + "Name": "PutNewOwnNEByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 11 + }, + { + "Opcode": 68, + "Name": "PutOwnByIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 12 + }, + { + "Opcode": 69, + "Name": "PutOwnByIndexL", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 12 + }, + { + "Opcode": 70, + "Name": "PutOwnByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 71, + "Name": "DelById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 13 + }, + { + "Opcode": 72, + "Name": "DelByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 13 + }, + { + "Opcode": 73, + "Name": "GetByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 74, + "Name": "PutByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 75, + "Name": "DelByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 76, + "Name": "PutOwnGetterSetterByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 77, + "Name": "GetPNameList", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 78, + "Name": "GetNextPName", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 79, + "Name": "Call", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 14 + }, + { + "Opcode": 80, + "Name": "Construct", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 15 + }, + { + "Opcode": 81, + "Name": "Call1", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 82, + "Name": "CallDirect", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 16 + }, + { + "Opcode": 83, + "Name": "Call2", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 84, + "Name": "Call3", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 85, + "Name": "Call4", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 86, + "Name": "CallLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 14 + }, + { + "Opcode": 87, + "Name": "ConstructLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 15 + }, + { + "Opcode": 88, + "Name": "CallDirectLongIndex", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 16 + }, + { + "Opcode": 89, + "Name": "CallBuiltin", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 17 + }, + { + "Opcode": 90, + "Name": "CallBuiltinLong", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 17 + }, + { + "Opcode": 91, + "Name": "GetBuiltinClosure", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 92, + "Name": "Ret", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 93, + "Name": "Catch", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 94, + "Name": "DirectEval", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 95, + "Name": "Throw", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 96, + "Name": "ThrowIfEmpty", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 97, + "Name": "Debugger", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 98, + "Name": "AsyncBreakCheck", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 99, + "Name": "ProfilePoint", + "OperandTypes": [ + "UInt16" + ], + "IsJump": false + }, + { + "Opcode": 100, + "Name": "CreateClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 18 + }, + { + "Opcode": 101, + "Name": "CreateClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 18 + }, + { + "Opcode": 102, + "Name": "CreateGeneratorClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 19 + }, + { + "Opcode": 103, + "Name": "CreateGeneratorClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 19 + }, + { + "Opcode": 104, + "Name": "CreateAsyncClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 20 + }, + { + "Opcode": 105, + "Name": "CreateAsyncClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 20 + }, + { + "Opcode": 106, + "Name": "CreateThis", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 107, + "Name": "SelectObject", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 108, + "Name": "LoadParam", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 21 + }, + { + "Opcode": 109, + "Name": "LoadParamLong", + "OperandTypes": [ + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 21 + }, + { + "Opcode": 110, + "Name": "LoadConstUInt8", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 111, + "Name": "LoadConstInt", + "OperandTypes": [ + "Reg8", + "Imm32" + ], + "IsJump": false + }, + { + "Opcode": 112, + "Name": "LoadConstDouble", + "OperandTypes": [ + "Reg8", + "Double" + ], + "IsJump": false + }, + { + "Opcode": 113, + "Name": "LoadConstBigInt", + "OperandTypes": [ + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 22 + }, + { + "Opcode": 114, + "Name": "LoadConstBigIntLongIndex", + "OperandTypes": [ + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 22 + }, + { + "Opcode": 115, + "Name": "LoadConstString", + "OperandTypes": [ + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 23 + }, + { + "Opcode": 116, + "Name": "LoadConstStringLongIndex", + "OperandTypes": [ + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 23 + }, + { + "Opcode": 117, + "Name": "LoadConstEmpty", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 118, + "Name": "LoadConstUndefined", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 119, + "Name": "LoadConstNull", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 120, + "Name": "LoadConstTrue", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 121, + "Name": "LoadConstFalse", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 122, + "Name": "LoadConstZero", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 123, + "Name": "CoerceThisNS", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 124, + "Name": "LoadThisNS", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 125, + "Name": "ToNumber", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 126, + "Name": "ToNumeric", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 127, + "Name": "ToInt32", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 128, + "Name": "AddEmptyString", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 129, + "Name": "GetArgumentsPropByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 130, + "Name": "GetArgumentsLength", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 131, + "Name": "ReifyArguments", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 132, + "Name": "CreateRegExp", + "OperandTypes": [ + "Reg8", + "UInt32S", + "UInt32S", + "UInt32" + ], + "IsJump": false + }, + { + "Opcode": 133, + "Name": "SwitchImm", + "OperandTypes": [ + "Reg8", + "UInt32", + "Addr32", + "UInt32", + "UInt32" + ], + "IsJump": false + }, + { + "Opcode": 134, + "Name": "StartGenerator", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 135, + "Name": "ResumeGenerator", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 136, + "Name": "CompleteGenerator", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 137, + "Name": "CreateGenerator", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 24 + }, + { + "Opcode": 138, + "Name": "CreateGeneratorLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 24 + }, + { + "Opcode": 139, + "Name": "IteratorBegin", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 140, + "Name": "IteratorNext", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 141, + "Name": "IteratorClose", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 142, + "Name": "Jmp", + "OperandTypes": [ + "Addr8" + ], + "IsJump": true, + "AbstractDefinition": 25 + }, + { + "Opcode": 143, + "Name": "JmpLong", + "OperandTypes": [ + "Addr32" + ], + "IsJump": true, + "AbstractDefinition": 25 + }, + { + "Opcode": 144, + "Name": "JmpTrue", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 26 + }, + { + "Opcode": 145, + "Name": "JmpTrueLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 26 + }, + { + "Opcode": 146, + "Name": "JmpFalse", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 27 + }, + { + "Opcode": 147, + "Name": "JmpFalseLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 27 + }, + { + "Opcode": 148, + "Name": "JmpUndefined", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 28 + }, + { + "Opcode": 149, + "Name": "JmpUndefinedLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 28 + }, + { + "Opcode": 150, + "Name": "SaveGenerator", + "OperandTypes": [ + "Addr8" + ], + "IsJump": true, + "AbstractDefinition": 29 + }, + { + "Opcode": 151, + "Name": "SaveGeneratorLong", + "OperandTypes": [ + "Addr32" + ], + "IsJump": true, + "AbstractDefinition": 29 + }, + { + "Opcode": 152, + "Name": "JLess", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 30 + }, + { + "Opcode": 153, + "Name": "JLessLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 30 + }, + { + "Opcode": 154, + "Name": "JNotLess", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 31 + }, + { + "Opcode": 155, + "Name": "JNotLessLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 31 + }, + { + "Opcode": 156, + "Name": "JLessN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 32 + }, + { + "Opcode": 157, + "Name": "JLessNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 32 + }, + { + "Opcode": 158, + "Name": "JNotLessN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 33 + }, + { + "Opcode": 159, + "Name": "JNotLessNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 33 + }, + { + "Opcode": 160, + "Name": "JLessEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 34 + }, + { + "Opcode": 161, + "Name": "JLessEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 34 + }, + { + "Opcode": 162, + "Name": "JNotLessEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 35 + }, + { + "Opcode": 163, + "Name": "JNotLessEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 35 + }, + { + "Opcode": 164, + "Name": "JLessEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 36 + }, + { + "Opcode": 165, + "Name": "JLessEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 36 + }, + { + "Opcode": 166, + "Name": "JNotLessEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 37 + }, + { + "Opcode": 167, + "Name": "JNotLessEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 37 + }, + { + "Opcode": 168, + "Name": "JGreater", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 38 + }, + { + "Opcode": 169, + "Name": "JGreaterLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 38 + }, + { + "Opcode": 170, + "Name": "JNotGreater", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 39 + }, + { + "Opcode": 171, + "Name": "JNotGreaterLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 39 + }, + { + "Opcode": 172, + "Name": "JGreaterN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 40 + }, + { + "Opcode": 173, + "Name": "JGreaterNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 40 + }, + { + "Opcode": 174, + "Name": "JNotGreaterN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 41 + }, + { + "Opcode": 175, + "Name": "JNotGreaterNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 41 + }, + { + "Opcode": 176, + "Name": "JGreaterEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 42 + }, + { + "Opcode": 177, + "Name": "JGreaterEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 42 + }, + { + "Opcode": 178, + "Name": "JNotGreaterEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 43 + }, + { + "Opcode": 179, + "Name": "JNotGreaterEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 43 + }, + { + "Opcode": 180, + "Name": "JGreaterEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 44 + }, + { + "Opcode": 181, + "Name": "JGreaterEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 44 + }, + { + "Opcode": 182, + "Name": "JNotGreaterEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 45 + }, + { + "Opcode": 183, + "Name": "JNotGreaterEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 45 + }, + { + "Opcode": 184, + "Name": "JEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 46 + }, + { + "Opcode": 185, + "Name": "JEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 46 + }, + { + "Opcode": 186, + "Name": "JNotEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 47 + }, + { + "Opcode": 187, + "Name": "JNotEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 47 + }, + { + "Opcode": 188, + "Name": "JStrictEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 48 + }, + { + "Opcode": 189, + "Name": "JStrictEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 48 + }, + { + "Opcode": 190, + "Name": "JStrictNotEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 49 + }, + { + "Opcode": 191, + "Name": "JStrictNotEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 49 + }, + { + "Opcode": 192, + "Name": "Add32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 193, + "Name": "Sub32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 194, + "Name": "Mul32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 195, + "Name": "Divi32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 196, + "Name": "Divu32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 197, + "Name": "Loadi8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 198, + "Name": "Loadu8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 199, + "Name": "Loadi16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 200, + "Name": "Loadu16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 201, + "Name": "Loadi32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 202, + "Name": "Loadu32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 203, + "Name": "Store8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 204, + "Name": "Store16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 205, + "Name": "Store32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + } + ], + "AbstractDefinitions": [ + { + "Name": "NewObjectWithBuffer", + "VariantOpcodes": [ + 1, + 2 + ] + }, + { + "Name": "NewArrayWithBuffer", + "VariantOpcodes": [ + 5, + 6 + ] + }, + { + "Name": "Mov", + "VariantOpcodes": [ + 8, + 9 + ] + }, + { + "Name": "StoreToEnvironment", + "VariantOpcodes": [ + 42, + 43 + ] + }, + { + "Name": "StoreNPToEnvironment", + "VariantOpcodes": [ + 44, + 45 + ] + }, + { + "Name": "LoadFromEnvironment", + "VariantOpcodes": [ + 46, + 47 + ] + }, + { + "Name": "GetById", + "VariantOpcodes": [ + 55, + 54, + 56 + ] + }, + { + "Name": "TryGetById", + "VariantOpcodes": [ + 57, + 58 + ] + }, + { + "Name": "PutById", + "VariantOpcodes": [ + 59, + 60 + ] + }, + { + "Name": "TryPutById", + "VariantOpcodes": [ + 61, + 62 + ] + }, + { + "Name": "PutNewOwnById", + "VariantOpcodes": [ + 64, + 63, + 65 + ] + }, + { + "Name": "PutNewOwnNEById", + "VariantOpcodes": [ + 66, + 67 + ] + }, + { + "Name": "PutOwnByIndex", + "VariantOpcodes": [ + 68, + 69 + ] + }, + { + "Name": "DelById", + "VariantOpcodes": [ + 71, + 72 + ] + }, + { + "Name": "Call", + "VariantOpcodes": [ + 79, + 86 + ] + }, + { + "Name": "Construct", + "VariantOpcodes": [ + 80, + 87 + ] + }, + { + "Name": "CallDirect", + "VariantOpcodes": [ + 82, + 88 + ] + }, + { + "Name": "CallBuiltin", + "VariantOpcodes": [ + 89, + 90 + ] + }, + { + "Name": "CreateClosure", + "VariantOpcodes": [ + 100, + 101 + ] + }, + { + "Name": "CreateGeneratorClosure", + "VariantOpcodes": [ + 102, + 103 + ] + }, + { + "Name": "CreateAsyncClosure", + "VariantOpcodes": [ + 104, + 105 + ] + }, + { + "Name": "LoadParam", + "VariantOpcodes": [ + 108, + 109 + ] + }, + { + "Name": "LoadConstBigInt", + "VariantOpcodes": [ + 113, + 114 + ] + }, + { + "Name": "LoadConstString", + "VariantOpcodes": [ + 115, + 116 + ] + }, + { + "Name": "CreateGenerator", + "VariantOpcodes": [ + 137, + 138 + ] + }, + { + "Name": "Jmp", + "VariantOpcodes": [ + 142, + 143 + ] + }, + { + "Name": "JmpTrue", + "VariantOpcodes": [ + 144, + 145 + ] + }, + { + "Name": "JmpFalse", + "VariantOpcodes": [ + 146, + 147 + ] + }, + { + "Name": "JmpUndefined", + "VariantOpcodes": [ + 148, + 149 + ] + }, + { + "Name": "SaveGenerator", + "VariantOpcodes": [ + 150, + 151 + ] + }, + { + "Name": "JLess", + "VariantOpcodes": [ + 152, + 153 + ] + }, + { + "Name": "JNotLess", + "VariantOpcodes": [ + 154, + 155 + ] + }, + { + "Name": "JLessN", + "VariantOpcodes": [ + 156, + 157 + ] + }, + { + "Name": "JNotLessN", + "VariantOpcodes": [ + 158, + 159 + ] + }, + { + "Name": "JLessEqual", + "VariantOpcodes": [ + 160, + 161 + ] + }, + { + "Name": "JNotLessEqual", + "VariantOpcodes": [ + 162, + 163 + ] + }, + { + "Name": "JLessEqualN", + "VariantOpcodes": [ + 164, + 165 + ] + }, + { + "Name": "JNotLessEqualN", + "VariantOpcodes": [ + 166, + 167 + ] + }, + { + "Name": "JGreater", + "VariantOpcodes": [ + 168, + 169 + ] + }, + { + "Name": "JNotGreater", + "VariantOpcodes": [ + 170, + 171 + ] + }, + { + "Name": "JGreaterN", + "VariantOpcodes": [ + 172, + 173 + ] + }, + { + "Name": "JNotGreaterN", + "VariantOpcodes": [ + 174, + 175 + ] + }, + { + "Name": "JGreaterEqual", + "VariantOpcodes": [ + 176, + 177 + ] + }, + { + "Name": "JNotGreaterEqual", + "VariantOpcodes": [ + 178, + 179 + ] + }, + { + "Name": "JGreaterEqualN", + "VariantOpcodes": [ + 180, + 181 + ] + }, + { + "Name": "JNotGreaterEqualN", + "VariantOpcodes": [ + 182, + 183 + ] + }, + { + "Name": "JEqual", + "VariantOpcodes": [ + 184, + 185 + ] + }, + { + "Name": "JNotEqual", + "VariantOpcodes": [ + 186, + 187 + ] + }, + { + "Name": "JStrictEqual", + "VariantOpcodes": [ + 188, + 189 + ] + }, + { + "Name": "JStrictNotEqual", + "VariantOpcodes": [ + 190, + 191 + ] + } + ], + "GitCommitHash": "1c717488d1799f6153cf6d60c3556ab4ddd9dce6" +} \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode95.json b/hasmer/libhasmer/Resources/Bytecode95.json new file mode 100644 index 0000000..d55515b --- /dev/null +++ b/hasmer/libhasmer/Resources/Bytecode95.json @@ -0,0 +1,2451 @@ +{ + "Version": 95, + "Definitions": [ + { + "Opcode": 0, + "Name": "Unreachable", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 1, + "Name": "NewObjectWithBuffer", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt16", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 0 + }, + { + "Opcode": 2, + "Name": "NewObjectWithBufferLong", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt32", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 0 + }, + { + "Opcode": 3, + "Name": "NewObject", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 4, + "Name": "NewObjectWithParent", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 5, + "Name": "NewArrayWithBuffer", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 1 + }, + { + "Opcode": 6, + "Name": "NewArrayWithBufferLong", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 1 + }, + { + "Opcode": 7, + "Name": "NewArray", + "OperandTypes": [ + "Reg8", + "UInt16" + ], + "IsJump": false + }, + { + "Opcode": 8, + "Name": "Mov", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 2 + }, + { + "Opcode": 9, + "Name": "MovLong", + "OperandTypes": [ + "Reg32", + "Reg32" + ], + "IsJump": false, + "AbstractDefinition": 2 + }, + { + "Opcode": 10, + "Name": "Negate", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 11, + "Name": "Not", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 12, + "Name": "BitNot", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 13, + "Name": "TypeOf", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 14, + "Name": "Eq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 15, + "Name": "StrictEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 16, + "Name": "Neq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 17, + "Name": "StrictNeq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 18, + "Name": "Less", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 19, + "Name": "LessEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 20, + "Name": "Greater", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 21, + "Name": "GreaterEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 22, + "Name": "Add", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 23, + "Name": "AddN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 24, + "Name": "Mul", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 25, + "Name": "MulN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 26, + "Name": "Div", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 27, + "Name": "DivN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 28, + "Name": "Mod", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 29, + "Name": "Sub", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 30, + "Name": "SubN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 31, + "Name": "LShift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 32, + "Name": "RShift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 33, + "Name": "URshift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 34, + "Name": "BitAnd", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 35, + "Name": "BitXor", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 36, + "Name": "BitOr", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 37, + "Name": "Inc", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 38, + "Name": "Dec", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 39, + "Name": "InstanceOf", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 40, + "Name": "IsIn", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 41, + "Name": "GetEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 42, + "Name": "StoreToEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 3 + }, + { + "Opcode": 43, + "Name": "StoreToEnvironmentL", + "OperandTypes": [ + "Reg8", + "UInt16", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 3 + }, + { + "Opcode": 44, + "Name": "StoreNPToEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 4 + }, + { + "Opcode": 45, + "Name": "StoreNPToEnvironmentL", + "OperandTypes": [ + "Reg8", + "UInt16", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 4 + }, + { + "Opcode": 46, + "Name": "LoadFromEnvironment", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 5 + }, + { + "Opcode": 47, + "Name": "LoadFromEnvironmentL", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 5 + }, + { + "Opcode": 48, + "Name": "GetGlobalObject", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 49, + "Name": "GetNewTarget", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 50, + "Name": "CreateEnvironment", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 51, + "Name": "CreateInnerEnvironment", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false + }, + { + "Opcode": 52, + "Name": "DeclareGlobalVar", + "OperandTypes": [ + "UInt32S" + ], + "IsJump": false + }, + { + "Opcode": 53, + "Name": "ThrowIfHasRestrictedGlobalProperty", + "OperandTypes": [ + "UInt32S" + ], + "IsJump": false + }, + { + "Opcode": 54, + "Name": "GetByIdShort", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt8S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 55, + "Name": "GetById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 56, + "Name": "GetByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 57, + "Name": "TryGetById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 7 + }, + { + "Opcode": 58, + "Name": "TryGetByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 7 + }, + { + "Opcode": 59, + "Name": "PutById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 8 + }, + { + "Opcode": 60, + "Name": "PutByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 8 + }, + { + "Opcode": 61, + "Name": "TryPutById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 9 + }, + { + "Opcode": 62, + "Name": "TryPutByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 9 + }, + { + "Opcode": 63, + "Name": "PutNewOwnByIdShort", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 64, + "Name": "PutNewOwnById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 65, + "Name": "PutNewOwnByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 66, + "Name": "PutNewOwnNEById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 11 + }, + { + "Opcode": 67, + "Name": "PutNewOwnNEByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 11 + }, + { + "Opcode": 68, + "Name": "PutOwnByIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 12 + }, + { + "Opcode": 69, + "Name": "PutOwnByIndexL", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 12 + }, + { + "Opcode": 70, + "Name": "PutOwnByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 71, + "Name": "DelById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 13 + }, + { + "Opcode": 72, + "Name": "DelByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 13 + }, + { + "Opcode": 73, + "Name": "GetByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 74, + "Name": "PutByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 75, + "Name": "DelByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 76, + "Name": "PutOwnGetterSetterByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 77, + "Name": "GetPNameList", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 78, + "Name": "GetNextPName", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 79, + "Name": "Call", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 14 + }, + { + "Opcode": 80, + "Name": "Construct", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 15 + }, + { + "Opcode": 81, + "Name": "Call1", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 82, + "Name": "CallDirect", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 16 + }, + { + "Opcode": 83, + "Name": "Call2", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 84, + "Name": "Call3", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 85, + "Name": "Call4", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 86, + "Name": "CallLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 14 + }, + { + "Opcode": 87, + "Name": "ConstructLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 15 + }, + { + "Opcode": 88, + "Name": "CallDirectLongIndex", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 16 + }, + { + "Opcode": 89, + "Name": "CallBuiltin", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 17 + }, + { + "Opcode": 90, + "Name": "CallBuiltinLong", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 17 + }, + { + "Opcode": 91, + "Name": "GetBuiltinClosure", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 92, + "Name": "Ret", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 93, + "Name": "Catch", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 94, + "Name": "DirectEval", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 95, + "Name": "Throw", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 96, + "Name": "ThrowIfEmpty", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 97, + "Name": "Debugger", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 98, + "Name": "AsyncBreakCheck", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 99, + "Name": "ProfilePoint", + "OperandTypes": [ + "UInt16" + ], + "IsJump": false + }, + { + "Opcode": 100, + "Name": "CreateClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 18 + }, + { + "Opcode": 101, + "Name": "CreateClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 18 + }, + { + "Opcode": 102, + "Name": "CreateGeneratorClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 19 + }, + { + "Opcode": 103, + "Name": "CreateGeneratorClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 19 + }, + { + "Opcode": 104, + "Name": "CreateAsyncClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 20 + }, + { + "Opcode": 105, + "Name": "CreateAsyncClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 20 + }, + { + "Opcode": 106, + "Name": "CreateThis", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 107, + "Name": "SelectObject", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 108, + "Name": "LoadParam", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 21 + }, + { + "Opcode": 109, + "Name": "LoadParamLong", + "OperandTypes": [ + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 21 + }, + { + "Opcode": 110, + "Name": "LoadConstUInt8", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 111, + "Name": "LoadConstInt", + "OperandTypes": [ + "Reg8", + "Imm32" + ], + "IsJump": false + }, + { + "Opcode": 112, + "Name": "LoadConstDouble", + "OperandTypes": [ + "Reg8", + "Double" + ], + "IsJump": false + }, + { + "Opcode": 113, + "Name": "LoadConstBigInt", + "OperandTypes": [ + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 22 + }, + { + "Opcode": 114, + "Name": "LoadConstBigIntLongIndex", + "OperandTypes": [ + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 22 + }, + { + "Opcode": 115, + "Name": "LoadConstString", + "OperandTypes": [ + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 23 + }, + { + "Opcode": 116, + "Name": "LoadConstStringLongIndex", + "OperandTypes": [ + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 23 + }, + { + "Opcode": 117, + "Name": "LoadConstEmpty", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 118, + "Name": "LoadConstUndefined", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 119, + "Name": "LoadConstNull", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 120, + "Name": "LoadConstTrue", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 121, + "Name": "LoadConstFalse", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 122, + "Name": "LoadConstZero", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 123, + "Name": "CoerceThisNS", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 124, + "Name": "LoadThisNS", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 125, + "Name": "ToNumber", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 126, + "Name": "ToNumeric", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 127, + "Name": "ToInt32", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 128, + "Name": "AddEmptyString", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 129, + "Name": "GetArgumentsPropByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 130, + "Name": "GetArgumentsLength", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 131, + "Name": "ReifyArguments", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 132, + "Name": "CreateRegExp", + "OperandTypes": [ + "Reg8", + "UInt32S", + "UInt32S", + "UInt32" + ], + "IsJump": false + }, + { + "Opcode": 133, + "Name": "SwitchImm", + "OperandTypes": [ + "Reg8", + "UInt32", + "Addr32", + "UInt32", + "UInt32" + ], + "IsJump": false + }, + { + "Opcode": 134, + "Name": "StartGenerator", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 135, + "Name": "ResumeGenerator", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 136, + "Name": "CompleteGenerator", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 137, + "Name": "CreateGenerator", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 24 + }, + { + "Opcode": 138, + "Name": "CreateGeneratorLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 24 + }, + { + "Opcode": 139, + "Name": "IteratorBegin", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 140, + "Name": "IteratorNext", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 141, + "Name": "IteratorClose", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 142, + "Name": "Jmp", + "OperandTypes": [ + "Addr8" + ], + "IsJump": true, + "AbstractDefinition": 25 + }, + { + "Opcode": 143, + "Name": "JmpLong", + "OperandTypes": [ + "Addr32" + ], + "IsJump": true, + "AbstractDefinition": 25 + }, + { + "Opcode": 144, + "Name": "JmpTrue", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 26 + }, + { + "Opcode": 145, + "Name": "JmpTrueLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 26 + }, + { + "Opcode": 146, + "Name": "JmpFalse", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 27 + }, + { + "Opcode": 147, + "Name": "JmpFalseLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 27 + }, + { + "Opcode": 148, + "Name": "JmpUndefined", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 28 + }, + { + "Opcode": 149, + "Name": "JmpUndefinedLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 28 + }, + { + "Opcode": 150, + "Name": "SaveGenerator", + "OperandTypes": [ + "Addr8" + ], + "IsJump": true, + "AbstractDefinition": 29 + }, + { + "Opcode": 151, + "Name": "SaveGeneratorLong", + "OperandTypes": [ + "Addr32" + ], + "IsJump": true, + "AbstractDefinition": 29 + }, + { + "Opcode": 152, + "Name": "JLess", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 30 + }, + { + "Opcode": 153, + "Name": "JLessLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 30 + }, + { + "Opcode": 154, + "Name": "JNotLess", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 31 + }, + { + "Opcode": 155, + "Name": "JNotLessLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 31 + }, + { + "Opcode": 156, + "Name": "JLessN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 32 + }, + { + "Opcode": 157, + "Name": "JLessNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 32 + }, + { + "Opcode": 158, + "Name": "JNotLessN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 33 + }, + { + "Opcode": 159, + "Name": "JNotLessNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 33 + }, + { + "Opcode": 160, + "Name": "JLessEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 34 + }, + { + "Opcode": 161, + "Name": "JLessEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 34 + }, + { + "Opcode": 162, + "Name": "JNotLessEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 35 + }, + { + "Opcode": 163, + "Name": "JNotLessEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 35 + }, + { + "Opcode": 164, + "Name": "JLessEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 36 + }, + { + "Opcode": 165, + "Name": "JLessEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 36 + }, + { + "Opcode": 166, + "Name": "JNotLessEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 37 + }, + { + "Opcode": 167, + "Name": "JNotLessEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 37 + }, + { + "Opcode": 168, + "Name": "JGreater", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 38 + }, + { + "Opcode": 169, + "Name": "JGreaterLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 38 + }, + { + "Opcode": 170, + "Name": "JNotGreater", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 39 + }, + { + "Opcode": 171, + "Name": "JNotGreaterLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 39 + }, + { + "Opcode": 172, + "Name": "JGreaterN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 40 + }, + { + "Opcode": 173, + "Name": "JGreaterNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 40 + }, + { + "Opcode": 174, + "Name": "JNotGreaterN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 41 + }, + { + "Opcode": 175, + "Name": "JNotGreaterNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 41 + }, + { + "Opcode": 176, + "Name": "JGreaterEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 42 + }, + { + "Opcode": 177, + "Name": "JGreaterEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 42 + }, + { + "Opcode": 178, + "Name": "JNotGreaterEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 43 + }, + { + "Opcode": 179, + "Name": "JNotGreaterEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 43 + }, + { + "Opcode": 180, + "Name": "JGreaterEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 44 + }, + { + "Opcode": 181, + "Name": "JGreaterEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 44 + }, + { + "Opcode": 182, + "Name": "JNotGreaterEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 45 + }, + { + "Opcode": 183, + "Name": "JNotGreaterEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 45 + }, + { + "Opcode": 184, + "Name": "JEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 46 + }, + { + "Opcode": 185, + "Name": "JEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 46 + }, + { + "Opcode": 186, + "Name": "JNotEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 47 + }, + { + "Opcode": 187, + "Name": "JNotEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 47 + }, + { + "Opcode": 188, + "Name": "JStrictEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 48 + }, + { + "Opcode": 189, + "Name": "JStrictEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 48 + }, + { + "Opcode": 190, + "Name": "JStrictNotEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 49 + }, + { + "Opcode": 191, + "Name": "JStrictNotEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 49 + }, + { + "Opcode": 192, + "Name": "Add32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 193, + "Name": "Sub32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 194, + "Name": "Mul32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 195, + "Name": "Divi32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 196, + "Name": "Divu32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 197, + "Name": "Loadi8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 198, + "Name": "Loadu8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 199, + "Name": "Loadi16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 200, + "Name": "Loadu16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 201, + "Name": "Loadi32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 202, + "Name": "Loadu32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 203, + "Name": "Store8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 204, + "Name": "Store16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 205, + "Name": "Store32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + } + ], + "AbstractDefinitions": [ + { + "Name": "NewObjectWithBuffer", + "VariantOpcodes": [ + 1, + 2 + ] + }, + { + "Name": "NewArrayWithBuffer", + "VariantOpcodes": [ + 5, + 6 + ] + }, + { + "Name": "Mov", + "VariantOpcodes": [ + 8, + 9 + ] + }, + { + "Name": "StoreToEnvironment", + "VariantOpcodes": [ + 42, + 43 + ] + }, + { + "Name": "StoreNPToEnvironment", + "VariantOpcodes": [ + 44, + 45 + ] + }, + { + "Name": "LoadFromEnvironment", + "VariantOpcodes": [ + 46, + 47 + ] + }, + { + "Name": "GetById", + "VariantOpcodes": [ + 55, + 54, + 56 + ] + }, + { + "Name": "TryGetById", + "VariantOpcodes": [ + 57, + 58 + ] + }, + { + "Name": "PutById", + "VariantOpcodes": [ + 59, + 60 + ] + }, + { + "Name": "TryPutById", + "VariantOpcodes": [ + 61, + 62 + ] + }, + { + "Name": "PutNewOwnById", + "VariantOpcodes": [ + 64, + 63, + 65 + ] + }, + { + "Name": "PutNewOwnNEById", + "VariantOpcodes": [ + 66, + 67 + ] + }, + { + "Name": "PutOwnByIndex", + "VariantOpcodes": [ + 68, + 69 + ] + }, + { + "Name": "DelById", + "VariantOpcodes": [ + 71, + 72 + ] + }, + { + "Name": "Call", + "VariantOpcodes": [ + 79, + 86 + ] + }, + { + "Name": "Construct", + "VariantOpcodes": [ + 80, + 87 + ] + }, + { + "Name": "CallDirect", + "VariantOpcodes": [ + 82, + 88 + ] + }, + { + "Name": "CallBuiltin", + "VariantOpcodes": [ + 89, + 90 + ] + }, + { + "Name": "CreateClosure", + "VariantOpcodes": [ + 100, + 101 + ] + }, + { + "Name": "CreateGeneratorClosure", + "VariantOpcodes": [ + 102, + 103 + ] + }, + { + "Name": "CreateAsyncClosure", + "VariantOpcodes": [ + 104, + 105 + ] + }, + { + "Name": "LoadParam", + "VariantOpcodes": [ + 108, + 109 + ] + }, + { + "Name": "LoadConstBigInt", + "VariantOpcodes": [ + 113, + 114 + ] + }, + { + "Name": "LoadConstString", + "VariantOpcodes": [ + 115, + 116 + ] + }, + { + "Name": "CreateGenerator", + "VariantOpcodes": [ + 137, + 138 + ] + }, + { + "Name": "Jmp", + "VariantOpcodes": [ + 142, + 143 + ] + }, + { + "Name": "JmpTrue", + "VariantOpcodes": [ + 144, + 145 + ] + }, + { + "Name": "JmpFalse", + "VariantOpcodes": [ + 146, + 147 + ] + }, + { + "Name": "JmpUndefined", + "VariantOpcodes": [ + 148, + 149 + ] + }, + { + "Name": "SaveGenerator", + "VariantOpcodes": [ + 150, + 151 + ] + }, + { + "Name": "JLess", + "VariantOpcodes": [ + 152, + 153 + ] + }, + { + "Name": "JNotLess", + "VariantOpcodes": [ + 154, + 155 + ] + }, + { + "Name": "JLessN", + "VariantOpcodes": [ + 156, + 157 + ] + }, + { + "Name": "JNotLessN", + "VariantOpcodes": [ + 158, + 159 + ] + }, + { + "Name": "JLessEqual", + "VariantOpcodes": [ + 160, + 161 + ] + }, + { + "Name": "JNotLessEqual", + "VariantOpcodes": [ + 162, + 163 + ] + }, + { + "Name": "JLessEqualN", + "VariantOpcodes": [ + 164, + 165 + ] + }, + { + "Name": "JNotLessEqualN", + "VariantOpcodes": [ + 166, + 167 + ] + }, + { + "Name": "JGreater", + "VariantOpcodes": [ + 168, + 169 + ] + }, + { + "Name": "JNotGreater", + "VariantOpcodes": [ + 170, + 171 + ] + }, + { + "Name": "JGreaterN", + "VariantOpcodes": [ + 172, + 173 + ] + }, + { + "Name": "JNotGreaterN", + "VariantOpcodes": [ + 174, + 175 + ] + }, + { + "Name": "JGreaterEqual", + "VariantOpcodes": [ + 176, + 177 + ] + }, + { + "Name": "JNotGreaterEqual", + "VariantOpcodes": [ + 178, + 179 + ] + }, + { + "Name": "JGreaterEqualN", + "VariantOpcodes": [ + 180, + 181 + ] + }, + { + "Name": "JNotGreaterEqualN", + "VariantOpcodes": [ + 182, + 183 + ] + }, + { + "Name": "JEqual", + "VariantOpcodes": [ + 184, + 185 + ] + }, + { + "Name": "JNotEqual", + "VariantOpcodes": [ + 186, + 187 + ] + }, + { + "Name": "JStrictEqual", + "VariantOpcodes": [ + 188, + 189 + ] + }, + { + "Name": "JStrictNotEqual", + "VariantOpcodes": [ + 190, + 191 + ] + } + ], + "GitCommitHash": "f6b56d334467555b634f54bd18900d7ef8408eba" +} \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/Bytecode96.json b/hasmer/libhasmer/Resources/Bytecode96.json new file mode 100644 index 0000000..c77de9c --- /dev/null +++ b/hasmer/libhasmer/Resources/Bytecode96.json @@ -0,0 +1,2451 @@ +{ + "Version": 96, + "Definitions": [ + { + "Opcode": 0, + "Name": "Unreachable", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 1, + "Name": "NewObjectWithBuffer", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt16", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 0 + }, + { + "Opcode": 2, + "Name": "NewObjectWithBufferLong", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt32", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 0 + }, + { + "Opcode": 3, + "Name": "NewObject", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 4, + "Name": "NewObjectWithParent", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 5, + "Name": "NewArrayWithBuffer", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 1 + }, + { + "Opcode": 6, + "Name": "NewArrayWithBufferLong", + "OperandTypes": [ + "Reg8", + "UInt16", + "UInt16", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 1 + }, + { + "Opcode": 7, + "Name": "NewArray", + "OperandTypes": [ + "Reg8", + "UInt16" + ], + "IsJump": false + }, + { + "Opcode": 8, + "Name": "Mov", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 2 + }, + { + "Opcode": 9, + "Name": "MovLong", + "OperandTypes": [ + "Reg32", + "Reg32" + ], + "IsJump": false, + "AbstractDefinition": 2 + }, + { + "Opcode": 10, + "Name": "Negate", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 11, + "Name": "Not", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 12, + "Name": "BitNot", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 13, + "Name": "TypeOf", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 14, + "Name": "Eq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 15, + "Name": "StrictEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 16, + "Name": "Neq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 17, + "Name": "StrictNeq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 18, + "Name": "Less", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 19, + "Name": "LessEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 20, + "Name": "Greater", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 21, + "Name": "GreaterEq", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 22, + "Name": "Add", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 23, + "Name": "AddN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 24, + "Name": "Mul", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 25, + "Name": "MulN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 26, + "Name": "Div", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 27, + "Name": "DivN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 28, + "Name": "Mod", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 29, + "Name": "Sub", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 30, + "Name": "SubN", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 31, + "Name": "LShift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 32, + "Name": "RShift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 33, + "Name": "URshift", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 34, + "Name": "BitAnd", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 35, + "Name": "BitXor", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 36, + "Name": "BitOr", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 37, + "Name": "Inc", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 38, + "Name": "Dec", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 39, + "Name": "InstanceOf", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 40, + "Name": "IsIn", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 41, + "Name": "GetEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 42, + "Name": "StoreToEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 3 + }, + { + "Opcode": 43, + "Name": "StoreToEnvironmentL", + "OperandTypes": [ + "Reg8", + "UInt16", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 3 + }, + { + "Opcode": 44, + "Name": "StoreNPToEnvironment", + "OperandTypes": [ + "Reg8", + "UInt8", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 4 + }, + { + "Opcode": 45, + "Name": "StoreNPToEnvironmentL", + "OperandTypes": [ + "Reg8", + "UInt16", + "Reg8" + ], + "IsJump": false, + "AbstractDefinition": 4 + }, + { + "Opcode": 46, + "Name": "LoadFromEnvironment", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 5 + }, + { + "Opcode": 47, + "Name": "LoadFromEnvironmentL", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 5 + }, + { + "Opcode": 48, + "Name": "GetGlobalObject", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 49, + "Name": "GetNewTarget", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 50, + "Name": "CreateEnvironment", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 51, + "Name": "CreateInnerEnvironment", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false + }, + { + "Opcode": 52, + "Name": "DeclareGlobalVar", + "OperandTypes": [ + "UInt32S" + ], + "IsJump": false + }, + { + "Opcode": 53, + "Name": "ThrowIfHasRestrictedGlobalProperty", + "OperandTypes": [ + "UInt32S" + ], + "IsJump": false + }, + { + "Opcode": 54, + "Name": "GetByIdShort", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt8S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 55, + "Name": "GetById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 56, + "Name": "GetByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 6 + }, + { + "Opcode": 57, + "Name": "TryGetById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 7 + }, + { + "Opcode": 58, + "Name": "TryGetByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 7 + }, + { + "Opcode": 59, + "Name": "PutById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 8 + }, + { + "Opcode": 60, + "Name": "PutByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 8 + }, + { + "Opcode": 61, + "Name": "TryPutById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 9 + }, + { + "Opcode": 62, + "Name": "TryPutByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 9 + }, + { + "Opcode": 63, + "Name": "PutNewOwnByIdShort", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 64, + "Name": "PutNewOwnById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 65, + "Name": "PutNewOwnByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 10 + }, + { + "Opcode": 66, + "Name": "PutNewOwnNEById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 11 + }, + { + "Opcode": 67, + "Name": "PutNewOwnNEByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 11 + }, + { + "Opcode": 68, + "Name": "PutOwnByIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 12 + }, + { + "Opcode": 69, + "Name": "PutOwnByIndexL", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 12 + }, + { + "Opcode": 70, + "Name": "PutOwnByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 71, + "Name": "DelById", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 13 + }, + { + "Opcode": 72, + "Name": "DelByIdLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 13 + }, + { + "Opcode": 73, + "Name": "GetByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 74, + "Name": "PutByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 75, + "Name": "DelByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 76, + "Name": "PutOwnGetterSetterByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 77, + "Name": "GetPNameList", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 78, + "Name": "GetNextPName", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 79, + "Name": "Call", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 14 + }, + { + "Opcode": 80, + "Name": "Construct", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 15 + }, + { + "Opcode": 81, + "Name": "Call1", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 82, + "Name": "CallDirect", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 16 + }, + { + "Opcode": 83, + "Name": "Call2", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 84, + "Name": "Call3", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 85, + "Name": "Call4", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 86, + "Name": "CallLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 14 + }, + { + "Opcode": 87, + "Name": "ConstructLong", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 15 + }, + { + "Opcode": 88, + "Name": "CallDirectLongIndex", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 16 + }, + { + "Opcode": 89, + "Name": "CallBuiltin", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 17 + }, + { + "Opcode": 90, + "Name": "CallBuiltinLong", + "OperandTypes": [ + "Reg8", + "UInt8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 17 + }, + { + "Opcode": 91, + "Name": "GetBuiltinClosure", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 92, + "Name": "Ret", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 93, + "Name": "Catch", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 94, + "Name": "DirectEval", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 95, + "Name": "Throw", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 96, + "Name": "ThrowIfEmpty", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 97, + "Name": "Debugger", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 98, + "Name": "AsyncBreakCheck", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 99, + "Name": "ProfilePoint", + "OperandTypes": [ + "UInt16" + ], + "IsJump": false + }, + { + "Opcode": 100, + "Name": "CreateClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 18 + }, + { + "Opcode": 101, + "Name": "CreateClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 18 + }, + { + "Opcode": 102, + "Name": "CreateGeneratorClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 19 + }, + { + "Opcode": 103, + "Name": "CreateGeneratorClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 19 + }, + { + "Opcode": 104, + "Name": "CreateAsyncClosure", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 20 + }, + { + "Opcode": 105, + "Name": "CreateAsyncClosureLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 20 + }, + { + "Opcode": 106, + "Name": "CreateThis", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 107, + "Name": "SelectObject", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 108, + "Name": "LoadParam", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false, + "AbstractDefinition": 21 + }, + { + "Opcode": 109, + "Name": "LoadParamLong", + "OperandTypes": [ + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 21 + }, + { + "Opcode": 110, + "Name": "LoadConstUInt8", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 111, + "Name": "LoadConstInt", + "OperandTypes": [ + "Reg8", + "Imm32" + ], + "IsJump": false + }, + { + "Opcode": 112, + "Name": "LoadConstDouble", + "OperandTypes": [ + "Reg8", + "Double" + ], + "IsJump": false + }, + { + "Opcode": 113, + "Name": "LoadConstBigInt", + "OperandTypes": [ + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 22 + }, + { + "Opcode": 114, + "Name": "LoadConstBigIntLongIndex", + "OperandTypes": [ + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 22 + }, + { + "Opcode": 115, + "Name": "LoadConstString", + "OperandTypes": [ + "Reg8", + "UInt16S" + ], + "IsJump": false, + "AbstractDefinition": 23 + }, + { + "Opcode": 116, + "Name": "LoadConstStringLongIndex", + "OperandTypes": [ + "Reg8", + "UInt32S" + ], + "IsJump": false, + "AbstractDefinition": 23 + }, + { + "Opcode": 117, + "Name": "LoadConstEmpty", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 118, + "Name": "LoadConstUndefined", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 119, + "Name": "LoadConstNull", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 120, + "Name": "LoadConstTrue", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 121, + "Name": "LoadConstFalse", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 122, + "Name": "LoadConstZero", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 123, + "Name": "CoerceThisNS", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 124, + "Name": "LoadThisNS", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 125, + "Name": "ToNumber", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 126, + "Name": "ToNumeric", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 127, + "Name": "ToInt32", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 128, + "Name": "AddEmptyString", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 129, + "Name": "GetArgumentsPropByVal", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 130, + "Name": "GetArgumentsLength", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 131, + "Name": "ReifyArguments", + "OperandTypes": [ + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 132, + "Name": "CreateRegExp", + "OperandTypes": [ + "Reg8", + "UInt32S", + "UInt32S", + "UInt32" + ], + "IsJump": false + }, + { + "Opcode": 133, + "Name": "SwitchImm", + "OperandTypes": [ + "Reg8", + "UInt32", + "Addr32", + "UInt32", + "UInt32" + ], + "IsJump": false + }, + { + "Opcode": 134, + "Name": "StartGenerator", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 135, + "Name": "ResumeGenerator", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 136, + "Name": "CompleteGenerator", + "OperandTypes": [], + "IsJump": false + }, + { + "Opcode": 137, + "Name": "CreateGenerator", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt16" + ], + "IsJump": false, + "AbstractDefinition": 24 + }, + { + "Opcode": 138, + "Name": "CreateGeneratorLongIndex", + "OperandTypes": [ + "Reg8", + "Reg8", + "UInt32" + ], + "IsJump": false, + "AbstractDefinition": 24 + }, + { + "Opcode": 139, + "Name": "IteratorBegin", + "OperandTypes": [ + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 140, + "Name": "IteratorNext", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 141, + "Name": "IteratorClose", + "OperandTypes": [ + "Reg8", + "UInt8" + ], + "IsJump": false + }, + { + "Opcode": 142, + "Name": "Jmp", + "OperandTypes": [ + "Addr8" + ], + "IsJump": true, + "AbstractDefinition": 25 + }, + { + "Opcode": 143, + "Name": "JmpLong", + "OperandTypes": [ + "Addr32" + ], + "IsJump": true, + "AbstractDefinition": 25 + }, + { + "Opcode": 144, + "Name": "JmpTrue", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 26 + }, + { + "Opcode": 145, + "Name": "JmpTrueLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 26 + }, + { + "Opcode": 146, + "Name": "JmpFalse", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 27 + }, + { + "Opcode": 147, + "Name": "JmpFalseLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 27 + }, + { + "Opcode": 148, + "Name": "JmpUndefined", + "OperandTypes": [ + "Addr8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 28 + }, + { + "Opcode": 149, + "Name": "JmpUndefinedLong", + "OperandTypes": [ + "Addr32", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 28 + }, + { + "Opcode": 150, + "Name": "SaveGenerator", + "OperandTypes": [ + "Addr8" + ], + "IsJump": true, + "AbstractDefinition": 29 + }, + { + "Opcode": 151, + "Name": "SaveGeneratorLong", + "OperandTypes": [ + "Addr32" + ], + "IsJump": true, + "AbstractDefinition": 29 + }, + { + "Opcode": 152, + "Name": "JLess", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 30 + }, + { + "Opcode": 153, + "Name": "JLessLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 30 + }, + { + "Opcode": 154, + "Name": "JNotLess", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 31 + }, + { + "Opcode": 155, + "Name": "JNotLessLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 31 + }, + { + "Opcode": 156, + "Name": "JLessN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 32 + }, + { + "Opcode": 157, + "Name": "JLessNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 32 + }, + { + "Opcode": 158, + "Name": "JNotLessN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 33 + }, + { + "Opcode": 159, + "Name": "JNotLessNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 33 + }, + { + "Opcode": 160, + "Name": "JLessEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 34 + }, + { + "Opcode": 161, + "Name": "JLessEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 34 + }, + { + "Opcode": 162, + "Name": "JNotLessEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 35 + }, + { + "Opcode": 163, + "Name": "JNotLessEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 35 + }, + { + "Opcode": 164, + "Name": "JLessEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 36 + }, + { + "Opcode": 165, + "Name": "JLessEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 36 + }, + { + "Opcode": 166, + "Name": "JNotLessEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 37 + }, + { + "Opcode": 167, + "Name": "JNotLessEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 37 + }, + { + "Opcode": 168, + "Name": "JGreater", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 38 + }, + { + "Opcode": 169, + "Name": "JGreaterLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 38 + }, + { + "Opcode": 170, + "Name": "JNotGreater", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 39 + }, + { + "Opcode": 171, + "Name": "JNotGreaterLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 39 + }, + { + "Opcode": 172, + "Name": "JGreaterN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 40 + }, + { + "Opcode": 173, + "Name": "JGreaterNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 40 + }, + { + "Opcode": 174, + "Name": "JNotGreaterN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 41 + }, + { + "Opcode": 175, + "Name": "JNotGreaterNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 41 + }, + { + "Opcode": 176, + "Name": "JGreaterEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 42 + }, + { + "Opcode": 177, + "Name": "JGreaterEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 42 + }, + { + "Opcode": 178, + "Name": "JNotGreaterEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 43 + }, + { + "Opcode": 179, + "Name": "JNotGreaterEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 43 + }, + { + "Opcode": 180, + "Name": "JGreaterEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 44 + }, + { + "Opcode": 181, + "Name": "JGreaterEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 44 + }, + { + "Opcode": 182, + "Name": "JNotGreaterEqualN", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 45 + }, + { + "Opcode": 183, + "Name": "JNotGreaterEqualNLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 45 + }, + { + "Opcode": 184, + "Name": "JEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 46 + }, + { + "Opcode": 185, + "Name": "JEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 46 + }, + { + "Opcode": 186, + "Name": "JNotEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 47 + }, + { + "Opcode": 187, + "Name": "JNotEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 47 + }, + { + "Opcode": 188, + "Name": "JStrictEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 48 + }, + { + "Opcode": 189, + "Name": "JStrictEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 48 + }, + { + "Opcode": 190, + "Name": "JStrictNotEqual", + "OperandTypes": [ + "Addr8", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 49 + }, + { + "Opcode": 191, + "Name": "JStrictNotEqualLong", + "OperandTypes": [ + "Addr32", + "Reg8", + "Reg8" + ], + "IsJump": true, + "AbstractDefinition": 49 + }, + { + "Opcode": 192, + "Name": "Add32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 193, + "Name": "Sub32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 194, + "Name": "Mul32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 195, + "Name": "Divi32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 196, + "Name": "Divu32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 197, + "Name": "Loadi8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 198, + "Name": "Loadu8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 199, + "Name": "Loadi16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 200, + "Name": "Loadu16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 201, + "Name": "Loadi32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 202, + "Name": "Loadu32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 203, + "Name": "Store8", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 204, + "Name": "Store16", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + }, + { + "Opcode": 205, + "Name": "Store32", + "OperandTypes": [ + "Reg8", + "Reg8", + "Reg8" + ], + "IsJump": false + } + ], + "AbstractDefinitions": [ + { + "Name": "NewObjectWithBuffer", + "VariantOpcodes": [ + 1, + 2 + ] + }, + { + "Name": "NewArrayWithBuffer", + "VariantOpcodes": [ + 5, + 6 + ] + }, + { + "Name": "Mov", + "VariantOpcodes": [ + 8, + 9 + ] + }, + { + "Name": "StoreToEnvironment", + "VariantOpcodes": [ + 42, + 43 + ] + }, + { + "Name": "StoreNPToEnvironment", + "VariantOpcodes": [ + 44, + 45 + ] + }, + { + "Name": "LoadFromEnvironment", + "VariantOpcodes": [ + 46, + 47 + ] + }, + { + "Name": "GetById", + "VariantOpcodes": [ + 55, + 54, + 56 + ] + }, + { + "Name": "TryGetById", + "VariantOpcodes": [ + 57, + 58 + ] + }, + { + "Name": "PutById", + "VariantOpcodes": [ + 59, + 60 + ] + }, + { + "Name": "TryPutById", + "VariantOpcodes": [ + 61, + 62 + ] + }, + { + "Name": "PutNewOwnById", + "VariantOpcodes": [ + 64, + 63, + 65 + ] + }, + { + "Name": "PutNewOwnNEById", + "VariantOpcodes": [ + 66, + 67 + ] + }, + { + "Name": "PutOwnByIndex", + "VariantOpcodes": [ + 68, + 69 + ] + }, + { + "Name": "DelById", + "VariantOpcodes": [ + 71, + 72 + ] + }, + { + "Name": "Call", + "VariantOpcodes": [ + 79, + 86 + ] + }, + { + "Name": "Construct", + "VariantOpcodes": [ + 80, + 87 + ] + }, + { + "Name": "CallDirect", + "VariantOpcodes": [ + 82, + 88 + ] + }, + { + "Name": "CallBuiltin", + "VariantOpcodes": [ + 89, + 90 + ] + }, + { + "Name": "CreateClosure", + "VariantOpcodes": [ + 100, + 101 + ] + }, + { + "Name": "CreateGeneratorClosure", + "VariantOpcodes": [ + 102, + 103 + ] + }, + { + "Name": "CreateAsyncClosure", + "VariantOpcodes": [ + 104, + 105 + ] + }, + { + "Name": "LoadParam", + "VariantOpcodes": [ + 108, + 109 + ] + }, + { + "Name": "LoadConstBigInt", + "VariantOpcodes": [ + 113, + 114 + ] + }, + { + "Name": "LoadConstString", + "VariantOpcodes": [ + 115, + 116 + ] + }, + { + "Name": "CreateGenerator", + "VariantOpcodes": [ + 137, + 138 + ] + }, + { + "Name": "Jmp", + "VariantOpcodes": [ + 142, + 143 + ] + }, + { + "Name": "JmpTrue", + "VariantOpcodes": [ + 144, + 145 + ] + }, + { + "Name": "JmpFalse", + "VariantOpcodes": [ + 146, + 147 + ] + }, + { + "Name": "JmpUndefined", + "VariantOpcodes": [ + 148, + 149 + ] + }, + { + "Name": "SaveGenerator", + "VariantOpcodes": [ + 150, + 151 + ] + }, + { + "Name": "JLess", + "VariantOpcodes": [ + 152, + 153 + ] + }, + { + "Name": "JNotLess", + "VariantOpcodes": [ + 154, + 155 + ] + }, + { + "Name": "JLessN", + "VariantOpcodes": [ + 156, + 157 + ] + }, + { + "Name": "JNotLessN", + "VariantOpcodes": [ + 158, + 159 + ] + }, + { + "Name": "JLessEqual", + "VariantOpcodes": [ + 160, + 161 + ] + }, + { + "Name": "JNotLessEqual", + "VariantOpcodes": [ + 162, + 163 + ] + }, + { + "Name": "JLessEqualN", + "VariantOpcodes": [ + 164, + 165 + ] + }, + { + "Name": "JNotLessEqualN", + "VariantOpcodes": [ + 166, + 167 + ] + }, + { + "Name": "JGreater", + "VariantOpcodes": [ + 168, + 169 + ] + }, + { + "Name": "JNotGreater", + "VariantOpcodes": [ + 170, + 171 + ] + }, + { + "Name": "JGreaterN", + "VariantOpcodes": [ + 172, + 173 + ] + }, + { + "Name": "JNotGreaterN", + "VariantOpcodes": [ + 174, + 175 + ] + }, + { + "Name": "JGreaterEqual", + "VariantOpcodes": [ + 176, + 177 + ] + }, + { + "Name": "JNotGreaterEqual", + "VariantOpcodes": [ + 178, + 179 + ] + }, + { + "Name": "JGreaterEqualN", + "VariantOpcodes": [ + 180, + 181 + ] + }, + { + "Name": "JNotGreaterEqualN", + "VariantOpcodes": [ + 182, + 183 + ] + }, + { + "Name": "JEqual", + "VariantOpcodes": [ + 184, + 185 + ] + }, + { + "Name": "JNotEqual", + "VariantOpcodes": [ + 186, + 187 + ] + }, + { + "Name": "JStrictEqual", + "VariantOpcodes": [ + 188, + 189 + ] + }, + { + "Name": "JStrictNotEqual", + "VariantOpcodes": [ + 190, + 191 + ] + } + ], + "GitCommitHash": "2afc7b09ffc74201b4dd530d9414b48e61a5196f" +} \ No newline at end of file diff --git a/hasmer/libhasmer/Resources/HasmTokenDefinitions.json b/hasmer/libhasmer/Resources/HasmTokenDefinitions.json new file mode 100644 index 0000000..92287b3 --- /dev/null +++ b/hasmer/libhasmer/Resources/HasmTokenDefinitions.json @@ -0,0 +1,363 @@ +{ + "Header": [ + { + "Kind": "literal", + "Match": ".hasm" + }, + { + "Kind": "integer", + "Var": "version" + }, + { + "Kind": "enum", + "Match": [ + "exact", + "auto" + ], + "Var": "mode" + } + ], + "Register": [ + { + "Modifier": "contiguous" + }, + { + "Kind": "literal", + "Match": "r" + }, + { + "Kind": "integer", + "Var": "reg" + } + ], + "Label": [ + { + "Modifier": "contiguous" + }, + { + "Kind": "enum", + "Match": [ + "A", + "K", + "V", + "L" + ], + "Var": "kind" + }, + { + "Kind": "integer", + "Var": "index" + }, + { + "Optional": true, + "Match": [ + { + "Kind": "integer", + "Var": "value" + } + ], + "Var": "offset" + } + ], + "Literal": [ + { + "Kind": "or", + "Match": [ + { + "Kind": "string" + }, + { + "Kind": "integer" + }, + { + "Kind": "number" + }, + { + "Kind": "enum", + "Match": ["true", "false"] + }, + { + "Kind": "literal", + "Match": "null" + } + ] + } + ], + "Operand": [ + { + "Kind": "or", + "Match": [ + { + "Kind": "string" + }, + { + "Kind": "ident" + }, + { + "Kind": "integer" + }, + { + "Kind": "number" + }, + { + "Kind": "$Register" + }, + { + "Kind": "$Label" + } + ] + } + ], + "DatumElements": [ + { + "Kind": "literal", + "Match": "{" + }, + { + "Modifier": "move" + }, + { + "Repeated": true, + "Optional": true, + "Match": [ + { + "Kind": "$Literal", + "Var": "elements" + }, + { + "Kind": "literal", + "Match": "," + } + ] + }, + { + "Kind": "literal", + "Match": "}" + } + ], + "Datum": [ + { + "Kind": "literal", + "Match": ".data", + "Var": "decl" + }, + { + "Kind": "$Label", + "Var": "label" + }, + { + "Kind": "enum", + "Match": [ + "String", + "Integer", + "Number", + "Null", + "True", + "False" + ], + "Var": "kind" + }, + { + "Kind": "literal", + "Match": "[" + }, + { + "Optional": true, + "Kind": "integer", + "Var": "length" + }, + { + "Kind": "literal", + "Match": "]" + }, + { + "Optional": true, + "Kind": "$DatumElements", + "Var": "elements" + } + + ], + "DirectiveID": [ + { + "Kind": "literal", + "Match": ".id" + }, + { + "Kind": "integer", + "Var": "n" + } + ], + "DirectiveParams": [ + { + "Kind": "literal", + "Match": ".params" + }, + { + "Kind": "integer", + "Var": "n" + } + ], + "DirectiveRegisters": [ + { + "Kind": "literal", + "Match": ".registers" + }, + { + "Kind": "integer", + "Var": "n" + } + ], + "DirectiveSymbols": [ + { + "Kind": "literal", + "Match": ".symbols" + }, + { + "Kind": "integer", + "Var": "n" + } + ], + "DirectiveStrict": [ + { + "Kind": "literal", + "Match": ".strict" + } + ], + "DirectiveLabel": [ + { + "Kind": "literal", + "Match": ".label" + }, + { + "Kind": "$Label", + "Var": "label" + } + ], + "Directive": [ + { + "Kind": "$DirectiveID" + }, + { + "Kind": "$DirectiveParams" + }, + { + "Kind": "$DirectiveRegisters" + }, + { + "Kind": "$DirectiveSymbols" + }, + { + "Kind": "$DirectiveStrict" + }, + { + "Kind": "$DirectiveLabel" + } + ], + "Instruction": [ + { + "Kind": "word", + "Var": "name" + }, + { + "Repeated": true, + "Optional": true, + "Match": [ + { + "Kind": "$Operand", + "Var": "operands" + }, + { + "Kind": "literal", + "Match": "," + } + ] + }, + { + "Optional": true, + "Kind": "$Operand", + "Var": "operands" + } + ], + "Function": [ + { + "Kind": "literal", + "Match": ".start" + }, + { + "Kind": "enum", + "Match": ["Function", "Constructor", "NSFunction"], + "Var": "kind" + }, + { + "Kind": "ident", + "Var": "name" + }, + { + "Kind": "literal", + "Match": "(" + }, + { + "Repeated": true, + "Optional": true, + "Match": [ + { + "Kind": "$Register", + "Var": "params" + }, + { + "Kind": "literal", + "Match": "," + } + ] + }, + { + "Optional": true, + "Kind": "$Register", + "Var": "params" + }, + { + "Kind": "literal", + "Match": ")" + }, + { + "Repeated": true, + "Optional": true, + "Match": [ + { + "Kind": "or", + "Match": [ + { + "Kind": "$Directive" + }, + { + "Kind": "$Instruction" + } + ] + } + ], + "Var": "body" + }, + { + "Kind": "literal", + "Match": ".end" + } + ], + "Program": [ + { + "Kind": "$Header", + "Var": "header" + }, + { + "Optional": true, + "Repeated": true, + "Kind": "$Datum", + "Var": "data" + }, + { + "Optional": true, + "Repeated": true, + "Kind": "$Function", + "Var": "funcs" + } + ] +} \ No newline at end of file diff --git a/hasmer/libhasmer/libhasmer.csproj b/hasmer/libhasmer/libhasmer.csproj index f6539d7..b0cf737 100644 --- a/hasmer/libhasmer/libhasmer.csproj +++ b/hasmer/libhasmer/libhasmer.csproj @@ -2,7 +2,7 @@ Library - net5.0 + net8.0 Hasmer libhasmer @@ -55,7 +55,18 @@ + + + + + + + + + + + @@ -106,7 +117,18 @@ + + + + + + + + + + +