// Copyright (c) 2014 Rusty Wagner

//

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to

// deal in the Software without restriction, including without limitation the

// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

// sell copies of the Software, and to permit persons to whom the Software is

// furnished to do so, subject to the following conditions:

//

// The above copyright notice and this permission notice shall be included in

// all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS

// IN THE SOFTWARE.

#include "OutputGenerator.h"

#include <queue>

#include <stdarg.h>

#include <stdlib.h>

#include <stdio.h>

#include <ctype.h>

using namespace std;

#ifdef WIN32

int vasprintf(char** buf, const char* fmt, va_list ap)

{

int len;

*buf = NULL;

len = vsnprintf(NULL, 0, fmt, ap);

if (len < 0)

return len;

*buf = (char*)malloc(len + 1);

if (!*buf)

return -1;

if (vsnprintf(*buf, len + 1, fmt, ap) == len)

return len;

free(buf);

*buf = NULL;

return -1;

}

#endif

OutputGenerator::OutputGenerator(ParserState* parser): m_parser(parser), m_errors(0), m_indentLevel(0)

{

m_className = m_parser->GetArchName() + "CodeGen";

}

void OutputGenerator::Indent()

{

for (int i = 0; i < m_indentLevel; i++)

m_output += "\t";

}

void OutputGenerator::BeginBlock()

{

Indent();

m_output += "{\n";

m_indentLevel++;

}

void OutputGenerator::WriteLine(const char* fmt, ...)

{

Indent();

char* str;

va_list args;

va_start(args, fmt);

if (vasprintf(&str, fmt, args) < 0)

return;

va_end(args);

m_output += str;

free(str);

m_output += "\n";

}

void OutputGenerator::WriteUnindented(const char* fmt, ...)

{

char* str;

va_list args;

va_start(args, fmt);

if (vasprintf(&str, fmt, args) < 0)

return;

va_end(args);

m_output += str;

free(str);

m_output += "\n";

}

void OutputGenerator::EndBlock()

{

m_indentLevel--;

Indent();

m_output += "}\n";

}

void OutputGenerator::EndBlockSemicolon()

{

m_indentLevel--;

Indent();

m_output += "};\n";

}

void OutputGenerator::WriteEncodingParams(Encoding* encoding, const CodeToken& token, map<string, MatchVariableType>& vars)

{

map< string, Ref<CodeBlock> >::const_iterator operand;

bool first = true;

for (vector<EncodingField>::const_iterator i = encoding->GetFields().begin(); i != encoding->GetFields().end(); ++i)

{

switch (i->type)

{

case FIELD_NORMAL:

case FIELD_DEFAULT_VALUE:

operand = token.operands.find(i->name);

if (operand == token.operands.end())

{

map<string, MatchVariableType>::iterator var = vars.find(i->name);

if ((var == vars.end()) || ((var->second != MATCHVAR_IMM) && (var->second != MATCHVAR_REG)))

{

// No operand for this field

if (i->type == FIELD_DEFAULT_VALUE)

{

// Field has default value, use it

if (first)

{

first = false;

if (encoding->GetWidth() == 64)

WriteLine("0x%" PRIx64 "LL", i->value);

else

WriteLine("0x%" PRIx32, (uint32_t)i->value);

}

else

{

if (encoding->GetWidth() == 64)

WriteLine(", 0x%" PRIx64 "LL", i->value);

else

WriteLine(", 0x%" PRIx32, (uint32_t)i->value);

}

}

else

{

// Field not defined, use zero as a default

// TODO: Should use these fields to satisfy blacklist restrictions

if (first)

{

first = false;

WriteLine("0");

}

else

{

WriteLine(", 0");

}

}

}

else

{

// Register or immediate operand with this name is present, use the value of the operand automatically

if (first)

{

first = false;

WriteLine("%s", i->name.c_str());

}

else

{

WriteLine(", %s", i->name.c_str());

}

}

}

else

{

// Encoding field specified directly, output code block for the field

if (first)

first = false;

else

WriteLine(",");

WriteCodeBlock(operand->second, vars);

}

break;

default:

break;

}

}

}

void OutputGenerator::WriteCodeBlock(CodeBlock* code, map<string, MatchVariableType> vars, CodeBlockType codeType)

{

string result;

map<string, MatchVariableType>::iterator var;

Encoding* encoding;

char offsetStr[32];

bool first = true;

for (vector<CodeToken>::const_iterator i = code->GetTokens().begin(); i != code->GetTokens().end(); ++i)

{

if (first)

{

#ifndef WIN32

WriteLine("#line %d \"%s\"", i->line, i->fileName.c_str());

#endif

first = false;

}

switch (i->type)

{

case TOKEN_TEXT:

if (i->name == "{")

{

if (result.size() != 0)

{

WriteLine("%s", result.c_str());

result = "";

}

BeginBlock();

first = true;

}

else if (i->name == "}")

{

if (result.size() != 0)

{

WriteLine("%s", result.c_str());

result = "";

}

EndBlock();

first = true;

}

else if (i->name == ";")

{

result += ";";

WriteLine("%s", result.c_str());

result = "";

first = true;

}

else

{

result += i->name;

result += " ";

}

break;

case TOKEN_INSTR_START:

switch (codeType)

{

case CODEBLOCK_UPDATE:

result += "replacement.push_back(";

break;

case CODEBLOCK_ARCH:

result += "code.push_back(";

break;

default:

result += "out->AddInstruction(";

break;

}

result += m_parser->GetArchName();

result += "_";

result += i->name;

result += "(";

break;

case TOKEN_INSTR_END:

result += "))";

break;

case TOKEN_VAR:

var = vars.find(i->name);

if (var == vars.end())

{

result += "0 ";

fprintf(stderr, "%s:%d: error: undefined match variable '%s'\n", i->fileName.c_str(), i->line, i->name.c_str());

m_errors++;

break;

}

switch (var->second)

{

case MATCHVAR_IMM:

case MATCHVAR_REG:

case MATCHVAR_BLOCK:

case MATCHVAR_FUNC:

case MATCHVAR_INPUT:

result += i->name;

result += " ";

break;

case MATCHVAR_LARGE_REG:

result += "0 ";

fprintf(stderr, "%s:%d: error: large register variable '%s' used without :low or :high\n",

i->fileName.c_str(), i->line, i->name.c_str());

m_errors++;

break;

case MATCHVAR_STACK:

result += i->name + "_base, " + i->name + "_var, " + i->name + "_offset, " + i->name + "_scratch ";

break;

case MATCHVAR_GLOBAL:

result += "m_globalBaseReg, " + i->name + "_offset, " + i->name + "_scratch ";

break;

default:

result += "0 ";

fprintf(stderr, "%s:%d: error: invalid match variable '%s'\n", i->fileName.c_str(), i->line, i->name.c_str());

m_errors++;

break;

}

break;

case TOKEN_VAR_LOW:

var = vars.find(i->name);

if (var == vars.end())

{

result += "0 ";

fprintf(stderr, "%s:%d: error: undefined match variable '%s'\n", i->fileName.c_str(), i->line, i->name.c_str());

m_errors++;

break;

}

switch (var->second)

{

case MATCHVAR_LARGE_REG:

result += i->name + "_low ";

break;

default:

result += "0 ";

fprintf(stderr, "%s:%d: error: variable '%s' is not a large register\n", i->fileName.c_str(),

i->line, i->name.c_str());

m_errors++;

break;

}

break;

case TOKEN_VAR_HIGH:

var = vars.find(i->name);

if (var == vars.end())

{

result += "0 ";

fprintf(stderr, "%s:%d: error: undefined match variable '%s'\n", i->fileName.c_str(), i->line, i->name.c_str());

m_errors++;

break;

}

switch (var->second)

{

case MATCHVAR_LARGE_REG:

result += i->name + "_high ";

break;

default:

result += "0 ";

fprintf(stderr, "%s:%d: error: variable '%s' is not a large register\n", i->fileName.c_str(),

i->line, i->name.c_str());

m_errors++;

break;

}

break;

case TOKEN_VAR_INT:

var = vars.find(i->name);

if (var == vars.end())

{

result += "0 ";

fprintf(stderr, "%s:%d: error: undefined match variable '%s'\n", i->fileName.c_str(), i->line, i->name.c_str());

m_errors++;

break;

}

snprintf(offsetStr, sizeof(offsetStr), "%+d", i->offset);

switch (var->second)

{

case MATCHVAR_STACK:

result += i->name + "_base, " + i->name + "_var, " + i->name + "_offset" + offsetStr + ", " + i->name + "_scratch ";

break;

case MATCHVAR_GLOBAL:

result += "m_globalBaseReg, " + i->name + "_offset" + offsetStr + ", " + i->name + "_scratch ";

break;

default:

result += "0 ";

fprintf(stderr, "%s:%d: error: variable '%s' is not a stack or global variable\n", i->fileName.c_str(),

i->line, i->name.c_str());

m_errors++;

break;

}

break;

case TOKEN_VAR_BASE:

var = vars.find(i->name);

if (var == vars.end())

{

result += "0 ";

fprintf(stderr, "%s:%d: error: undefined match variable '%s'\n", i->fileName.c_str(), i->line, i->name.c_str());

m_errors++;

break;

}

switch (var->second)

{

case MATCHVAR_VAR_COMPONENTS:

result += i->name + "_base";

break;

default:

result += "0 ";

fprintf(stderr, "%s:%d: error: variable '%s' is not a stack or global variable\n", i->fileName.c_str(),

i->line, i->name.c_str());

m_errors++;

break;

}

break;

case TOKEN_VAR_OFFSET:

var = vars.find(i->name);

if (var == vars.end())

{

result += "0 ";

fprintf(stderr, "%s:%d: error: undefined match variable '%s'\n", i->fileName.c_str(), i->line, i->name.c_str());

m_errors++;

break;

}

switch (var->second)

{

case MATCHVAR_VAR_COMPONENTS:

result += i->name + "_offset";

break;

default:

result += "0 ";

fprintf(stderr, "%s:%d: error: variable '%s' is not a stack or global variable\n", i->fileName.c_str(),

i->line, i->name.c_str());

m_errors++;

break;

}

break;

case TOKEN_VAR_TEMP:

var = vars.find(i->name);

if (var == vars.end())

{

result += "0 ";

fprintf(stderr, "%s:%d: error: undefined match variable '%s'\n", i->fileName.c_str(), i->line, i->name.c_str());

m_errors++;

break;

}

switch (var->second)

{

case MATCHVAR_VAR_COMPONENTS:

result += i->name + "_temp";

break;

default:

result += "0 ";

fprintf(stderr, "%s:%d: error: variable '%s' is not a stack or global variable\n", i->fileName.c_str(),

i->line, i->name.c_str());

m_errors++;

break;

}

break;

case TOKEN_VAR_FUNCTION:

var = vars.find(i->name);

if (var == vars.end())

{

result += "0 ";

fprintf(stderr, "%s:%d: error: undefined match variable '%s'\n", i->fileName.c_str(), i->line, i->name.c_str());

m_errors++;

break;

}

switch (var->second)

{

case MATCHVAR_FUNC_AND_BLOCK:

result += i->name + "_func";

break;

default:

result += "NULL ";

fprintf(stderr, "%s:%d: error: variable '%s' is not a function\n", i->fileName.c_str(),

i->line, i->name.c_str());

m_errors++;

break;

}

break;

case TOKEN_VAR_BLOCK:

var = vars.find(i->name);

if (var == vars.end())

{

result += "0 ";

fprintf(stderr, "%s:%d: error: undefined match variable '%s'\n", i->fileName.c_str(), i->line, i->name.c_str());

m_errors++;

break;

}

switch (var->second)

{

case MATCHVAR_FUNC_AND_BLOCK:

result += i->name + "_block";

break;

default:

result += "NULL ";

fprintf(stderr, "%s:%d: error: variable '%s' is not a function\n", i->fileName.c_str(),

i->line, i->name.c_str());

m_errors++;

break;

}

break;

case TOKEN_INSTR_ENCODING:

encoding = m_parser->GetEncoding(i->name);

if (!encoding)

{

fprintf(stderr, "%s:%d: error: invalid encoding '%s'\n", i->fileName.c_str(), i->line, i->name.c_str());

m_errors++;

break;

}

switch (encoding->GetWidth())

{

case 8:

result += string("out->WriteUInt8(ENCODING_VALUE_") + i->name + "(";

break;

case 16:

result += string("out->WriteUInt16(ENCODING_VALUE_") + i->name + "(";

break;

case 32:

result += string("out->WriteUInt32(ENCODING_VALUE_") + i->name + "(";

break;

case 64:

result += string("out->WriteUInt64(ENCODING_VALUE_") + i->name + "(";

break;

default:

result += string("(ENCODING_VALUE_") + i->name + "(";

fprintf(stderr, "%s:%d: error: encoding '%s' has invalid size %d\n", i->fileName.c_str(),

i->line, i->name.c_str(), encoding->GetWidth());

m_errors++;

break;

}

WriteLine("%s", result.c_str());

result = "";

m_indentLevel++;

WriteEncodingParams(encoding, *i, vars);

WriteLine("))");

m_indentLevel--;

break;

case TOKEN_INSTR_ENCODING_VALUE:

encoding = m_parser->GetEncoding(i->name);

if (!encoding)

{

fprintf(stderr, "%s:%d: error: invalid encoding '%s'\n", i->fileName.c_str(), i->line, i->name.c_str());

m_errors++;

break;

}

result += string("ENCODING_VALUE_") + i->name + "(";

WriteLine("%s", result.c_str());

result = "";

m_indentLevel++;

WriteEncodingParams(encoding, *i, vars);

WriteLine(")");

m_indentLevel--;

break;

default:

fprintf(stderr, "%s:%d: error: invalid token in code block\n", i->fileName.c_str(), i->line);

m_errors++;

break;

}

}

WriteLine("%s", result.c_str());

}

string OutputGenerator::GenerateTypeMatchCode(const string& prefix, TreeNode* node)

{

vector<string> types;

if (node->GetSizeFlags() == 0)

return "false";

if (node->GetSizeFlags() == REG_MATCH_ALL)

return "";

if (node->GetSizeFlags() & REG_MATCH_U8)

types.push_back(prefix + "->GetType() == NODETYPE_U8");

if (node->GetSizeFlags() & REG_MATCH_S8)

types.push_back(prefix + "->GetType() == NODETYPE_S8");

if (node->GetSizeFlags() & REG_MATCH_U16)

types.push_back(prefix + "->GetType() == NODETYPE_U16");

if (node->GetSizeFlags() & REG_MATCH_S16)

types.push_back(prefix + "->GetType() == NODETYPE_S16");

if (node->GetSizeFlags() & REG_MATCH_U32)

types.push_back(prefix + "->GetType() == NODETYPE_U32");

if (node->GetSizeFlags() & REG_MATCH_S32)

types.push_back(prefix + "->GetType() == NODETYPE_S32");

if (node->GetSizeFlags() & REG_MATCH_U64)

types.push_back(prefix + "->GetType() == NODETYPE_U64");

if (node->GetSizeFlags() & REG_MATCH_S64)

types.push_back(prefix + "->GetType() == NODETYPE_S64");

if (node->GetSizeFlags() & REG_MATCH_U128)

types.push_back(prefix + "->GetType() == NODETYPE_U128");

if (node->GetSizeFlags() & REG_MATCH_S128)

types.push_back(prefix + "->GetType() == NODETYPE_S128");

if (node->GetSizeFlags() & REG_MATCH_F32)

types.push_back(prefix + "->GetType() == NODETYPE_F32");

if (node->GetSizeFlags() & REG_MATCH_F64)

types.push_back(prefix + "->GetType() == NODETYPE_F64");

string result = " && (";

for (vector<string>::iterator i = types.begin(); i != types.end(); ++i)

{

if (i != types.begin())

result += " || ";

result += string("(") + *i + ")";

}

result += ")";

return result;

}

string OutputGenerator::GenerateMatchForNode(Match* match, const string& prefix, TreeNode* node)

{

switch (node->GetClass())

{

case NODE_REG:

if (node->GetTypeName() == "BLOCK")

return prefix + "->GetClass() == NODE_BLOCK";

else if (node->GetTypeName() == "FUNCTION")

return prefix + "->GetClass() == NODE_FUNC";

else if (node->GetTypeName() == "IMM")

return string("(") + prefix + "->GetClass() == NODE_IMMED)" + GenerateTypeMatchCode(prefix, node);

else if (node->GetTypeName() == "STACKVAR")

return string("(") + prefix + "->GetClass() == NODE_STACK_VAR)" + GenerateTypeMatchCode(prefix, node);

else if (node->GetTypeName() == "GLOBALVAR")

return string("(") + prefix + "->GetClass() == NODE_GLOBAL_VAR)" + GenerateTypeMatchCode(prefix, node);

else if (node->GetTypeName() == "INPUT")

return prefix + "->GetClass() == NODE_INPUT";

else if (m_parser->IsImmediateClass(node->GetTypeName()))

{

return string("(") + prefix + "->GetClass() == NODE_IMMED) && (MatchImmClass_" +

node->GetTypeName() + "(" + prefix + "->GetImmediate()))" + GenerateTypeMatchCode(prefix, node);

}

else if (m_parser->IsRegisterClass(node->GetTypeName()))

{

RegisterClassDef* reg = m_parser->GetRegisterClass(node->GetTypeName());

if (!reg)

{

fprintf(stderr, "%s:%d: error: invalid register class '%s'\n", match->GetFileName().c_str(),

match->GetLineNumber(), node->GetTypeName().c_str());

m_errors++;

return "false";

}

if (reg->GetClassType() == REGCLASS_NORMAL)

{

return string("(") + prefix + "->GetClass() == NODE_REG) && " +

"IsRegisterClassCompatible(" + prefix + "->GetRegisterClass(), " + reg->GetRegisterClassName() + ") " +

GenerateTypeMatchCode(prefix, node);

}

else if (reg->GetClassType() == REGCLASS_LARGE)

{

return string("(") + prefix + "->GetClass() == NODE_LARGE_REG) && " +

"IsRegisterClassCompatible(" + prefix + "->GetRegisterClass(), " + reg->GetLowRegisterClassName() + ") && " +

"IsRegisterClassCompatible(" + prefix + "->GetHighRegisterClass(), " + reg->GetHighRegisterClassName() + ") " +

GenerateTypeMatchCode(prefix, node);

}

else

{

fprintf(stderr, "%s:%d: error: invalid use of temporary register class '%s'\n", match->GetFileName().c_str(),

match->GetLineNumber(), node->GetTypeName().c_str());

m_errors++;

return "false";

}

}

fprintf(stderr, "%s:%d: error: invalid match type '%s'\n", match->GetFileName().c_str(),

match->GetLineNumber(), node->GetTypeName().c_str());

m_errors++;

return "false";

case NODE_ASSIGN:

return prefix + "->GetClass() == NODE_ASSIGN";

case NODE_LOAD:

return string("(") + prefix + "->GetClass() == NODE_LOAD)" + GenerateTypeMatchCode(prefix, node);

case NODE_STORE:

return string("(") + prefix + "->GetClass() == NODE_STORE)" + GenerateTypeMatchCode(prefix, node);

case NODE_REF:

return prefix + "->GetClass() == NODE_REF";

case NODE_ADD:

return string("(") + prefix + "->GetClass() == NODE_ADD)" + GenerateTypeMatchCode(prefix, node);

case NODE_SUB:

return string("(") + prefix + "->GetClass() == NODE_SUB)" + GenerateTypeMatchCode(prefix, node);

case NODE_SMUL:

return string("(") + prefix + "->GetClass() == NODE_SMUL)" + GenerateTypeMatchCode(prefix, node);

case NODE_UMUL:

return string("(") + prefix + "->GetClass() == NODE_UMUL)" + GenerateTypeMatchCode(prefix, node);

case NODE_SDIV:

return string("(") + prefix + "->GetClass() == NODE_SDIV)" + GenerateTypeMatchCode(prefix, node);

case NODE_UDIV:

return string("(") + prefix + "->GetClass() == NODE_UDIV)" + GenerateTypeMatchCode(prefix, node);

case NODE_SMOD:

return string("(") + prefix + "->GetClass() == NODE_SMOD)" + GenerateTypeMatchCode(prefix, node);

case NODE_UMOD:

return string("(") + prefix + "->GetClass() == NODE_UMOD)" + GenerateTypeMatchCode(prefix, node);

case NODE_AND:

return string("(") + prefix + "->GetClass() == NODE_AND)" + GenerateTypeMatchCode(prefix, node);

case NODE_OR:

return string("(") + prefix + "->GetClass() == NODE_OR)" + GenerateTypeMatchCode(prefix, node);

case NODE_XOR:

return string("(") + prefix + "->GetClass() == NODE_XOR)" + GenerateTypeMatchCode(prefix, node);

case NODE_SHL:

return string("(") + prefix + "->GetClass() == NODE_SHL)" + GenerateTypeMatchCode(prefix, node);

case NODE_SHR:

return string("(") + prefix + "->GetClass() == NODE_SHR)" + GenerateTypeMatchCode(prefix, node);

case NODE_SAR:

return string("(") + prefix + "->GetClass() == NODE_SAR)" + GenerateTypeMatchCode(prefix, node);

case NODE_NEG:

return string("(") + prefix + "->GetClass() == NODE_NEG)" + GenerateTypeMatchCode(prefix, node);

case NODE_NOT:

return string("(") + prefix + "->GetClass() == NODE_NOT)" + GenerateTypeMatchCode(prefix, node);

case NODE_IFTRUE:

return prefix + "->GetClass() == NODE_IFTRUE";

case NODE_IFSLT:

return prefix + "->GetClass() == NODE_IFSLT";

case NODE_IFULT:

return prefix + "->GetClass() == NODE_IFULT";

case NODE_IFSLE:

return prefix + "->GetClass() == NODE_IFSLE";

case NODE_IFULE:

return prefix + "->GetClass() == NODE_IFULE";

case NODE_IFE:

return prefix + "->GetClass() == NODE_IFE";

case NODE_GOTO:

return prefix + "->GetClass() == NODE_GOTO";

case NODE_CALL:

return prefix + "->GetClass() == NODE_CALL";

case NODE_CALLVOID:

return prefix + "->GetClass() == NODE_CALLVOID";

case NODE_SYSCALL:

return prefix + "->GetClass() == NODE_SYSCALL";

case NODE_SYSCALLVOID:

return prefix + "->GetClass() == NODE_SYSCALLVOID";

case NODE_SCONVERT:

return string("(") + prefix + "->GetClass() == NODE_SCONVERT)" + GenerateTypeMatchCode(prefix, node);

case NODE_UCONVERT:

return string("(") + prefix + "->GetClass() == NODE_UCONVERT)" + GenerateTypeMatchCode(prefix, node);

case NODE_RETURN:

return prefix + "->GetClass() == NODE_RETURN";

case NODE_RETURNVOID:

return prefix + "->GetClass() == NODE_RETURNVOID";

case NODE_ALLOCA:

return prefix + "->GetClass() == NODE_ALLOCA";

case NODE_MEMCPY:

return prefix + "->GetClass() == NODE_MEMCPY";

case NODE_MEMSET:

return prefix + "->GetClass() == NODE_MEMSET";

case NODE_STRLEN:

return string("(") + prefix + "->GetClass() == NODE_STRLEN)" + GenerateTypeMatchCode(prefix, node);

case NODE_RDTSC:

return prefix + "->GetClass() == NODE_RDTSC";

case NODE_RDTSC_LOW:

return prefix + "->GetClass() == NODE_RDTSC_LOW";

case NODE_RDTSC_HIGH:

return prefix + "->GetClass() == NODE_RDTSC_HIGH";

case NODE_PEB:

return prefix + "->GetClass() == NODE_PEB";

case NODE_TEB:

return prefix + "->GetClass() == NODE_TEB";

case NODE_VARARG:

return prefix + "->GetClass() == NODE_VARARG";

case NODE_BYTESWAP:

return string("(") + prefix + "->GetClass() == NODE_BYTESWAP)" + GenerateTypeMatchCode(prefix, node);

case NODE_BREAKPOINT:

return prefix + "->GetClass() == NODE_BREAKPOINT";

case NODE_POW:

return string("(") + prefix + "->GetClass() == NODE_POW)" + GenerateTypeMatchCode(prefix, node);

case NODE_FLOOR:

return string("(") + prefix + "->GetClass() == NODE_FLOOR)" + GenerateTypeMatchCode(prefix, node);

case NODE_CEIL:

return string("(") + prefix + "->GetClass() == NODE_CEIL)" + GenerateTypeMatchCode(prefix, node);

case NODE_SQRT:

return string("(") + prefix + "->GetClass() == NODE_SQRT)" + GenerateTypeMatchCode(prefix, node);

case NODE_SIN:

return string("(") + prefix + "->GetClass() == NODE_SIN)" + GenerateTypeMatchCode(prefix, node);

case NODE_COS:

return string("(") + prefix + "->GetClass() == NODE_COS)" + GenerateTypeMatchCode(prefix, node);

case NODE_TAN:

return string("(") + prefix + "->GetClass() == NODE_TAN)" + GenerateTypeMatchCode(prefix, node);

case NODE_ASIN:

return string("(") + prefix + "->GetClass() == NODE_ASIN)" + GenerateTypeMatchCode(prefix, node);

case NODE_ACOS:

return string("(") + prefix + "->GetClass() == NODE_ACOS)" + GenerateTypeMatchCode(prefix, node);

case NODE_ATAN:

return string("(") + prefix + "->GetClass() == NODE_ATAN)" + GenerateTypeMatchCode(prefix, node);

case NODE_PUSH:

return string("(") + prefix + "->GetClass() == NODE_PUSH)" + GenerateTypeMatchCode(prefix, node);

default:

fprintf(stderr, "%s:%d: error: invalid node type in match\n", match->GetFileName().c_str(), match->GetLineNumber());

m_errors++;

return "false";

}

}

void OutputGenerator::GenerateMatchCode(Match* match)

{

bool first = true;

queue<MatchNodeInfo> nodes;

MatchNodeInfo info;

info.prefix = "node";

info.node = match->GetMatch();

nodes.push(info);

while (nodes.size() != 0)

{

info = nodes.front();

nodes.pop();

string code = GenerateMatchForNode(match, info.prefix, info.node);

if (first)

code = string("if ((") + code + string(")");

else

code = string("\t&& (") + code + string(")");

first = false;

WriteLine("%s", code.c_str());

for (size_t i = 0; i < info.node->GetChildNodes().size(); i++)

{

MatchNodeInfo child;

char indexStr[32];

snprintf(indexStr, sizeof(indexStr), "%d", (int)i);

child.prefix = string("(*") + info.prefix + ")[" + indexStr + "]";

child.node = info.node->GetChildNodes()[i];

nodes.push(child);

}

}

WriteLine("\t)");

BeginBlock();

// TODO: Implement override of default cost calculation, and use actual instruction sizes

// on architectures with variable width instructions

size_t cost = 0;

for (vector<CodeToken>::const_iterator i = match->GetCode()->GetTokens().begin();

i != match->GetCode()->GetTokens().end(); ++i)

{

if (i->type == TOKEN_INSTR_START)

cost++;

}

WriteLine("MatchState nextState;");

WriteLine("nextState = state;");

WriteLine("nextState.cost += %d;", (int)cost);

WriteLine("vector<uint32_t> temps;");

for (vector< Ref<TreeNode> >::const_iterator i = match->GetTemps().begin(); i != match->GetTemps().end(); ++i)

{

RegisterClassDef* reg = m_parser->GetRegisterClass((*i)->GetTypeName());

if (!reg)

{

fprintf(stderr, "%s:%d: error: invalid register class '%s' for '%s'\n", match->GetFileName().c_str(),

match->GetLineNumber(), (*i)->GetTypeName().c_str(), (*i)->GetName().c_str());

m_errors++;

}

else if ((reg->GetClassType() == REGCLASS_NORMAL) || (reg->GetClassType() == REGCLASS_TEMP))

{

WriteLine("temps.push_back(AddRegisterForMatch(nextState, %s));", reg->GetRegisterClassName().c_str());

}

else if (reg->GetClassType() == REGCLASS_LARGE)

{

WriteLine("temps.push_back(AddRegisterForMatch(nextState, %s));", reg->GetLowRegisterClassName().c_str());

WriteLine("temps.push_back(AddRegisterForMatch(nextState, %s));", reg->GetHighRegisterClassName().c_str());

}

else

{

fprintf(stderr, "%s:%d: error: invalid register class '%s' for '%s'\n", match->GetFileName().c_str(),

match->GetLineNumber(), (*i)->GetTypeName().c_str(), (*i)->GetName().c_str());

m_errors++;

}

}

if (!match->GetResult())

WriteLine("AddMatchNoResult(state, nextState, node, matches, %d, temps);", (int)match->GetIndex());

else

{

RegisterClassDef* reg = m_parser->GetRegisterClass(match->GetResult()->GetTypeName());

if (!reg)

{

fprintf(stderr, "%s:%d: error: invalid register class '%s' in result\n", match->GetFileName().c_str(),

match->GetLineNumber(), match->GetResult()->GetTypeName().c_str());

m_errors++;

}

else if (reg->GetClassType() == REGCLASS_NORMAL)

{

WriteLine("AddMatchNormalRegisterResult(state, nextState, node, possible, %d, %s, temps);", (int)match->GetIndex(),

reg->GetRegisterClassName().c_str());

}

else if (reg->GetClassType() == REGCLASS_LARGE)

{

WriteLine("AddMatchLargeRegisterResult(state, nextState, node, possible, %d, %s, %s, temps);", (int)match->GetIndex(),

reg->GetLowRegisterClassName().c_str(), reg->GetHighRegisterClassName().c_str());

}

else

{

fprintf(stderr, "%s:%d: internal error: temporary register class '%s' not fully expanded\n",

match->GetFileName().c_str(), match->GetLineNumber(), match->GetResult()->GetTypeName().c_str());

m_errors++;

}

}

EndBlock();

}

void OutputGenerator::GenerateOutputCode(Match* match)

{

queue<MatchNodeInfo> nodes;

MatchNodeInfo info;

info.prefix = "_match";

info.node = match->GetMatch();

nodes.push(info);

map<string, MatchVariableType> varTypes;

while (nodes.size() != 0)

{

info = nodes.front();

nodes.pop();

if (info.node->GetClass() == NODE_REG)

{

if (m_parser->IsImmediateClass(info.node->GetTypeName()))

{

WriteLine("int64_t %s = %s->GetImmediate();", info.node->GetName().c_str(), info.prefix.c_str());

WriteLine("(void)%s;", info.node->GetName().c_str());

varTypes[info.node->GetName()] = MATCHVAR_IMM;

}

else if (info.node->GetTypeName() == "IMM")

{

WriteLine("int64_t %s = %s->GetImmediate();", info.node->GetName().c_str(), info.prefix.c_str());

WriteLine("(void)%s;", info.node->GetName().c_str());

varTypes[info.node->GetName()] = MATCHVAR_IMM;

}

else if (info.node->GetTypeName() == "STACKVAR")

{

WriteLine("uint32_t %s_base = %s->GetRegister();", info.node->GetName().c_str(), info.prefix.c_str());

WriteLine("int32_t %s_var = %s->GetVariable();", info.node->GetName().c_str(), info.prefix.c_str());

WriteLine("int64_t %s_offset = %s->GetImmediate();", info.node->GetName().c_str(), info.prefix.c_str());

WriteLine("uint32_t %s_scratch = m_symFunc->AddRegister(%s);", info.node->GetName().c_str(),

m_parser->GetDefaultRegisterClass()->GetRegisterClassName().c_str());

WriteLine("(void)%s_base; (void)%s_var; (void)%s_offset; (void)%s_scratch;",

info.node->GetName().c_str(), info.node->GetName().c_str(), info.node->GetName().c_str(),

info.node->GetName().c_str());

varTypes[info.node->GetName()] = MATCHVAR_STACK;

}

else if (info.node->GetTypeName() == "GLOBALVAR")

{

WriteLine("int64_t %s_offset = %s->GetImmediate();", info.node->GetName().c_str(), info.prefix.c_str());

WriteLine("uint32_t %s_scratch = m_symFunc->AddRegister(%s);", info.node->GetName().c_str(),

m_parser->GetDefaultRegisterClass()->GetRegisterClassName().c_str());

WriteLine("(void)%s_offset; (void)%s_scratch;", info.node->GetName().c_str(), info.node->GetName().c_str());

varTypes[info.node->GetName()] = MATCHVAR_GLOBAL;

}

else if (info.node->GetTypeName() == "BLOCK")

{

WriteLine("TreeBlock* %s = %s->GetBlock();", info.node->GetName().c_str(), info.prefix.c_str());

WriteLine("(void)%s;", info.node->GetName().c_str());

varTypes[info.node->GetName()] = MATCHVAR_BLOCK;

}

else if (info.node->GetTypeName() == "FUNCTION")

{

WriteLine("Function* %s = %s->GetFunction();", info.node->GetName().c_str(), info.prefix.c_str());

WriteLine("(void)%s;", info.node->GetName().c_str());

varTypes[info.node->GetName()] = MATCHVAR_FUNC;

}

else if (info.node->GetTypeName() == "INPUT")

{

WriteLine("vector<uint32_t> %s;", info.node->GetName().c_str());

WriteLine("for (vector< Ref<TreeNode> >::const_iterator _i = %s->GetChildNodes().begin();", info.prefix.c_str());

WriteLine("\t_i != %s->GetChildNodes().end(); ++_i)", info.prefix.c_str());

BeginBlock();

WriteLine("%s.push_back((*_i)->GetRegister());", info.node->GetName().c_str());

EndBlock();

varTypes[info.node->GetName()] = MATCHVAR_INPUT;

}

else

{

RegisterClassDef* reg = m_parser->GetRegisterClass(info.node->GetTypeName());

if (!reg)

{

fprintf(stderr, "%s:%d: error: invalid register class '%s' for '%s'\n", match->GetFileName().c_str(),

match->GetLineNumber(), info.node->GetTypeName().c_str(), info.node->GetName().c_str());

m_errors++;

}

else if (reg->GetClassType() == REGCLASS_NORMAL)

{

WriteLine("uint32_t %s = %s->GetRegister();", info.node->GetName().c_str(), info.prefix.c_str());

WriteLine("(void)%s;", info.node->GetName().c_str());

varTypes[info.node->GetName()] = MATCHVAR_REG;

}

else if (reg->GetClassType() == REGCLASS_LARGE)

{

WriteLine("uint32_t %s_low = %s->GetRegister();", info.node->GetName().c_str(), info.prefix.c_str());

WriteLine("uint32_t %s_high = %s->GetHighRegister();", info.node->GetName().c_str(), info.prefix.c_str());

WriteLine("(void)%s_low; (void)%s_high;", info.node->GetName().c_str(), info.node->GetName().c_str());

varTypes[info.node->GetName()] = MATCHVAR_LARGE_REG;

}

else