Mirror/zeek
1
0
Fork 0
mirror of https://github.com/zeek/zeek.git synced 2025-10-01 22:28:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1
zeek/tools/gen-zam/Gen-ZAM.cc
Tim Wojtulewicz 7499234d42 gen-zam: Move source files up a directory
2025-08-28 12:14:09 -07:00

2473 lines
72 KiB
C++
Raw Blame History

// See the file "COPYING" in the main distribution directory for copyright.
#include "Gen-ZAM.h"
#include <cctype>
#include <cstring>
#include <map>
#include <regex>
#include <set>
using namespace std;
// Helper functions to convert dashes to underscores or vice versa.
static char dash_to_under(char c) { return c == '-' ? '_' : c; }
static char under_to_dash(char c) { return c == '_' ? '-' : c; }
// Structure for binding together Zeek script types, internal names Gen-ZAM
// uses to track them, mnemonics for referring to them in instruction names,
// the corresponding Val accessor, and whether the type requires memory
// management.
struct TypeInfo {
string tag;
ZAM_Type zt;
string suffix;
string accessor; // doesn't include "As" prefix or "()" suffix
bool is_managed;
};
static vector<TypeInfo> ZAM_type_info = {
{"TYPE_ADDR", ZAM_TYPE_ADDR, "A", "Addr", true}, {"TYPE_ANY", ZAM_TYPE_ANY, "a", "Any", true},
{"TYPE_COUNT", ZAM_TYPE_UINT, "U", "Count", false}, {"TYPE_DOUBLE", ZAM_TYPE_DOUBLE, "D", "Double", false},
{"TYPE_FILE", ZAM_TYPE_FILE, "f", "File", true}, {"TYPE_FUNC", ZAM_TYPE_FUNC, "F", "Func", true},
{"TYPE_INT", ZAM_TYPE_INT, "I", "Int", false}, {"TYPE_LIST", ZAM_TYPE_LIST, "L", "List", true},
{"TYPE_OPAQUE", ZAM_TYPE_OPAQUE, "O", "Opaque", true}, {"TYPE_PATTERN", ZAM_TYPE_PATTERN, "P", "Pattern", true},
{"TYPE_RECORD", ZAM_TYPE_RECORD, "R", "Record", true}, {"TYPE_STRING", ZAM_TYPE_STRING, "S", "String", true},
{"TYPE_SUBNET", ZAM_TYPE_SUBNET, "N", "SubNet", true}, {"TYPE_TABLE", ZAM_TYPE_TABLE, "T", "Table", true},
{"TYPE_TYPE", ZAM_TYPE_TYPE, "t", "Type", true}, {"TYPE_VECTOR", ZAM_TYPE_VECTOR, "V", "Vector", true},
};
// Maps op-type mnemonics to the corresponding internal value used by Gen-ZAM.
static unordered_map<char, ZAM_Type> type_names = {
{'*', ZAM_TYPE_DEFAULT}, {'A', ZAM_TYPE_ADDR}, {'a', ZAM_TYPE_ANY}, {'D', ZAM_TYPE_DOUBLE},
{'f', ZAM_TYPE_FILE}, {'F', ZAM_TYPE_FUNC}, {'I', ZAM_TYPE_INT}, {'L', ZAM_TYPE_LIST},
{'X', ZAM_TYPE_NONE}, {'O', ZAM_TYPE_OPAQUE}, {'P', ZAM_TYPE_PATTERN}, {'R', ZAM_TYPE_RECORD},
{'S', ZAM_TYPE_STRING}, {'N', ZAM_TYPE_SUBNET}, {'T', ZAM_TYPE_TABLE}, {'t', ZAM_TYPE_TYPE},
{'U', ZAM_TYPE_UINT}, {'V', ZAM_TYPE_VECTOR},
};
// Inverse of the above.
static unordered_map<ZAM_Type, char> expr_name_types;
// Given a ZAM_Type, returns the corresponding TypeInfo.
const TypeInfo& find_type_info(ZAM_Type zt) {
assert(zt != ZAM_TYPE_NONE);
auto pred = [zt](const TypeInfo& ti) -> bool { return ti.zt == zt; };
auto ti = std::find_if(ZAM_type_info.begin(), ZAM_type_info.end(), pred);
assert(ti != ZAM_type_info.end());
return *ti;
}
// Given a ZAM_Type, return its ZVal accessor. Takes into account
// some naming inconsistencies between ZVal's and Val's.
string find_type_accessor(ZAM_Type zt, bool is_lhs) {
if ( zt == ZAM_TYPE_NONE )
return "";
string acc = string("As") + find_type_info(zt).accessor;
if ( is_lhs )
acc += "Ref";
return acc + "()";
}
// Maps ZAM operand types to pairs of (1) the C++ name used to declare
// the operand in a method declaration, and (2) the variable name to
// use for the operand.
unordered_map<ZAM_OperandClass, pair<const char*, const char*>> ArgsManager::oc_to_args = {
{ZAM_OC_AUX, {"OpaqueVals*", "v"}},
{ZAM_OC_CONSTANT, {"const ConstExpr*", "c"}},
{ZAM_OC_EVENT_HANDLER, {"EventHandler*", "h"}},
{ZAM_OC_INT, {"int", "i"}},
{ZAM_OC_BRANCH, {"int", "i"}},
{ZAM_OC_GLOBAL, {"int", "i"}},
{ZAM_OC_STEP_ITER, {"int", "i"}},
{ZAM_OC_TBL_ITER, {"int", "i"}},
{ZAM_OC_LIST, {"const ListExpr*", "l"}},
{ZAM_OC_RECORD_FIELD, {"const NameExpr*", "n"}},
{ZAM_OC_VAR, {"const NameExpr*", "n"}},
// The following gets special treatment.
{ZAM_OC_ASSIGN_FIELD, {"const NameExpr*", "n"}},
};
// The different operand classes that are represented as "raw" integers
// (meaning the slot value is used directly, rather than indexing the frame).
static const set<ZAM_OperandClass> raw_int_oc({ZAM_OC_BRANCH, ZAM_OC_GLOBAL, ZAM_OC_INT, ZAM_OC_STEP_ITER,
ZAM_OC_TBL_ITER});
ArgsManager::ArgsManager(const OCVec& oc_orig, ZAM_InstClass zc) {
auto oc = oc_orig;
if ( zc == ZIC_COND )
// Remove the final entry corresponding to the branch, as
// we'll automatically generate it subsequently.
oc.pop_back();
int n = 0;
bool add_field = false;
for ( const auto& ot_i : oc ) {
if ( ot_i == ZAM_OC_NONE ) { // it had better be the only operand type
assert(oc.size() == 1);
break;
}
++n;
// Start off the argument info using the usual case
// of (1) same method parameter name as GenInst argument,
// and (2) not requiring a record field.
auto& arg_i = oc_to_args[ot_i];
Arg arg = {arg_i.second, arg_i.first, arg_i.second};
if ( ot_i == ZAM_OC_ASSIGN_FIELD ) {
if ( n == 1 ) { // special-case the parameter
arg.decl_name = "flhs";
arg.decl_type = "const FieldLHSAssignExpr*";
}
}
args.emplace_back(std::move(arg));
}
Differentiate();
}
void ArgsManager::Differentiate() {
// First, figure out which parameter names are used how often.
map<string, int> name_count; // how often the name appears
map<string, int> usage_count; // how often the name's been used so far
for ( auto& arg : args ) {
auto& name = arg.param_name;
if ( name_count.count(name) == 0 ) {
name_count[name] = 1;
usage_count[name] = 0;
}
else
++name_count[name];
}
// Now for each name - whether appearing as an argument or in
// a declaration - if it's used more than once, then differentiate
// it. Note, some names only appear multiple times as arguments
// when invoking methods, but not in the declarations of the methods
// themselves.
for ( auto& arg : args ) {
auto& decl = arg.decl_name;
auto& name = arg.param_name;
bool decl_and_arg_same = decl == name;
if ( name_count[name] == 1 )
continue; // it's unique
auto n = to_string(++usage_count[name]);
name += n;
if ( decl_and_arg_same )
decl += n;
}
// Finally, build the full versions of the declaration and parameters.
for ( auto& arg : args ) {
if ( ! full_decl.empty() )
full_decl += ", ";
full_decl += arg.decl_type + " " + arg.decl_name;
if ( ! full_params.empty() )
full_params += ", ";
full_params += arg.param_name;
params.push_back(arg.param_name);
}
}
ZAM_OpTemplate::ZAM_OpTemplate(ZAMGen* _g, string _base_name) : g(_g), base_name(std::move(_base_name)) {
// Make the base name viable in a C++ name.
transform(base_name.begin(), base_name.end(), base_name.begin(), dash_to_under);
cname = base_name;
transform(cname.begin(), cname.end(), cname.begin(), ::toupper);
}
void ZAM_OpTemplate::Build() {
op_loc = g->CurrLoc();
string line;
while ( g->ScanLine(line) ) {
if ( line.size() <= 1 )
break;
auto words = g->SplitIntoWords(line);
if ( words.empty() )
break;
Parse(words[0], line, words);
}
if ( ! op_classes.empty() && ! op_classes_vec.empty() )
Gripe("\"class\" and \"classes\" are mutually exclusive");
if ( ! op_classes.empty() || ! op_classes_vec.empty() ) {
auto nclasses = op_classes.empty() ? op_classes_vec[0].size() : op_classes.size();
for ( auto& oc : op_classes_vec )
if ( oc.size() != nclasses )
Gripe("size mismatch in \"classes\" specifications");
if ( ! op_types.empty() && op_types.size() != nclasses )
Gripe("number of \"op-types\" elements must match \"class\"/\"classes\"");
}
else if ( ! op_types.empty() )
Gripe("\"op-types\" can only be used with \"class\"/\"classes\"");
}
void ZAM_OpTemplate::Instantiate() {
if ( IsPredicate() )
InstantiatePredicate();
else if ( op_classes_vec.empty() )
InstantiateOp(OperandClasses(), IncludesVectorOp());
else
for ( auto& ocs : op_classes_vec )
InstantiateOp(ocs, IncludesVectorOp());
}
void ZAM_OpTemplate::InstantiatePredicate() {
if ( ! op_classes_vec.empty() )
Gripe("\"predicate\" cannot include \"classes\"");
if ( op_classes.empty() )
Gripe("\"predicate\" requires a \"class\"");
if ( IncludesVectorOp() )
Gripe("\"predicate\" cannot include \"vector\"");
// Build 3 forms: an assignment to an int-value'd $$, a conditional
// if the evaluation is true, and one if it is not.
auto orig_eval = eval;
// Remove trailing '\n' from eval.
orig_eval.pop_back();
auto orig_op_classes = op_classes;
bool no_classes = orig_op_classes[0] == ZAM_OC_NONE;
// Assignment form.
op_classes.clear();
op_classes.push_back(ZAM_OC_VAR);
if ( ! no_classes )
op_classes.insert(op_classes.end(), orig_op_classes.begin(), orig_op_classes.end());
string target_accessor;
if ( ! op_types.empty() )
op_types.insert(op_types.begin(), ZAM_TYPE_INT);
else
target_accessor = ".AsIntRef()";
eval = "$$" + target_accessor + " = " + orig_eval + ";";
InstantiateOp(op_classes, false);
// Conditional form - branch if not true.
if ( ! op_types.empty() ) {
// Remove 'V' at the beginning from the assignment form,
// and add a 'i' at the end for the branch.
op_types.erase(op_types.begin());
op_types.push_back(ZAM_TYPE_INT);
}
cname += "_COND";
op1_flavor = "OP1_READ";
if ( no_classes )
op_classes.clear();
else
op_classes = orig_op_classes;
op_classes.push_back(ZAM_OC_BRANCH);
auto branch_pos = to_string(op_classes.size());
auto suffix = " )\n\t\t$" + branch_pos;
eval = "if ( ! (" + orig_eval + ")" + suffix;
InstantiateOp(op_classes, false);
// Now the form that branches if true.
cname = "NOT_" + cname;
eval = "if ( (" + orig_eval + ")" + suffix;
InstantiateOp(op_classes, false);
}
void ZAM_OpTemplate::UnaryInstantiate() {
// First operand is always the frame slot to which this operation
// assigns the result of the applying unary operator.
OCVec ocs = {ZAM_OC_VAR};
ocs.resize(2);
// Now build versions for a constant operand (maybe not actually
// needed due to constant folding, but sometimes that gets deferred
// to run-time) ...
if ( ! NoConst() ) {
ocs[1] = ZAM_OC_CONSTANT;
InstantiateOp(ocs, IncludesVectorOp());
}
// ... and for a variable (frame-slot) operand.
ocs[1] = ZAM_OC_VAR;
InstantiateOp(ocs, IncludesVectorOp());
}
void ZAM_OpTemplate::Parse(const string& attr, const string& line, const Words& words) {
int num_args = -1; // -1 = don't enforce
int nwords = static_cast<int>(words.size());
if ( attr == "class" ) {
if ( nwords <= 1 )
g->Gripe("missing argument", line);
num_args = 1;
op_classes = ParseClass(words[1]);
}
else if ( attr == "classes" ) {
if ( nwords <= 1 )
g->Gripe("missing argument", line);
num_args = -1;
for ( int i = 1; i < nwords; ++i )
op_classes_vec.push_back(ParseClass(words[i]));
}
else if ( attr == "op-types" ) {
if ( words.size() == 1 )
g->Gripe("op-types needs arguments", line);
for ( auto i = 1U; i < words.size(); ++i ) {
auto& w_i = words[i];
if ( w_i.size() != 1 )
g->Gripe("bad op-types argument", w_i);
auto et_c = w_i.c_str()[0];
if ( type_names.count(et_c) == 0 )
g->Gripe("bad op-types argument", w_i);
op_types.push_back(type_names[et_c]);
}
}
else if ( attr == "op1-read" ) {
num_args = 0;
SetOp1Flavor("OP1_READ");
}
else if ( attr == "op1-read-write" ) {
num_args = 0;
SetOp1Flavor("OP1_READ_WRITE");
}
else if ( attr == "op1-internal" ) {
num_args = 0;
SetOp1Flavor("OP1_INTERNAL");
}
else if ( attr == "set-type" ) {
num_args = 1;
if ( nwords > 1 )
SetTypeParam(ExtractTypeParam(words[1]));
}
else if ( attr == "set-type2" ) {
num_args = 1;
if ( nwords > 1 )
SetType2Param(ExtractTypeParam(words[1]));
}
else if ( attr == "custom-method" )
SetCustomMethod(g->SkipWords(line, 1));
else if ( attr == "method-post" )
SetPostMethod(g->SkipWords(line, 1));
else if ( attr == "side-effects" ) {
if ( nwords == 3 )
SetAssignmentLess(words[1], words[2]);
else
// otherwise shouldn't be any arguments
num_args = 0;
SetHasSideEffects();
}
else if ( attr == "no-eval" ) {
num_args = 0;
SetNoEval();
}
else if ( attr == "vector" ) {
num_args = 0;
SetIncludesVectorOp();
}
else if ( attr == "assign-val" ) {
num_args = 1;
if ( words.size() > 1 )
SetAssignVal(words[1]);
}
else if ( attr == "eval" ) {
AddEval(g->SkipWords(line, 1));
auto addl = GatherEval();
if ( ! addl.empty() )
AddEval(addl);
}
else if ( attr == "macro" )
g->ReadMacro(line);
else
g->Gripe("unknown template attribute", attr);
if ( num_args >= 0 && num_args != nwords - 1 )
g->Gripe("extraneous or missing arguments", line);
}
OCVec ZAM_OpTemplate::ParseClass(const string& spec) const {
OCVec ocs;
const char* types = spec.c_str();
while ( *types ) {
ZAM_OperandClass oc = ZAM_OC_NONE;
switch ( *types ) {
case 'C': oc = ZAM_OC_CONSTANT; break;
case 'F': oc = ZAM_OC_ASSIGN_FIELD; break;
case 'H': oc = ZAM_OC_EVENT_HANDLER; break;
case 'L': oc = ZAM_OC_LIST; break;
case 'O': oc = ZAM_OC_AUX; break;
case 'R': oc = ZAM_OC_RECORD_FIELD; break;
case 'V': oc = ZAM_OC_VAR; break;
case 'i': oc = ZAM_OC_INT; break;
case 'b': oc = ZAM_OC_BRANCH; break;
case 'f': // 'f' = "for" loop
oc = ZAM_OC_TBL_ITER;
break;
case 'g': oc = ZAM_OC_GLOBAL; break;
case 's': oc = ZAM_OC_STEP_ITER; break;
case 'X': oc = ZAM_OC_NONE; break;
default: g->Gripe("bad operand type", spec); break;
}
ocs.push_back(oc);
++types;
}
return ocs;
}
string ZAM_OpTemplate::GatherEval() {
string res;
string l;
while ( g->ScanLine(l) ) {
if ( l.size() <= 1 || ! isspace(l.c_str()[0]) ) {
g->PutBack(l);
return res;
}
res += l;
}
return res;
}
int ZAM_OpTemplate::ExtractTypeParam(const string& arg) {
if ( arg == "$$" )
return 0;
if ( arg[0] != '$' )
g->Gripe("bad set-type parameter, should be $n", arg);
int param = atoi(&arg[1]);
if ( param <= 0 || param > 2 )
g->Gripe("bad set-type parameter, should be $1 or $2", arg);
return param;
}
// Maps an operand type to a character mnemonic used to distinguish
// it from others.
unordered_map<ZAM_OperandClass, char> ZAM_OpTemplate::oc_to_char = {
{ZAM_OC_AUX, 'O'}, {ZAM_OC_CONSTANT, 'C'}, {ZAM_OC_EVENT_HANDLER, 'H'}, {ZAM_OC_ASSIGN_FIELD, 'F'},
{ZAM_OC_INT, 'i'}, {ZAM_OC_LIST, 'L'}, {ZAM_OC_NONE, 'X'}, {ZAM_OC_RECORD_FIELD, 'R'},
{ZAM_OC_VAR, 'V'}, {ZAM_OC_BRANCH, 'b'}, {ZAM_OC_GLOBAL, 'g'}, {ZAM_OC_STEP_ITER, 's'},
{ZAM_OC_TBL_ITER, 'f'},
};
void ZAM_OpTemplate::InstantiateOp(const OCVec& oc, bool do_vec) {
auto method = MethodName(oc);
InstantiateOp(method, oc, ZIC_REGULAR);
if ( IncludesFieldOp() )
InstantiateOp(method, oc, ZIC_FIELD);
if ( do_vec )
InstantiateOp(method, oc, ZIC_VEC);
if ( IsConditionalOp() )
InstantiateOp(method, oc, ZIC_COND);
}
void ZAM_OpTemplate::InstantiateOp(const string& orig_method, const OCVec& oc_orig, ZAM_InstClass zc) {
auto oc = oc_orig;
string suffix = "";
if ( zc == ZIC_FIELD ) {
// Make room for the offset.
oc.push_back(ZAM_OC_INT);
suffix = NoEval() ? "" : "_field";
}
else if ( zc == ZIC_COND ) {
// Remove the assignment and add in the branch.
oc.erase(oc.begin());
oc.push_back(ZAM_OC_BRANCH);
suffix = "_cond";
}
else if ( zc == ZIC_VEC ) {
// Don't generate versions of these for constant operands
// as those don't exist.
if ( int(oc.size()) != Arity() + 1 )
Gripe("vector class/arity mismatch");
if ( oc[1] == ZAM_OC_CONSTANT )
return;
if ( Arity() > 1 && oc[2] == ZAM_OC_CONSTANT )
return;
suffix = "_vec";
}
auto method = MethodName(oc);
if ( ! IsInternalOp() )
InstantiateMethod(method, suffix, oc, zc);
if ( IsAssignOp() )
InstantiateAssignOp(oc, suffix);
else {
InstantiateEval(oc, suffix, zc);
if ( HasAssignmentLess() ) {
auto op_string = "_" + OpSuffix(oc);
auto op = g->GenOpCode(this, op_string);
GenAssignmentlessVersion(op);
}
}
}
void ZAM_OpTemplate::GenAssignmentlessVersion(const string& op) {
EmitTo(AssignFlavor);
Emit("assignmentless_op[" + op + "] = " + AssignmentLessOp() + ";");
Emit("assignmentless_op_class[" + op + "] = " + AssignmentLessOpClass() + ";");
}
void ZAM_OpTemplate::InstantiateMethod(const string& m, const string& suffix, const OCVec& oc, ZAM_InstClass zc) {
if ( IsInternalOp() )
return;
auto decls = MethodDeclare(oc, zc);
EmitTo(MethodDecl);
Emit("const ZAMStmt " + m + suffix + "(" + decls + ");");
EmitTo(MethodDef);
Emit("const ZAMStmt ZAMCompiler::" + m + suffix + "(" + decls + ")");
BeginBlock();
InstantiateMethodCore(oc, suffix, zc);
if ( HasPostMethod() )
Emit(GetPostMethod());
if ( ! HasCustomMethod() )
Emit("return AddInst(z);");
EndBlock();
NL();
}
void ZAM_OpTemplate::InstantiateMethodCore(const OCVec& oc, const string& suffix, ZAM_InstClass zc) {
if ( HasCustomMethod() ) {
Emit(GetCustomMethod());
return;
}
assert(! oc.empty());
string full_suffix = "_" + OpSuffix(oc) + suffix;
Emit("ZInstI z;");
if ( oc[0] == ZAM_OC_AUX ) {
auto op = g->GenOpCode(this, full_suffix, zc);
Emit("z = ZInstI(" + op + ");");
return;
}
if ( oc[0] == ZAM_OC_NONE ) {
auto op = g->GenOpCode(this, full_suffix, zc);
Emit("z = GenInst(" + op + ");");
return;
}
if ( oc.size() > 1 && oc[1] == ZAM_OC_AUX ) {
auto op = g->GenOpCode(this, full_suffix, zc);
Emit("z = ZInstI(" + op + ", Frame1Slot(n, " + op + "));");
return;
}
ArgsManager args(oc, zc);
BuildInstruction(oc, args.Params(), full_suffix, zc);
auto& tp = GetTypeParam();
if ( tp )
Emit("z.SetType(" + args.NthParam(*tp) + "->GetType());");
auto& tp2 = GetType2Param();
if ( tp2 )
Emit("z.SetType2(" + args.NthParam(*tp2) + "->GetType());");
}
void ZAM_OpTemplate::BuildInstruction(const OCVec& oc, const string& params, const string& suffix, ZAM_InstClass zc) {
auto op = g->GenOpCode(this, suffix, zc);
Emit("z = GenInst(" + op + ", " + params + ");");
}
static bool skippable_op_type(ZAM_OperandClass oc) {
return oc == ZAM_OC_EVENT_HANDLER || oc == ZAM_OC_AUX || oc == ZAM_OC_LIST;
}
string ZAM_OpTemplate::ExpandParams(const OCVec& oc, string eval, const vector<string>& accessors) const {
auto have_target = eval.find("$$") != string::npos;
const auto& fl = GetOp1Flavor();
auto need_target = fl == "OP1_WRITE";
auto oc_size = oc.size();
if ( oc_size > 0 ) {
auto oc0 = oc[0];
if ( oc0 == ZAM_OC_NONE || oc0 == ZAM_OC_AUX ) {
--oc_size;
need_target = false;
}
else if ( raw_int_oc.count(oc0) > 0 )
need_target = false;
}
while ( oc_size > 0 && skippable_op_type(oc[oc_size - 1]) )
--oc_size;
auto max_param = oc_size;
if ( need_target && ! have_target )
Gripe("eval missing $$:", eval);
if ( have_target ) {
assert(max_param > 0);
--max_param;
}
bool has_d1 = eval.find("$1") != string::npos;
bool has_d2 = eval.find("$2") != string::npos;
bool has_d3 = eval.find("$3") != string::npos;
bool has_d4 = eval.find("$4") != string::npos;
switch ( max_param ) {
case 4:
if ( ! has_d4 )
Gripe("eval missing $4", eval);
[[fallthrough]];
case 3:
if ( ! has_d3 )
Gripe("eval missing $3", eval);
[[fallthrough]];
case 2:
if ( ! has_d2 )
Gripe("eval missing $2", eval);
[[fallthrough]];
case 1:
if ( ! has_d1 )
Gripe("eval missing $1", eval);
[[fallthrough]];
case 0: break;
default: Gripe("unexpected param size", to_string(max_param) + " - " + eval); break;
}
switch ( max_param ) {
case 0:
if ( has_d1 )
Gripe("extraneous $1 in eval", eval);
[[fallthrough]];
case 1:
if ( has_d2 )
Gripe("extraneous $2 in eval", eval);
[[fallthrough]];
case 2:
if ( has_d3 )
Gripe("extraneous $3 in eval", eval);
[[fallthrough]];
case 3:
if ( has_d4 )
Gripe("extraneous $4 in eval", eval);
[[fallthrough]];
case 4: break;
default: Gripe("unexpected param size", to_string(max_param) + " - " + eval); break;
}
int frame_slot = 0;
bool const_seen = false;
bool int_seen = false;
for ( size_t i = 0; i < oc_size; ++i ) {
string op;
bool needs_accessor = true;
switch ( oc[i] ) {
case ZAM_OC_VAR:
if ( int_seen )
Gripe("'V' type specifier after 'i' specifier", eval);
op = "frame[z.v" + to_string(++frame_slot) + "]";
break;
case ZAM_OC_RECORD_FIELD: op = "frame[z.v" + to_string(++frame_slot) + "]"; break;
case ZAM_OC_INT:
case ZAM_OC_BRANCH:
case ZAM_OC_GLOBAL:
case ZAM_OC_STEP_ITER:
case ZAM_OC_TBL_ITER:
op = "z.v" + to_string(++frame_slot);
int_seen = true;
needs_accessor = false;
if ( oc[i] == ZAM_OC_BRANCH )
op = "Branch(" + op + ")";
else if ( oc[i] == ZAM_OC_STEP_ITER )
op = "StepIter(" + op + ")";
else if ( oc[i] == ZAM_OC_TBL_ITER )
op = "TableIter(" + op + ")";
break;
case ZAM_OC_CONSTANT:
if ( const_seen )
g->Gripe("double constant", eval.c_str());
const_seen = true;
op = "z.c";
break;
default: Gripe("unexpected oc type", eval); break;
}
if ( needs_accessor ) {
if ( ! accessors.empty() && ! accessors[i].empty() )
op += "." + accessors[i];
else if ( ! op_types.empty() && op_types[i] != ZAM_TYPE_NONE )
op += "." + find_type_accessor(op_types[i], have_target && i == 0);
}
else if ( ! op_types.empty() && oc[i] == ZAM_OC_INT ) {
if ( op_types[i] == ZAM_TYPE_UINT )
op = "zeek_uint_t(" + op + ")";
}
string pat;
if ( i == 0 && have_target )
pat = "\\$\\$";
else
pat = "\\$" + to_string(have_target ? i : i + 1);
auto orig_eval = eval;
eval = regex_replace(eval, regex(pat), op);
if ( orig_eval == eval )
Gripe("no eval sub", pat + " - " + eval);
}
return eval;
}
void ZAM_OpTemplate::InstantiateEval(const OCVec& oc, const string& suffix, ZAM_InstClass zc) {
if ( NoEval() )
return;
auto eval = ExpandParams(oc, GetEval(), accessors);
GenEval(Eval, OpSuffix(oc), suffix, eval, zc);
}
void ZAM_OpTemplate::GenEval(EmitTarget et, const string& oc_str, const string& op_suffix, const string& eval,
ZAM_InstClass zc) {
auto op_code = g->GenOpCode(this, "_" + oc_str + op_suffix, zc);
if ( et == Eval ) {
auto oc_str_copy = oc_str;
if ( zc == ZIC_COND ) {
auto n = oc_str_copy.size();
if ( oc_str_copy[n - 1] == 'V' )
oc_str_copy[n - 1] = 'i';
else if ( oc_str_copy[n - 1] == 'C' ) {
if ( oc_str_copy[n - 2] != 'V' )
Gripe("bad operator class");
oc_str_copy[n - 2] = 'C';
oc_str_copy[n - 1] = 'i';
}
}
GenDesc(op_code, oc_str_copy, eval);
}
EmitTo(et);
Emit("case " + op_code + ":");
BeginBlock();
Emit(eval);
EndBlock();
EmitUp("break;");
NL();
}
void ZAM_OpTemplate::GenDesc(const string& op_code, const string& oc_str, const string& eval) {
StartDesc(op_code, oc_str);
Emit(eval);
EndDesc();
}
void ZAM_OpTemplate::StartDesc(const string& op_code, const string& oc_str) {
EmitTo(OpDesc);
Emit("{ " + op_code + ",");
BeginBlock();
Emit("\"" + oc_str + "\",");
if ( op_types.empty() )
Emit("\"\",");
else {
string ots;
for ( auto typ : op_types ) {
if ( typ == ZAM_TYPE_DEFAULT )
ots += "X";
else
ots += expr_name_types[typ];
}
Emit("\"" + ots + "\", ");
}
StartString();
}
void ZAM_OpTemplate::EndDesc() {
EndString();
EndBlock();
Emit("},");
}
void ZAM_OpTemplate::InstantiateAssignOp(const OCVec& oc, const string& suffix) {
// First, create a generic version of the operand, which the
// ZAM compiler uses to find specific-flavored versions.
auto oc_str = OpSuffix(oc);
auto op_string = "_" + oc_str;
auto generic_op = g->GenOpCode(this, op_string);
auto flavor_ind = "assignment_flavor[" + generic_op + "]";
EmitTo(AssignFlavor);
Emit(flavor_ind + " = empty_map;");
const auto& eval = GetEval();
const auto& v = GetAssignVal();
for ( auto& ti : ZAM_type_info ) {
auto op = g->GenOpCode(this, op_string + "_" + ti.suffix);
if ( IsInternalOp() ) {
EmitTo(AssignFlavor);
Emit(flavor_ind + "[" + ti.tag + "] = " + op + ";");
if ( HasAssignmentLess() )
GenAssignmentlessVersion(op);
}
StartDesc(op, oc_str);
GenAssignOpCore(oc, eval, ti.accessor, ti.is_managed);
if ( ! post_eval.empty() )
Emit(post_eval);
EndDesc();
EmitTo(Eval);
Emit("case " + op + ":");
BeginBlock();
GenAssignOpCore(oc, eval, ti.accessor, ti.is_managed);
if ( ! post_eval.empty() )
Emit(post_eval);
Emit("break;");
EndBlock();
}
post_eval.clear();
}
void ZAM_OpTemplate::GenAssignOpCore(const OCVec& oc, const string& eval, const string& accessor, bool is_managed) {
if ( HasAssignVal() ) {
GenAssignOpValCore(oc, eval, accessor, is_managed);
return;
}
if ( ! eval.empty() )
g->Gripe("assign-op should not have an \"eval\"", eval);
auto lhs_field = (oc[0] == ZAM_OC_ASSIGN_FIELD);
auto rhs_field = lhs_field && oc.size() > 3 && (oc[3] == ZAM_OC_INT);
auto constant_op = (oc[1] == ZAM_OC_CONSTANT);
string rhs = constant_op ? "z.c" : "frame[z.v2]";
auto acc = ".As" + accessor + "()";
if ( accessor == "Any" && constant_op && ! rhs_field ) {
// "any_val = constant" or "x$any_val = constant".
//
// These require special-casing, because to avoid going
// through a CoerceToAny operation, we allow expressing
// these directly. They don't fit with the usual assignment
// paradigm since the RHS differs in type from the LHS.
Emit("auto v = z.c.ToVal(Z_TYPE);");
if ( lhs_field ) {
Emit("auto r = frame[z.v1].AsRecord();");
Emit("auto& f = DirectField(r, z.v2);");
}
else
Emit("auto& f = frame[z.v1];");
Emit("zeek::Unref(f.ManagedVal());");
Emit("f = ZVal(v.release());");
}
else if ( rhs_field ) {
// The following is counter-intuitive, but comes from the
// fact that we build out the instruction parameters as
// an echo of the method parameters, and for this case that
// means that the RHS field offset comes *before*, not after,
// the LHS field offset.
auto lhs_offset = constant_op ? 3 : 4;
auto rhs_offset = lhs_offset - 1;
Emit("auto v = DirectOptField(" + rhs + ".AsRecord(), z.v" + to_string(rhs_offset) +
"); // note, RHS field before LHS field\n");
Emit("if ( ! v )");
BeginBlock();
Emit("ZAM_run_time_error(Z_LOC, \"field value missing\");");
EndBlock();
Emit("else");
BeginBlock();
auto slot = "z.v" + to_string(lhs_offset);
Emit("auto r = frame[z.v1].AsRecord();");
Emit("auto& f = DirectField(r, " + slot + "); // note, LHS field after RHS field\n");
if ( is_managed ) {
Emit("zeek::Ref((*v)" + acc + ");");
Emit("zeek::Unref(f.ManagedVal());");
}
Emit("f = *v;");
if ( lhs_field )
Emit("r->Modified();");
EndBlock();
}
else {
if ( is_managed )
Emit("zeek::Ref(" + rhs + acc + ");");
if ( lhs_field ) {
auto lhs_offset = constant_op ? 2 : 3;
auto slot = "z.v" + to_string(lhs_offset);
Emit("auto r = frame[z.v1].AsRecord();");
Emit("auto& f = DirectField(r, " + slot + ");");
if ( is_managed )
Emit("zeek::Unref(f.ManagedVal());");
Emit("f = " + rhs + ";");
Emit("r->Modified();");
}
else {
if ( is_managed )
Emit("zeek::Unref(frame[z.v1].ManagedVal());");
Emit("frame[z.v1] = ZVal(" + rhs + acc + ");");
}
}
}
void ZAM_OpTemplate::GenAssignOpValCore(const OCVec& oc, const string& orig_eval, const string& accessor,
bool is_managed) {
const auto& v = GetAssignVal();
// Maps Zeek types to how to get the underlying value from a ValPtr.
static unordered_map<string, string> val_accessors = {
{"Addr", "->AsAddrVal()"}, {"Any", ".get()"},
{"Count", "->AsCount()"}, {"Double", "->AsDouble()"},
{"Int", "->AsInt()"}, {"Pattern", "->AsPatternVal()"},
{"String", "->AsStringVal()"}, {"SubNet", "->AsSubNetVal()"},
{"Table", "->AsTableVal()"}, {"Vector", "->AsVectorVal()"},
{"File", "->AsFile()"}, {"Func", "->AsFunc()"},
{"List", "->AsListVal()"}, {"Opaque", "->AsOpaqueVal()"},
{"Record", "->AsRecordVal()"}, {"Type", "->AsTypeVal()"},
};
const auto& val_accessor = val_accessors[accessor];
string rhs;
if ( IsInternalOp() )
rhs = v + val_accessor;
else
rhs = v + ".As" + accessor + "()";
auto eval = orig_eval;
if ( is_managed ) {
eval += string("auto rhs = ") + rhs + ";\n";
eval += "zeek::Ref(rhs);\n";
eval += "Unref($$.ManagedVal());\n";
eval += "$$ = ZVal(rhs);\n";
}
else
eval += "$$ = ZVal(" + rhs + ");\n";
Emit(ExpandParams(oc, eval));
}
string ZAM_OpTemplate::MethodName(const OCVec& oc) const { return base_name + OpSuffix(oc); }
string ZAM_OpTemplate::MethodDeclare(const OCVec& oc, ZAM_InstClass zc) {
ArgsManager args(oc, zc);
return args.Decls();
}
string ZAM_OpTemplate::OpSuffix(const OCVec& oc) const {
string os;
for ( auto& o : oc )
os += oc_to_char[o];
return os;
}
string ZAM_OpTemplate::SkipWS(const string& s) const {
auto sp = s.c_str();
while ( *sp && isspace(*sp) )
++sp;
return sp;
}
void ZAM_OpTemplate::Emit(const string& s) { g->Emit(curr_et, s); }
void ZAM_OpTemplate::EmitNoNL(const string& s) {
g->SetNoNL(true);
Emit(s);
g->SetNoNL(false);
}
void ZAM_OpTemplate::IndentUp() { g->IndentUp(); }
void ZAM_OpTemplate::IndentDown() { g->IndentDown(); }
void ZAM_OpTemplate::StartString() { g->StartString(); }
void ZAM_OpTemplate::EndString() { g->EndString(); }
void ZAM_OpTemplate::Gripe(const char* msg) const { g->Gripe(msg, op_loc); }
void ZAM_OpTemplate::Gripe(string msg, string addl) const {
auto full_msg = msg + ": " + addl;
Gripe(full_msg.c_str());
}
void ZAM_UnaryOpTemplate::Instantiate() { UnaryInstantiate(); }
void ZAM_DirectUnaryOpTemplate::Instantiate() {
EmitTo(DirectDef);
Emit("case EXPR_" + cname + ":\treturn " + direct + "(lhs, rhs);");
}
ZAM_ExprOpTemplate::ZAM_ExprOpTemplate(ZAMGen* _g, string _base_name) : ZAM_OpTemplate(_g, std::move(_base_name)) {
static bool did_map_init = false;
if ( ! did_map_init ) { // Create the inverse mapping.
for ( auto& tn : type_names )
expr_name_types[tn.second] = tn.first;
did_map_init = true;
}
}
void ZAM_ExprOpTemplate::Parse(const string& attr, const string& line, const Words& words) {
if ( attr == "op-type" ) {
if ( words.size() == 1 )
g->Gripe("op-type needs arguments", line);
for ( auto i = 1U; i < words.size(); ++i ) {
auto& w_i = words[i];
if ( w_i.size() != 1 )
g->Gripe("bad op-type argument", w_i);
auto et_c = w_i.c_str()[0];
if ( type_names.count(et_c) == 0 )
g->Gripe("bad op-type argument", w_i);
AddExprType(type_names[et_c]);
}
}
else if ( attr == "includes-field-op" ) {
if ( words.size() != 1 )
g->Gripe("includes-field-op does not take any arguments", line);
SetIncludesFieldOp();
}
else if ( attr == "eval-type" ) {
if ( words.size() < 3 )
g->Gripe("eval-type needs type and evaluation", line);
auto& type = words[1];
if ( type.size() != 1 )
g->Gripe("bad eval-type type", type);
auto type_c = type.c_str()[0];
if ( type_names.count(type_c) == 0 )
g->Gripe("bad eval-type type", type);
auto zt = type_names[type_c];
if ( expr_types.count(zt) == 0 )
g->Gripe("eval-type type not present in eval-type", type);
auto eval = g->SkipWords(line, 2);
eval += GatherEval();
AddEvalSet(zt, eval);
}
else if ( attr == "eval-mixed" ) {
if ( words.size() < 4 )
g->Gripe("eval-mixed needs types and evaluation", line);
auto& type1 = words[1];
auto& type2 = words[2];
if ( type1.size() != 1 || type2.size() != 1 )
g->Gripe("bad eval-mixed types", line);
auto type_c1 = type1.c_str()[0];
auto type_c2 = type2.c_str()[0];
if ( type_names.count(type_c1) == 0 || type_names.count(type_c2) == 0 )
g->Gripe("bad eval-mixed types", line);
auto et1 = type_names[type_c1];
auto et2 = type_names[type_c2];
auto eval = g->SkipWords(line, 3);
eval += GatherEval();
AddEvalSet(et1, et2, eval);
}
else if ( attr == "precheck" ) {
if ( words.size() < 2 )
g->Gripe("precheck needs evaluation", line);
auto eval = g->SkipWords(line, 1);
eval += GatherEval();
eval.pop_back();
SetPreCheck(eval);
}
else if ( attr == "precheck-action" ) {
if ( words.size() < 2 )
g->Gripe("precheck-action needs evaluation", line);
auto eval = g->SkipWords(line, 1);
eval += GatherEval();
eval.pop_back();
SetPreCheckAction(eval);
}
else if ( attr == "explicit-result-type" ) {
if ( words.size() != 1 )
g->Gripe("extraneous argument to explicit-result-type", line);
SetHasExplicitResultType();
}
else
// Not an attribute specific to expr-op's.
ZAM_OpTemplate::Parse(attr, line, words);
}
void ZAM_ExprOpTemplate::Instantiate() {
if ( ! op_classes_vec.empty() )
Gripe("expressions cannot use \"classes\"");
InstantiateOp(OperandClasses(), IncludesVectorOp());
if ( op_classes.size() > 1 && op_classes[1] == ZAM_OC_CONSTANT )
InstantiateC1(op_classes, op_classes.size() - 1);
if ( op_classes.size() > 2 && op_classes[2] == ZAM_OC_CONSTANT )
InstantiateC2(op_classes, op_classes.size() - 1);
if ( op_classes.size() > 3 && op_classes[3] == ZAM_OC_CONSTANT )
InstantiateC3(op_classes);
bool all_var = true;
for ( auto i = 1U; i < op_classes.size(); ++i )
if ( op_classes[i] != ZAM_OC_VAR )
all_var = false;
if ( all_var )
InstantiateV(op_classes);
if ( op_classes.size() == 3 && op_classes[1] == ZAM_OC_RECORD_FIELD && op_classes[2] == ZAM_OC_INT )
InstantiateV(op_classes);
}
void ZAM_ExprOpTemplate::InstantiateC1(const OCVec& ocs, size_t arity) {
string args = "lhs, r1->AsConstExpr()";
if ( arity == 1 && ocs[0] == ZAM_OC_RECORD_FIELD )
args += ", rhs->AsFieldExpr()->Field()";
else if ( arity > 1 ) {
args += ", ";
if ( ocs[2] == ZAM_OC_RECORD_FIELD )
args += "rhs->AsFieldExpr()->Field()";
else
args += "r2->AsNameExpr()";
}
auto m = MethodName(ocs);
EmitTo(C1Def);
EmitNoNL("case EXPR_" + cname + ":");
EmitUp("return " + m + "(" + args + ");");
if ( IncludesFieldOp() ) {
EmitTo(C1FieldDef);
Emit("case EXPR_" + cname + ":\treturn " + m + "i_field(" + args + ", field);");
}
}
void ZAM_ExprOpTemplate::InstantiateC2(const OCVec& ocs, size_t arity) {
string args = "lhs, r1->AsNameExpr(), r2->AsConstExpr()";
if ( arity == 3 )
args += ", r3->AsNameExpr()";
auto method = MethodName(ocs);
auto m = method.c_str();
EmitTo(C2Def);
Emit("case EXPR_" + cname + ":\treturn " + m + "(" + args + ");");
if ( IncludesFieldOp() ) {
EmitTo(C2FieldDef);
Emit("case EXPR_" + cname + ":\treturn " + m + "i_field(" + args + ", field);");
}
}
void ZAM_ExprOpTemplate::InstantiateC3(const OCVec& ocs) {
EmitTo(C3Def);
Emit("case EXPR_" + cname + ":\treturn " + MethodName(ocs) +
"(lhs, r1->AsNameExpr(), r2->AsNameExpr(), r3->AsConstExpr());");
}
void ZAM_ExprOpTemplate::InstantiateV(const OCVec& ocs) {
auto m = MethodName(ocs);
string args = "lhs, r1->AsNameExpr()";
if ( ocs.size() >= 3 ) {
if ( ocs[2] == ZAM_OC_INT ) {
string acc_flav = IncludesFieldOp() ? "Has" : "";
args += ", rhs->As" + acc_flav + "FieldExpr()->Field()";
}
else
args += ", r2->AsNameExpr()";
if ( ocs.size() == 4 )
args += ", r3->AsNameExpr()";
}
EmitTo(VDef);
EmitNoNL("case EXPR_" + cname + ":");
if ( IncludesVectorOp() )
DoVectorCase(m, args);
else
EmitUp("return " + m + "(" + args + ");");
if ( IncludesFieldOp() ) {
string suffix = NoEval() ? "" : "_field";
EmitTo(VFieldDef);
Emit("case EXPR_" + cname + ":\treturn " + m + "i" + suffix + "(" + args + ", field);");
}
}
void ZAM_ExprOpTemplate::DoVectorCase(const string& m, const string& args) {
NL();
IndentUp();
Emit("if ( rt->Tag() == TYPE_VECTOR )");
EmitUp("return " + m + "_vec(" + args + ");");
Emit("else");
EmitUp("return " + m + "(" + args + ");");
IndentDown();
}
void ZAM_ExprOpTemplate::BuildInstructionCore(const string& params, const string& suffix, ZAM_InstClass zc) {
Emit("auto tag1 = t->Tag();");
Emit("auto i_t1 = t->InternalType();");
int ncases = 0;
if ( zc != ZIC_VEC )
for ( auto& [et1, et2_map] : eval_mixed_set )
for ( auto& [et2, eval] : et2_map )
GenMethodTest(et1, et2, params, suffix, ++ncases > 1, zc);
bool do_default = false;
for ( auto zt : ExprTypes() ) {
if ( zt == ZAM_TYPE_DEFAULT )
do_default = true;
else if ( zt == ZAM_TYPE_NONE )
continue;
else
GenMethodTest(zt, zt, params, suffix, ++ncases > 1, zc);
}
Emit("else");
if ( do_default ) {
auto op = g->GenOpCode(this, suffix, zc);
EmitUp("z = GenInst(" + op + ", " + params + ");");
}
else
EmitUp("reporter->InternalError(\"bad tag when generating method core\");");
}
void ZAM_ExprOpTemplate::GenMethodTest(ZAM_Type et1, ZAM_Type et2, const string& params, const string& suffix,
bool do_else, ZAM_InstClass zc) {
// Maps ZAM_Type's to the information needed (variable name,
// constant to compare it against) to identify using an "if" test
// that a given AST Expr node employs the given type of operand.
static map<ZAM_Type, pair<string, string>> if_tests = {
{ZAM_TYPE_ADDR, {"i_t", "TYPE_INTERNAL_ADDR"}},
{ZAM_TYPE_ANY, {"tag", "TYPE_ANY"}},
{ZAM_TYPE_DOUBLE, {"i_t", "TYPE_INTERNAL_DOUBLE"}},
{ZAM_TYPE_FILE, {"tag", "TYPE_FILE"}},
{ZAM_TYPE_FUNC, {"tag", "TYPE_FUNC"}},
{ZAM_TYPE_INT, {"i_t", "TYPE_INTERNAL_INT"}},
{ZAM_TYPE_LIST, {"tag", "TYPE_LIST"}},
{ZAM_TYPE_OPAQUE, {"tag", "TYPE_OPAQUE"}},
{ZAM_TYPE_PATTERN, {"tag", "TYPE_PATTERN"}},
{ZAM_TYPE_RECORD, {"tag", "TYPE_RECORD"}},
{ZAM_TYPE_STRING, {"i_t", "TYPE_INTERNAL_STRING"}},
{ZAM_TYPE_SUBNET, {"i_t", "TYPE_INTERNAL_SUBNET"}},
{ZAM_TYPE_TABLE, {"tag", "TYPE_TABLE"}},
{ZAM_TYPE_TYPE, {"tag", "TYPE_TYPE"}},
{ZAM_TYPE_UINT, {"i_t", "TYPE_INTERNAL_UNSIGNED"}},
{ZAM_TYPE_VECTOR, {"tag", "TYPE_VECTOR"}},
};
if ( if_tests.count(et1) == 0 || if_tests.count(et2) == 0 )
Gripe("bad op-type");
const auto& [var, val] = if_tests[et1];
auto if_var1 = var + "1";
string test = if_var1 + " == " + val;
if ( Arity() > 1 ) {
const auto& [var2, val2] = if_tests[et2];
auto if_var2 = var2 + "2";
test = test + " && " + if_var2 + " == " + val2;
}
test = "if ( " + test + " )";
if ( do_else )
test = "else " + test;
Emit(test);
auto op_suffix = suffix + "_" + expr_name_types[et1];
if ( et2 != et1 )
op_suffix += expr_name_types[et2];
auto op = g->GenOpCode(this, op_suffix, zc);
EmitUp("z = GenInst(" + op + ", " + params + ");");
}
EvalInstance::EvalInstance(ZAM_Type _lhs_et, ZAM_Type _op1_et, ZAM_Type _op2_et, string _eval, bool _is_def) {
lhs_et = _lhs_et;
op1_et = _op1_et;
op2_et = _op2_et;
eval = std::move(_eval);
is_def = _is_def;
}
string EvalInstance::LHSAccessor(bool is_ptr) const {
if ( lhs_et == ZAM_TYPE_NONE || lhs_et == ZAM_TYPE_DEFAULT )
return "";
string deref = is_ptr ? "->" : ".";
string acc = find_type_accessor(lhs_et, true);
return deref + acc;
}
string EvalInstance::Accessor(ZAM_Type zt, bool is_ptr) const {
if ( zt == ZAM_TYPE_NONE || zt == ZAM_TYPE_DEFAULT )
return "";
string deref = is_ptr ? "->" : ".";
return deref + "As" + find_type_info(zt).accessor + "()";
}
string EvalInstance::OpMarker() const {
if ( op1_et == ZAM_TYPE_DEFAULT || op1_et == ZAM_TYPE_NONE )
return "";
if ( op1_et == op2_et )
return "_" + find_type_info(op1_et).suffix;
return "_" + find_type_info(op1_et).suffix + find_type_info(op2_et).suffix;
}
void ZAM_ExprOpTemplate::InstantiateEval(const OCVec& oc_orig, const string& suffix, ZAM_InstClass zc) {
if ( (HasPreCheck() || HasPreCheckAction()) && (! HasPreCheck() || ! HasPreCheckAction()) )
Gripe("precheck and precheck-action must be used together");
auto oc = oc_orig;
if ( expr_types.empty() ) {
// No operand types to expand over. This happens for
// some "non-uniform" operations.
ZAM_OpTemplate::InstantiateEval(oc, suffix, zc);
return;
}
auto oc_str = OpSuffix(oc);
// Some of these might not wind up being used, but no harm in
// initializing them in case they are.
string lhs, op1, op2;
string branch_target = "z.v";
EmitTarget emit_target = Eval;
if ( zc == ZIC_VEC ) {
lhs = "vec1[i]";
op1 = "vec2[i]";
op2 = "vec3[i]";
emit_target = Arity() == 1 ? Vec1Eval : Vec2Eval;
}
else {
lhs = "frame[z.v1]";
// First compute the offsets into oc for the operands.
auto op1_offset = zc == ZIC_COND ? 0 : 1;
bool oc1_const = oc[op1_offset] == ZAM_OC_CONSTANT;
bool oc2_const = Arity() > 1 && oc[op1_offset + 1] == ZAM_OC_CONSTANT;
// Now the frame slots.
auto op1_slot = op1_offset + 1;
auto op2_slot = op1_slot + 1;
if ( oc1_const ) {
op1 = "z.c";
--op2_slot;
if ( zc == ZIC_COND )
branch_target += "2";
}
else {
op1 = "frame[z.v" + to_string(op1_slot) + "]";
if ( zc == ZIC_COND ) {
if ( Arity() > 1 && ! oc2_const )
branch_target += "3";
else
branch_target += "2";
}
}
if ( oc2_const )
op2 = "z.c";
else
op2 = "frame[z.v" + to_string(op2_slot) + "]";
if ( zc == ZIC_FIELD ) {
// Compute the slot holding the field offset.
auto f =
// The first slots are taken up by the
// assignment slot and the operands ...
Arity() + 1 +
// ... and slots are numbered starting at 1.
+1;
if ( oc1_const || oc2_const )
// One of the operand slots won't be needed
// due to the presence of a constant.
// (It's never the case that both operands
// are constants - those instead get folded.)
--f;
lhs = "DirectField(" + lhs + ".AsRecord(), z.v" + to_string(f) + ")";
}
}
vector<EvalInstance> eval_instances;
for ( auto zt : expr_types ) {
// Support for "op-type X" meaning "allow empty evaluation",
// as well as "evaluation is generic".
if ( zt == ZAM_TYPE_NONE && GetEval().empty() )
continue;
auto is_def = eval_set.count(zt) == 0;
string eval = is_def ? GetEval() : eval_set[zt];
auto lhs_et = IsConditionalOp() ? ZAM_TYPE_INT : zt;
eval_instances.emplace_back(lhs_et, zt, zt, eval, is_def);
}
if ( zc != ZIC_VEC )
for ( const auto& em1 : eval_mixed_set ) {
auto et1 = em1.first;
for ( const auto& em2 : em1.second ) {
auto et2 = em2.first;
// For the LHS, either its expression type is
// ignored, or if it's a conditional, so just
// note it for the latter.
auto lhs_et = ZAM_TYPE_INT;
eval_instances.emplace_back(lhs_et, et1, et2, em2.second, false);
}
}
for ( auto& ei : eval_instances ) {
op_types.clear();
auto lhs_accessor = ei.LHSAccessor();
if ( HasExplicitResultType() ) {
op_types.push_back(ZAM_TYPE_NONE);
lhs_accessor = "";
}
else if ( zc == ZIC_FIELD )
op_types.push_back(ZAM_TYPE_RECORD);
else if ( zc != ZIC_COND )
op_types.push_back(ei.LHS_ET());
string lhs_ei = lhs;
if ( zc != ZIC_VEC )
lhs_ei += lhs_accessor;
op_types.push_back(ei.Op1_ET());
if ( Arity() > 1 )
op_types.push_back(ei.Op2_ET());
if ( zc == ZIC_FIELD )
op_types.push_back(ZAM_TYPE_INT);
else if ( zc == ZIC_COND )
op_types.push_back(ZAM_TYPE_INT);
else if ( zc == ZIC_VEC ) {
// Above isn't applicable, since we use helper
// functions.
op_types.clear();
op_types.push_back(ZAM_TYPE_VECTOR);
op_types.push_back(ZAM_TYPE_VECTOR);
if ( Arity() > 1 )
op_types.push_back(ZAM_TYPE_VECTOR);
}
auto op1_ei = op1 + ei.Op1Accessor(zc == ZIC_VEC);
auto op2_ei = op2 + ei.Op2Accessor(zc == ZIC_VEC);
auto eval = SkipWS(ei.Eval());
auto has_target = eval.find("$$") != string::npos;
if ( zc == ZIC_VEC ) {
const char* rhs;
if ( has_target )
rhs = "\\$\\$ = ([^;\n]*)";
else
rhs = "^[^;\n]*";
auto replacement = VecEvalRE(has_target);
eval = regex_replace(eval, regex(rhs), replacement, std::regex_constants::match_not_null);
}
auto is_none = ei.LHS_ET() == ZAM_TYPE_NONE;
auto is_default = ei.LHS_ET() == ZAM_TYPE_DEFAULT;
if ( ! is_none && ! is_default && find_type_info(ei.LHS_ET()).is_managed && ! HasExplicitResultType() ) {
auto pre = "auto hold_lhs = " + lhs;
if ( zc == ZIC_VEC )
// For vectors, we have to check for whether
// the previous value is present, or a hole.
pre += string(" ? ") + lhs + "->";
else
pre += ".";
pre += "ManagedVal()";
if ( zc == ZIC_VEC )
pre += " : nullptr";
pre += ";\n\t";
auto post = "\tUnref(hold_lhs);";
eval = pre + eval + post;
}
eval = regex_replace(eval, regex("\\$1"), op1_ei);
eval = regex_replace(eval, regex("\\$2"), op2_ei);
string pre, post;
if ( HasPreCheck() ) {
pre = "if ( " + GetPreCheck() + ")\n\t{\n\t" + GetPreCheckAction() + "\n\t}\n\telse\n\t{\n\t";
post = "\n\t}";
}
pre = regex_replace(pre, regex("\\$1"), op1_ei);
pre = regex_replace(pre, regex("\\$2"), op2_ei);
if ( has_target )
eval = regex_replace(eval, regex("\\$\\$"), lhs_ei);
else if ( zc == ZIC_COND ) {
// Aesthetics: get rid of trailing newlines.
eval = regex_replace(eval, regex("\n"), "");
eval = "if ( ! (" + eval + ") ) " + "Branch(" + branch_target + ")";
}
else if ( ! is_none && (ei.IsDefault() || IsConditionalOp()) ) {
eval = lhs_ei + " = " + eval;
// Ensure a single terminating semicolon.
eval = regex_replace(eval, regex(";*\n"), ";\n");
}
eval = pre + eval + post;
auto full_suffix = suffix + ei.OpMarker();
GenEval(emit_target, oc_str, full_suffix, eval, zc);
if ( zc == ZIC_VEC ) {
string dispatch_params = "frame[z.v1].AsVectorRef(), frame[z.v2].AsVector()";
if ( Arity() == 2 )
dispatch_params += ", frame[z.v3].AsVector()";
auto op_code = g->GenOpCode(this, "_" + oc_str + full_suffix);
auto dispatch = "vec_exec(" + op_code + ", Z_TYPE, " + dispatch_params + ", z);";
GenEval(Eval, oc_str, full_suffix, dispatch, zc);
}
}
}
void ZAM_UnaryExprOpTemplate::Parse(const string& attr, const string& line, const Words& words) {
if ( attr == "no-const" ) {
if ( words.size() != 1 )
g->Gripe("extraneous argument to no-const", line);
SetNoConst();
}
else
ZAM_ExprOpTemplate::Parse(attr, line, words);
}
void ZAM_UnaryExprOpTemplate::Instantiate() {
UnaryInstantiate();
OCVec ocs = {ZAM_OC_VAR, ZAM_OC_CONSTANT};
if ( ! NoConst() )
InstantiateC1(ocs, 1);
ocs[1] = ZAM_OC_VAR;
InstantiateV(ocs);
}
void ZAM_UnaryExprOpTemplate::BuildInstruction(const OCVec& oc, const string& params, const string& suffix,
ZAM_InstClass zc) {
const auto& ets = ExprTypes();
if ( ets.size() == 1 && ets.count(ZAM_TYPE_NONE) == 1 ) {
ZAM_ExprOpTemplate::BuildInstruction(oc, params, suffix, zc);
return;
}
auto constant_op = oc[1] == ZAM_OC_CONSTANT;
string type_src = constant_op ? "c" : "n2";
if ( oc[0] == ZAM_OC_ASSIGN_FIELD ) {
type_src = constant_op ? "n" : "n1";
Emit("auto " + type_src + " = flhs->GetOp1()->AsNameExpr();");
Emit("const auto& t = flhs->GetType();");
}
else {
if ( IsAssignOp() )
type_src = constant_op ? "n" : "n1";
auto type_suffix = zc == ZIC_VEC ? "->Yield();" : ";";
Emit("const auto& t = " + type_src + "->GetType()" + type_suffix);
}
BuildInstructionCore(params, suffix, zc);
if ( IsAssignOp() && IsFieldOp() )
// These can't take the type from the LHS variable, since
// that's the enclosing record and not the field within it.
Emit("z.SetType(t);");
else if ( zc == ZIC_VEC ) {
if ( constant_op )
Emit("z.SetType(n->GetType());");
else
Emit("z.SetType(n1->GetType());");
}
}
ZAM_AssignOpTemplate::ZAM_AssignOpTemplate(ZAMGen* _g, string _base_name)
: ZAM_UnaryExprOpTemplate(_g, std::move(_base_name)) {
// Assignments apply to every valid form of ExprType.
for ( auto& etn : type_names ) {
auto zt = etn.second;
if ( zt != ZAM_TYPE_NONE && zt != ZAM_TYPE_DEFAULT )
AddExprType(zt);
}
}
void ZAM_AssignOpTemplate::Parse(const string& attr, const string& line, const Words& words) {
if ( attr == "field-op" ) {
if ( words.size() != 1 )
g->Gripe("field-op does not take any arguments", line);
SetFieldOp();
}
else
ZAM_OpTemplate::Parse(attr, line, words);
}
void ZAM_AssignOpTemplate::Instantiate() {
if ( op_classes.size() != 1 )
Gripe("operation needs precisely one \"type\"");
if ( ! op_classes_vec.empty() )
Gripe("operation cannot use \"classes\"");
OCVec ocs;
ocs.push_back(op_classes[0]);
// Build constant/variable versions ...
ocs.push_back(ZAM_OC_CONSTANT);
if ( ocs[0] == ZAM_OC_RECORD_FIELD || ocs[0] == ZAM_OC_ASSIGN_FIELD )
ocs.push_back(ZAM_OC_INT);
InstantiateOp(ocs, false);
if ( IsFieldOp() )
InstantiateC1(ocs, 1);
ocs[1] = ZAM_OC_VAR;
InstantiateOp(ocs, false);
// ... and for assignments to fields, additional field versions.
if ( ocs[0] == ZAM_OC_ASSIGN_FIELD ) {
ocs.push_back(ZAM_OC_INT);
InstantiateOp(ocs, false);
ocs[1] = ZAM_OC_CONSTANT;
InstantiateOp(ocs, false);
}
else if ( IsFieldOp() )
InstantiateV(ocs);
}
void ZAM_BinaryExprOpTemplate::Instantiate() {
// As usual, the first slot receives the operator's result.
OCVec ocs = {ZAM_OC_VAR};
ocs.resize(3);
// Build each combination for constant/variable operand,
// except skip constant/constant as that is always folded.
// We only include vector operations when both operands
// are non-constants.
ocs[1] = ZAM_OC_CONSTANT;
ocs[2] = ZAM_OC_VAR;
InstantiateOp(ocs, false);
if ( ! IsInternalOp() )
InstantiateC1(ocs, 2);
ocs[1] = ZAM_OC_VAR;
ocs[2] = ZAM_OC_CONSTANT;
InstantiateOp(ocs, false);
if ( ! IsInternalOp() )
InstantiateC2(ocs, 2);
ocs[2] = ZAM_OC_VAR;
InstantiateOp(ocs, IncludesVectorOp());
if ( ! IsInternalOp() )
InstantiateV(ocs);
}
void ZAM_BinaryExprOpTemplate::BuildInstruction(const OCVec& oc, const string& params, const string& suffix,
ZAM_InstClass zc) {
auto constant_op = oc[1] == ZAM_OC_CONSTANT;
string type_src = constant_op ? "c" : "n2";
auto type_suffix = zc == ZIC_VEC ? "->Yield();" : ";";
Emit("const auto& t = " + type_src + "->GetType()" + type_suffix);
GenerateSecondTypeVars(oc, zc);
BuildInstructionCore(params, suffix, zc);
if ( zc == ZIC_VEC )
Emit("z.SetType(n1->GetType());");
}
void ZAM_BinaryExprOpTemplate::GenerateSecondTypeVars(const OCVec& oc, ZAM_InstClass zc) {
auto constant_op = oc[1] == ZAM_OC_CONSTANT;
auto type_suffix = zc == ZIC_VEC ? "->Yield();" : ";";
string type_src2;
if ( zc == ZIC_COND ) {
if ( oc[0] == ZAM_OC_CONSTANT )
type_src2 = "n";
else if ( oc[1] == ZAM_OC_CONSTANT )
type_src2 = "c";
else
type_src2 = "n2";
}
else {
if ( oc[1] == ZAM_OC_CONSTANT )
type_src2 = "n2";
else if ( oc[2] == ZAM_OC_CONSTANT )
type_src2 = "c";
else
type_src2 = "n3";
}
Emit("const auto& t2 = " + type_src2 + "->GetType()" + type_suffix);
Emit("auto tag2 = t2->Tag();");
Emit("auto i_t2 = t2->InternalType();");
}
void ZAM_RelationalExprOpTemplate::Instantiate() {
ZAM_BinaryExprOpTemplate::Instantiate();
EmitTo(Cond);
Emit("case EXPR_" + cname + ":");
IndentUp();
Emit("if ( n1 && n2 )");
EmitUp("return " + cname + "VVb_cond(n1, n2);");
Emit("else if ( n1 )");
EmitUp("return " + cname + "VCb_cond(n1, c);");
Emit("else");
EmitUp("return " + cname + "CVb_cond(c, n2);");
IndentDown();
NL();
}
void ZAM_RelationalExprOpTemplate::BuildInstruction(const OCVec& oc, const string& params, const string& suffix,
ZAM_InstClass zc) {
string op1;
if ( zc == ZIC_COND ) {
if ( oc[0] == ZAM_OC_CONSTANT )
op1 = "c";
else if ( oc[1] == ZAM_OC_CONSTANT )
op1 = "n";
else
op1 = "n1";
}
else {
if ( oc[1] == ZAM_OC_CONSTANT )
op1 = "c";
else
op1 = "n2";
}
auto type_suffix = zc == ZIC_VEC ? "->Yield();" : ";";
Emit("const auto& t = " + op1 + "->GetType()" + type_suffix);
GenerateSecondTypeVars(oc, zc);
BuildInstructionCore(params, suffix, zc);
if ( zc == ZIC_VEC )
Emit("z.SetType(n1->GetType());");
}
void ZAM_InternalOpTemplate::Parse(const string& attr, const string& line, const Words& words) {
if ( attr == "num-call-args" )
ParseCall(line, words);
else if ( attr == "indirect-call" || attr == "indirect-local-call" ) {
if ( words.size() != 1 )
g->Gripe("indirect-call takes one argument", line);
// Note, currently only works with a *subsequent* num-call-args,
// whose setting needs to be 'n'.
is_indirect_call = true;
if ( attr == "indirect-local-call" )
is_local_indirect_call = true;
}
else
ZAM_OpTemplate::Parse(attr, line, words);
}
void ZAM_InternalOpTemplate::ParseCall(const string& line, const Words& words) {
if ( words.size() != 2 )
g->Gripe("num-call-args takes one argument", line);
eval = "std::vector<ValPtr> args;\n";
auto& arg = words[1];
int n = arg == "n" ? -1 : stoi(arg);
auto arg_offset = HasAssignVal() ? 1 : 0;
auto arg_slot = arg_offset + 1;
string func = "Z_AUX->func";
if ( n == 1 )
eval += "args.push_back($1.ToVal(Z_TYPE));\n";
else if ( n != 0 ) {
eval += "auto aux = Z_AUX;\n";
if ( n < 0 ) {
if ( is_indirect_call ) {
func = "func";
if ( is_local_indirect_call )
eval += "auto func = $1.AsFunc();\n";
else {
eval += "auto func_v = aux->id_val->GetVal();\n";
eval += "auto func = func_v ? func_v->AsFunc() : nullptr;\n";
}
eval += "if ( ! func )\n";
eval += "\t{\n";
eval += "\tZAM_run_time_error(Z_LOC, \"value used but not set\");\n";
eval += "\tbreak;\n";
eval += "\t}\n";
}
eval += "auto n = aux->n;\n";
eval += "args.reserve(n);\n";
eval += "for ( auto i = 0; i < n; ++i )\n";
eval += "\targs.push_back(aux->ToVal(frame, i));\n";
}
else
for ( auto i = 0; i < n; ++i ) {
eval += "args.push_back(aux->ToVal(frame, ";
eval += to_string(i);
eval += "));\n";
}
}
eval += "f->SetOnlyCall(Z_AUX->call_expr.get());\n";
eval += "ZAM_PROFILE_PRE_CALL\n";
if ( HasAssignVal() ) {
const auto& av = GetAssignVal();
eval += "auto " + av + " = " + func + "->Invoke(&args, f);\n";
eval += "if ( ! " + av + " ) { ZAM_error = true; break; }\n";
// Postpone the profiling follow-up until after we process
// the assignment.
post_eval = "ZAM_PROFILE_POST_CALL\n";
}
else {
eval += "(void) " + func + "->Invoke(&args, f);\n";
eval += "ZAM_PROFILE_POST_CALL\n";
}
}
bool TemplateInput::ScanLine(string& line) {
if ( ! put_back.empty() ) {
line = put_back;
put_back.clear();
return true;
}
char buf[8192];
// Read lines, discarding comments, which have to start at the
// beginning of a line.
do {
if ( ! fgets(buf, sizeof buf, f) )
return false;
++loc.line_num;
} while ( buf[0] == '#' );
line = buf;
return true;
}
vector<string> TemplateInput::SplitIntoWords(const string& line) const {
vector<string> words;
for ( auto start = line.c_str(); *start && *start != '\n'; ) {
auto end = start + 1;
while ( *end && ! isspace(*end) )
++end;
words.emplace_back(string(start, end - start));
start = end;
while ( *start && isspace(*start) )
++start;
}
return words;
}
string TemplateInput::SkipWords(const string& line, int n) const {
auto s = line.c_str();
for ( int i = 0; i < n; ++i ) {
// Find end of current word.
while ( *s && *s != '\n' ) {
if ( isspace(*s) )
break;
++s;
}
if ( *s == '\n' )
break;
// Find start of next word.
while ( *s && isspace(*s) )
++s;
}
return string(s);
}
void TemplateInput::Gripe(const char* msg, const string& input) const {
auto input_s = input.c_str();
size_t n = strlen(input_s);
fprintf(stderr, "%s, line %d: %s - %s", loc.file_name, loc.line_num, msg, input_s);
if ( n == 0 || input_s[n - 1] != '\n' )
fprintf(stderr, "\n");
exit(1);
}
void TemplateInput::Gripe(const char* msg, const InputLoc& l) const {
fprintf(stderr, "%s, line %d: %s\n", l.file_name, l.line_num, msg);
exit(1);
}
ZAMGen::ZAMGen(int argc, char** argv) {
auto prog_name = (argv++)[0];
if ( --argc < 1 ) {
fprintf(stderr, "usage: %s <ZAM-templates-file>\n", prog_name);
exit(1);
}
while ( argc-- > 0 ) {
auto file_name = (argv++)[0];
bool is_stdin = file_name == std::string("-");
auto f = is_stdin ? stdin : fopen(file_name, "r");
if ( ! f ) {
fprintf(stderr, "%s: cannot open \"%s\"\n", prog_name, file_name);
exit(1);
}
ti = make_unique<TemplateInput>(f, prog_name, file_name);
while ( ParseTemplate() )
;
if ( ! is_stdin )
fclose(f);
}
InitEmitTargets();
for ( auto& t : templates )
t->Instantiate();
GenMacros();
CloseEmitTargets();
}
void ZAMGen::ReadMacro(const string& line) {
vector<string> mac;
mac.emplace_back(SkipWords(line, 1));
string s;
while ( ScanLine(s) ) {
if ( s.size() <= 1 || ! isspace(s.c_str()[0]) ) {
PutBack(s);
break;
}
if ( regex_search(s, regex("\\$[$123]")) )
Gripe("macro has $-param", s);
mac.push_back(s);
}
macros.emplace_back(std::move(mac));
}
void ZAMGen::GenMacros() {
for ( auto& m : macros ) {
for ( auto i = 0U; i < m.size(); ++i ) {
auto ms = m[i];
if ( i == 0 ) {
auto name = regex_replace(ms, regex("[( ].*\n"), "");
Emit(MacroDesc, "{ \"" + name + "\",");
ms = "#define " + ms;
}
auto desc = ms;
desc.erase(desc.find('\n'));
desc = regex_replace(desc, regex("\\\\"), "\\\\");
desc = regex_replace(desc, regex("\""), "\\\"");
if ( i < m.size() - 1 ) {
ms = regex_replace(ms, regex("\n"), " \\\n");
desc.append(" \\\\\\n");
}
Emit(MacroDesc, " \"" + desc + "\"");
if ( i == m.size() - 1 )
Emit(MacroDesc, "},");
Emit(EvalMacros, ms);
}
Emit(EvalMacros, "\n");
}
}
string ZAMGen::GenOpCode(const ZAM_OpTemplate* op_templ, const string& suffix, ZAM_InstClass zc) {
auto op = "OP_" + op_templ->CanonicalName() + suffix;
static unordered_set<string> known_opcodes;
if ( known_opcodes.count(op) > 0 )
// We've already done this one, don't re-define its auxiliary
// information.
return op;
known_opcodes.insert(op);
IndentUp();
// Generate the enum defining the opcode ...
Emit(OpDef, op + ",");
// ... the "flavor" of how it treats its first operand ...
auto op_comment = ",\t// " + op;
auto op1_always_read = (zc == ZIC_FIELD || zc == ZIC_COND);
auto flavor = op1_always_read ? "OP1_READ" : op_templ->GetOp1Flavor();
Emit(Op1Flavor, flavor + op_comment);
// ... whether it has side effects ...
auto se = op_templ->HasSideEffects() ? "true" : "false";
Emit(OpSideEffects, se + op_comment);
// ... and the switch case that maps the enum to a string
// representation.
auto name = op_templ->BaseName();
transform(name.begin(), name.end(), name.begin(), ::tolower);
name += suffix;
transform(name.begin(), name.end(), name.begin(), under_to_dash);
Emit(OpName, "case " + op + ":\treturn \"" + name + "\";");
IndentDown();
return op;
}
void ZAMGen::Emit(EmitTarget et, const string& s) {
assert(et != None);
if ( gen_files.count(et) == 0 ) {
fprintf(stderr, "bad generation file type\n");
exit(1);
}
FILE* f = gen_files[et];
for ( auto i = indent_level; i > 0; --i )
fputc('\t', f);
if ( string_lit ) {
fputc('"', f);
for ( auto sp = s.c_str(); *sp; ++sp ) {
if ( *sp == '\\' )
fputs("\\\\", f);
else if ( *sp == '"' )
fputs("\\\"", f);
else if ( *sp == '\n' )
fputs("\\n", f);
else
fputc(*sp, f);
}
fputc('"', f);
}
else
fputs(s.c_str(), f);
if ( ! no_NL && (s.empty() || s.back() != '\n') )
fputc('\n', f);
}
void ZAMGen::InitEmitTargets() {
// Maps an EmitTarget enum to its corresponding filename.
static const unordered_map<EmitTarget, const char*> gen_file_names = {
{None, nullptr},
{AssignFlavor, "ZAM-AssignFlavorsDefs.h"},
{C1Def, "ZAM-GenExprsDefsC1.h"},
{C1FieldDef, "ZAM-GenFieldsDefsC1.h"},
{C2Def, "ZAM-GenExprsDefsC2.h"},
{C2FieldDef, "ZAM-GenFieldsDefsC2.h"},
{C3Def, "ZAM-GenExprsDefsC3.h"},
{Cond, "ZAM-Conds.h"},
{DirectDef, "ZAM-DirectDefs.h"},
{Eval, "ZAM-EvalDefs.h"},
{EvalMacros, "ZAM-EvalMacros.h"},
{MacroDesc, "ZAM-MacroDesc.h"},
{MethodDecl, "ZAM-MethodDecls.h"},
{MethodDef, "ZAM-MethodDefs.h"},
{Op1Flavor, "ZAM-Op1FlavorsDefs.h"},
{OpDef, "ZAM-OpsDefs.h"},
{OpDesc, "ZAM-OpDesc.h"},
{OpName, "ZAM-OpsNamesDefs.h"},
{OpSideEffects, "ZAM-OpSideEffects.h"},
{VDef, "ZAM-GenExprsDefsV.h"},
{VFieldDef, "ZAM-GenFieldsDefsV.h"},
{Vec1Eval, "ZAM-Vec1EvalDefs.h"},
{Vec2Eval, "ZAM-Vec2EvalDefs.h"},
};
for ( auto& gfn : gen_file_names ) {
auto fn = gfn.second;
if ( ! fn )
continue;
auto f = fopen(fn, "w");
if ( ! f ) {
fprintf(stderr, "can't open generation file %s\n", fn);
exit(1);
}
gen_files[gfn.first] = f;
}
// Avoid bugprone-branch-clone warnings from clang-tidy in generated code.
Emit(OpName, "// NOLINTBEGIN(bugprone-branch-clone)");
Emit(Eval, "// NOLINTBEGIN(bugprone-branch-clone)");
Emit(EvalMacros, "// NOLINTBEGIN(bugprone-macro-parentheses)");
Emit(EvalMacros, "// NOLINTBEGIN(cppcoreguidelines-macro-usage)");
InitSwitch(C1Def, "C1 assignment");
InitSwitch(C2Def, "C2 assignment");
InitSwitch(C3Def, "C3 assignment");
InitSwitch(VDef, "V assignment");
InitSwitch(C1FieldDef, "C1 field assignment");
InitSwitch(C2FieldDef, "C2 field assignment");
InitSwitch(VFieldDef, "V field assignment");
}
void ZAMGen::InitSwitch(EmitTarget et, string desc) {
Emit(et, "{");
Emit(et, "switch ( rhs->Tag() ) {");
switch_targets[et] = std::move(desc);
}
void ZAMGen::CloseEmitTargets() {
FinishSwitches();
Emit(OpName, "// NOLINTEND(bugprone-branch-clone)");
Emit(Eval, "// NOLINTEND(bugprone-branch-clone)");
Emit(EvalMacros, "// NOLINTEND(cppcoreguidelines-macro-usage)");
Emit(EvalMacros, "// NOLINTEND(bugprone-macro-parentheses)");
for ( auto& gf : gen_files )
fclose(gf.second);
}
void ZAMGen::FinishSwitches() {
for ( auto& st : switch_targets ) {
auto et = st.first;
auto& desc = st.second;
Emit(et, "default:");
IndentUp();
Emit(et, "reporter->InternalError(\"inconsistency in " + desc + ": %s\", obj_desc(rhs).c_str());");
IndentDown();
Emit(et, "}");
Emit(et, "}");
}
}
bool ZAMGen::ParseTemplate() {
string line;
if ( ! ScanLine(line) )
return false;
if ( line.size() <= 1 )
// A blank line - no template to parse.
return true;
auto words = SplitIntoWords(line);
if ( words.size() < 2 )
Gripe("too few words at start of template", line);
const auto& op = words[0];
if ( op == "macro" ) {
ReadMacro(line);
return true;
}
const auto& op_name = words[1];
// We track issues with the wrong number of template arguments
// up front, to avoid misinvoking constructors, but we don't
// report these until later because if the template names a
// bad operation, it's better to report that as the core problem.
const char* args_mismatch = nullptr;
if ( op == "direct-unary-op" ) {
if ( words.size() != 3 )
args_mismatch = "direct-unary-op takes 2 arguments";
}
else if ( words.size() != 2 )
args_mismatch = "templates take 1 argument";
unique_ptr<ZAM_OpTemplate> t;
if ( op == "op" )
t = make_unique<ZAM_OpTemplate>(this, op_name);
else if ( op == "unary-op" )
t = make_unique<ZAM_UnaryOpTemplate>(this, op_name);
else if ( op == "direct-unary-op" && ! args_mismatch )
t = make_unique<ZAM_DirectUnaryOpTemplate>(this, op_name, words[2]);
else if ( op == "assign-op" )
t = make_unique<ZAM_AssignOpTemplate>(this, op_name);
else if ( op == "expr-op" )
t = make_unique<ZAM_ExprOpTemplate>(this, op_name);
else if ( op == "unary-expr-op" )
t = make_unique<ZAM_UnaryExprOpTemplate>(this, op_name);
else if ( op == "binary-expr-op" )
t = make_unique<ZAM_BinaryExprOpTemplate>(this, op_name);
else if ( op == "rel-expr-op" )
t = make_unique<ZAM_RelationalExprOpTemplate>(this, op_name);
else if ( op == "internal-op" )
t = make_unique<ZAM_InternalOpTemplate>(this, op_name);
else if ( op == "predicate-op" ) {
t = make_unique<ZAM_InternalOpTemplate>(this, op_name);
t->SetIsPredicate();
}
else if ( op == "internal-assignment-op" )
t = make_unique<ZAM_InternalAssignOpTemplate>(this, op_name);
else
Gripe("bad template name", op);
if ( args_mismatch )
Gripe(args_mismatch, line);
t->Build();
templates.emplace_back(std::move(t));
return true;
}
int main(int argc, char** argv) {
try {
ZAMGen zg(argc, argv);
exit(0);
} catch ( const std::regex_error& e ) {
fprintf(stderr, "%s: regular expression error - %s\n", argv[0], e.what());
exit(1);
}
}
Reference in a new issue View git blame Copy permalink