| #!/usr/bin/env python |
| # |
| # Copyright (C) 2017 The Android Open Source Project |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| # |
| |
| import getopt |
| import json |
| import string |
| import sys |
| |
| def generate_header_file(filename, with_guard, printer): |
| f = open(filename, 'w') |
| orig_stdout = sys.stdout |
| sys.stdout = f |
| print '// DO NOT MODIFY. AUTO-GENERATED.\n' |
| if with_guard: |
| print "#pragma once" |
| print |
| print "namespace android {" |
| print "namespace spirit {" |
| print |
| printer() |
| if with_guard: |
| print "} // namespace spirit" |
| print "} // namespace android" |
| f.close() |
| sys.stdout = orig_stdout |
| |
| |
| |
| ################################################################################ |
| # |
| # Generate Builder class: the .h and .cpp files. |
| # |
| ################################################################################ |
| |
| def factory_method_name(opname, outlined): |
| if outlined: |
| return "Builder::Make%s" % opname_noprefix(opname) |
| else: |
| return "Make%s" % opname_noprefix(opname) |
| |
| |
| |
| def factory_method_prototype(inst, outlined): |
| opname = inst['opname'] |
| operands = inst.get('operands') |
| str = "%s *%s(" % (class_name(opname), factory_method_name(opname, outlined)) |
| first = True; |
| for type, var, quantifier, comment in generate_member_list(operands): |
| if var != "mResult": |
| param = var[1:] |
| if first: |
| first = False |
| else: |
| str += ', ' |
| if quantifier == '?': |
| str += '%s *%s=nullptr' % (type, param) |
| elif quantifier == '*': |
| vecTy = "std::vector<%s>" % type |
| str += '%s %s=%s()' % (vecTy, param, vecTy) |
| else: |
| str += '%s %s' % (type, param) |
| str += ')' |
| return str |
| |
| |
| |
| def factory_method_body(inst): |
| opname = inst['opname'] |
| operands = inst.get('operands') |
| clazz = class_name(opname) |
| str = "%s *ret = new %s(" % (clazz, clazz) |
| first = True |
| for type, var, quantifier, comment in generate_member_list(operands): |
| if var != "mResult" and quantifier != '*' and quantifier != '?': |
| param = var[1:] |
| if first: |
| first = False |
| else: |
| str += ', ' |
| str += param |
| str += """); |
| if (!ret) { |
| return nullptr; |
| } |
| """ |
| str += """ |
| if (ret->hasResult()) { |
| ret->setId(Module::getCurrentModule()->nextId()); |
| } |
| """ |
| for type, var, quantifier, comment in generate_member_list(operands): |
| param = var[1:] |
| # TODO: use vector::swap() or move instead of copy |
| if quantifier == '?' or quantifier == '*': |
| str += " ret->%s = %s;\n" % (var, param) |
| str += " return ret;" |
| return str |
| |
| |
| |
| def print_factory_method(inst): |
| print """%s { |
| %s |
| }""" % (factory_method_prototype(inst, False), |
| factory_method_body(inst)) |
| |
| |
| |
| def print_factory_methods(insts): |
| for inst in insts: |
| print_factory_method(inst) |
| |
| |
| |
| ################################################################################ |
| # |
| # Generate type defintions |
| # |
| ################################################################################ |
| |
| def enum_enumerants(ty, enumerants): |
| str = "" |
| for enumerant in enumerants: |
| name = enumerant['enumerant'] |
| val = enumerant['value'] |
| if name[0].isalpha(): |
| str += " %s = %sU,\n" % (name, val) |
| else: |
| str += " %s%s = %sU,\n" % (ty, name, val) |
| return str |
| |
| |
| def generate_enum(ty): |
| typeName = ty['kind'] |
| print """enum class %s : uint32_t {\n%s}; |
| """ % (typeName, |
| enum_enumerants(typeName, ty['enumerants'])) |
| |
| |
| def generate_composite_fields(bases): |
| str = "" |
| i = 0 |
| for field in bases: |
| str += " %s mField%d;\n" % (field, i) |
| i = i + 1 |
| return str |
| |
| |
| |
| def print_type_definitions(operand_kinds): |
| for ty in operand_kinds: |
| category = ty['category'] |
| if category == 'BitEnum' or category == 'ValueEnum': |
| generate_enum(ty) |
| elif category == 'Composite': |
| print "struct %s {\n%s};\n" % (ty['kind'], |
| generate_composite_fields(ty['bases'])) |
| |
| |
| |
| ################################################################################ |
| # |
| # Generate class defintions for all instructions |
| # |
| ################################################################################ |
| |
| def opname_noprefix(opname): |
| return opname[2:] |
| |
| def class_name(opname): |
| return "%sInst" % opname_noprefix(opname) |
| |
| |
| |
| def generate_member_list(operands): |
| members = [] |
| if operands is None: |
| return members |
| index = 1 |
| for operand in operands: |
| type = operand['kind'] |
| if type == 'IdResultType' or type == 'IdResult': |
| varName = "m%s" % type[2:] |
| else: |
| varName = "mOperand%d" % index |
| index = index + 1 |
| quantifier = operand.get('quantifier') |
| comment = operand.get('name'); |
| members.append((type, varName, quantifier, comment)) |
| return members |
| |
| def fixed_word_count(member_list): |
| wc = 1 # for the first word of opcode and word count |
| for type, var, quant, comment in member_list: |
| if quant != '?' and quant != '*': |
| wc += 1 |
| return wc |
| |
| def string_for_members(opname, member_list): |
| if member_list == []: |
| return "" |
| member_str = "\n static constexpr OpCode mOpCode=%s;\n" % opname |
| for type, var, quantifier, comment in member_list: |
| if comment is not None and comment.find('\n') != -1: |
| member_str += " /* %s\n */\n" % comment |
| member_str += " " |
| if quantifier == '?': |
| type = type + '*'; |
| elif quantifier == '*': |
| type = 'std::vector<%s>' % type; |
| member_str += "%s %s;" % (type, var) |
| if comment is not None and comment.find('\n') == -1: |
| member_str += " // %s" % comment |
| member_str += "\n" |
| return member_str |
| |
| def string_for_constructor(opname, opcode, members): |
| # Default constructor |
| initializer = "Instruction(%s, %d)" % (opname, fixed_word_count(members)) |
| first = True |
| for type, var, quantifier, comment in members: |
| if quantifier == '?': |
| initializer += ", %s(nullptr)" % var |
| str = "%s() : %s {}" % (class_name(opname), initializer) |
| |
| # Constructor with values for members |
| if members == [] or (len(members) == 1 and members[0][0]=='IdResult'): |
| return str |
| nonOptionalOperandExists = False |
| for type, var, quantifier, comment in members: |
| if quantifier is None: |
| nonOptionalOperandExists = True |
| if not nonOptionalOperandExists: |
| return str |
| params = "" |
| initializer = "Instruction(%s, %d)" % (opname, fixed_word_count(members)) |
| first = True |
| for type, var, quantifier, comment in members: |
| if var != "mResult" and quantifier != '*': |
| initializer += ", " |
| if quantifier == '?': |
| initializer += "%s(nullptr)" % var |
| else: |
| if first: |
| first = False |
| else: |
| params += ", " |
| param = var[1:] # remove the prefix "m" |
| params += "%s %s" % (type, param) |
| initializer += "%s(%s)" % (var, param) |
| if params != "": |
| str += "\n %s(%s) :\n %s {}" % (class_name(opname), params, initializer) |
| str += "\n virtual ~%s() {}" % class_name(opname) |
| return str |
| |
| def string_for_serializer_body(opcode, members): |
| body = "setWordCount();\n" |
| body += " OS << mCodeAndCount;\n" |
| for type, var, quantifier, comment in members: |
| if quantifier == '?': |
| body += " if (%s!=nullptr) { OS << *%s; }\n" % (var, var) |
| elif quantifier == '*': |
| body += """ for (auto val : %s) { OS << val; }\n""" % var |
| else: |
| body += " OS << %s;\n" % var |
| body += " SerializeExtraOperands(OS);\n" |
| return body |
| |
| def string_for_deserializer_body(name, members): |
| body = "return DeserializeFirstWord(IS, %s)" % name |
| for type, var, quantifier, comment in members: |
| body += " &&\n " |
| if quantifier == '?': |
| body += "DeserializeOptionallyOne(IS, &%s)" % var |
| elif quantifier == '*': |
| body += "DeserializeZeroOrMoreOperands(IS, &%s)" % var |
| else: |
| body += "DeserializeExactlyOne(IS, &%s)" % var |
| body += " &&\n DeserializeExtraOperands(IS);\n" |
| return body |
| |
| def string_for_get_word_count(members): |
| str = """uint16_t getWordCount() const override { |
| uint16_t count = mFixedWordCount;\n""" |
| for type, var, quantifier, comment in members: |
| if quantifier == '?': |
| str += " if (%s) count += WordCount(*%s);\n" % (var, var) |
| elif quantifier == '*': |
| str += " if (!%s.empty()) count += WordCount(%s[0]) * %s.size();\n" % (var, var, var) |
| elif type == 'LiteralString': |
| str += " count += WordCount(%s) - 1;\n" % var |
| |
| str += """ count += mExtraOperands.size(); |
| return count; |
| }""" |
| return str |
| |
| def string_for_accept(): |
| return """ |
| void accept(IVisitor *v) override { v->visit(this); } |
| """ |
| |
| def has_result(members): |
| for type, val, quantifier, comment in members: |
| if type == 'IdResult': |
| return True |
| return False |
| |
| |
| def string_for_has_result(hasResult): |
| if hasResult: |
| retVal = "true" |
| else: |
| retVal = "false" |
| return "bool hasResult() const override { return %s; }" % retVal |
| |
| def string_for_get_all_refs(members): |
| str = """std::vector<const IdRef*> getAllIdRefs() const override { |
| std::vector<const IdRef*> ret = {""" |
| first = True |
| # TODO: what if references are in * operands? |
| for type, var, quantifier, comment in members: |
| if type == 'IdRef' or type == 'IdResultType' or type == 'IdMemorySemantics' or type == 'IdScope': |
| if quantifier == '*': |
| pass |
| else: |
| if first: |
| first = False |
| else: |
| str += ", " |
| if quantifier == '?': |
| str += "%s" % var |
| else: |
| str += "&%s" % var |
| str += """}; |
| """ |
| for type, var, quantifier, comment in members: |
| if type == 'IdRef' or type == 'IdResultType' or type == 'IdMemorySemantics' or type == 'IdScope': |
| if quantifier == '*': |
| str+=""" |
| for(const auto &ref : %s) { |
| ret.push_back(&ref); |
| } |
| """ % var |
| str += """ |
| return ret; |
| }""" |
| return str |
| |
| def string_for_get_set_id(hasResult): |
| if hasResult: |
| return """IdResult getId() const override { return mResult; } |
| void setId(IdResult id) override { mResult = id; }""" |
| else: |
| retVal = "0" |
| return """IdResult getId() const override { return 0; } |
| void setId(IdResult) override {}""" |
| |
| |
| def print_instruction_class(inst): |
| opname = inst['opname'] |
| opcode = inst['opcode'] |
| operands = inst.get('operands') |
| members = generate_member_list(operands) |
| hasResult = has_result(members) |
| print """class %s : public Instruction { |
| public: |
| %s |
| |
| void Serialize(OutputWordStream &OS) const override { |
| %s } |
| |
| bool DeserializeInternal(InputWordStream &IS) override { |
| %s } |
| |
| void accept(IVisitor *v) override { v->visit(this); } |
| |
| %s |
| |
| %s |
| |
| %s |
| |
| %s |
| %s}; |
| """ % (class_name(opname), |
| string_for_constructor(opname, opcode, members), |
| string_for_serializer_body(opcode, members), |
| string_for_deserializer_body(opname, members), |
| string_for_get_word_count(members), |
| string_for_has_result(hasResult), |
| string_for_get_set_id(hasResult), |
| string_for_get_all_refs(members), |
| string_for_members(opname, members)) |
| |
| def print_all_instruction_classes(insts): |
| for inst in insts: |
| print_instruction_class(inst) |
| |
| ################################################################################ |
| # |
| # Generate opcode enum |
| # |
| ################################################################################ |
| |
| def print_opcode_enum(insts): |
| print "enum OpCode {" |
| for inst in insts: |
| opname = inst['opname'] |
| opcode = inst['opcode'] |
| print " %s = %d," % (opname, opcode) |
| print "};" |
| |
| |
| |
| ################################################################################ |
| # |
| # Generate dispatching code |
| # |
| ################################################################################ |
| |
| def print_dispatches(insts): |
| for inst in insts: |
| opname = inst['opname'] |
| print "HANDLE_INSTRUCTION(%s,%s)" % (opname, class_name(opname)) |
| |
| def print_type_inst_dispatches(insts): |
| for inst in insts: |
| opname = inst['opname'] |
| if opname[:6] == "OpType": |
| print "HANDLE_INSTRUCTION(%s, %s)" % (opname, class_name(opname)) |
| |
| def print_const_inst_dispatches(insts): |
| for inst in insts: |
| opname = inst['opname'] |
| if opname[:10] == "OpConstant": |
| print "HANDLE_INSTRUCTION(%s, %s)" % (opname, class_name(opname)) |
| |
| def print_enum_dispatches(operand_kinds): |
| for ty in operand_kinds: |
| category = ty['category'] |
| if category == 'BitEnum' or category == 'ValueEnum': |
| print "HANDLE_ENUM(%s)" % ty['kind'] |
| |
| |
| |
| ################################################################################ |
| # |
| # main |
| # |
| ################################################################################ |
| |
| def main(): |
| try: |
| opts, args = getopt.getopt(sys.argv[2:],"h",["instructions=", |
| "types=", |
| "opcodes=", |
| "instruction_dispatches=", |
| "enum_dispatches=", |
| "type_inst_dispatches=", |
| "const_inst_dispatches=", |
| "factory_methods="]) |
| except getopt.GetoptError: |
| print sys.argv[0], '' |
| sys.exit(2) |
| |
| with open(sys.argv[1]) as grammar_file: |
| grammar = json.load(grammar_file) |
| |
| instructions = grammar['instructions'] |
| |
| for opt, arg in opts: |
| if opt == "--instructions": |
| generate_header_file(arg, True, lambda: print_all_instruction_classes(instructions)) |
| elif opt == "--types": |
| kinds = grammar['operand_kinds'] |
| generate_header_file(arg, True, lambda: print_type_definitions(kinds)) |
| elif opt == "--opcodes": |
| generate_header_file(arg, True, lambda: print_opcode_enum(instructions)) |
| elif opt == "--instruction_dispatches": |
| generate_header_file(arg, False, lambda: print_dispatches(instructions)) |
| elif opt == "--enum_dispatches": |
| kinds = grammar['operand_kinds'] |
| generate_header_file(arg, False, lambda: print_enum_dispatches(kinds)) |
| elif opt == "--type_inst_dispatches": |
| generate_header_file(arg, False, lambda: print_type_inst_dispatches(instructions)) |
| elif opt == "--const_inst_dispatches": |
| generate_header_file(arg, False, lambda: print_const_inst_dispatches(instructions)) |
| elif opt == "--factory_methods": |
| generate_header_file(arg, False, lambda: print_factory_methods(instructions)) |
| |
| if __name__ == '__main__': |
| main() |
