Changeset 238804 in webkit


Ignore:
Timestamp:
Dec 3, 2018, 9:57:51 AM (6 years ago)
Author:
mark.lam@apple.com
Message:

Fix the bytecode code generator scripts to pretty print BytecodeStructs.h and BytecodeIndices.h.
​https://bugs.webkit.org/show_bug.cgi?id=192271

Reviewed by Keith Miller.

This makes the generated code style compliant and human readable.

  • generator/Argument.rb:
  • generator/DSL.rb:
  • generator/Fits.rb:
  • generator/Metadata.rb:
  • generator/Opcode.rb:
Location:
trunk/Source/JavaScriptCore
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r238791 r238804  
     12018-12-03  Mark Lam  <mark.lam@apple.com>
     2
     3        Fix the bytecode code generator scripts to pretty print BytecodeStructs.h and BytecodeIndices.h.
     4        https://bugs.webkit.org/show_bug.cgi?id=192271
     5
     6        Reviewed by Keith Miller.
     7
     8        This makes the generated code style compliant and human readable.
     9
     10        * generator/Argument.rb:
     11        * generator/DSL.rb:
     12        * generator/Fits.rb:
     13        * generator/Metadata.rb:
     14        * generator/Opcode.rb:
     15
    1162018-12-02  Zalan Bujtas  <zalan@apple.com>
    217

  • trunk/Source/JavaScriptCore/generator/Argument.rb

    r238414 r238804  
    6161    def setter
    6262        <<-EOF
    63         template<typename Functor>
    64         void set#{capitalized_name}(#{@type.to_s} value, Functor func)
    65         {
    66             if (isWide())
    67                 set#{capitalized_name}<OpcodeSize::Wide>(value, func);
    68             else
    69                 set#{capitalized_name}<OpcodeSize::Narrow>(value, func);
    70         }
     63    template<typename Functor>
     64    void set#{capitalized_name}(#{@type.to_s} value, Functor func)
     65    {
     66        if (isWide())
     67            set#{capitalized_name}<OpcodeSize::Wide>(value, func);
     68        else
     69            set#{capitalized_name}<OpcodeSize::Narrow>(value, func);
     70    }
    7171
    72         template <OpcodeSize size, typename Functor>
    73         void set#{capitalized_name}(#{@type.to_s} value, Functor func)
    74         {
    75             if (!#{Fits::check "size", "value", @type})
    76                 value = func();
    77             auto* stream = bitwise_cast<typename TypeBySize<size>::type*>(reinterpret_cast<uint8_t*>(this) + #{@index} * size + PaddingBySize<size>::value);
    78             *stream = #{Fits::convert "size", "value", @type};
    79         }
    80         EOF
     72    template <OpcodeSize size, typename Functor>
     73    void set#{capitalized_name}(#{@type.to_s} value, Functor func)
     74    {
     75        if (!#{Fits::check "size", "value", @type})
     76            value = func();
     77        auto* stream = bitwise_cast<typename TypeBySize<size>::type*>(reinterpret_cast<uint8_t*>(this) + #{@index} * size + PaddingBySize<size>::value);
     78        *stream = #{Fits::convert "size", "value", @type};
     79    }
     80EOF
    8181    end
    8282

  • trunk/Source/JavaScriptCore/generator/DSL.rb

    r238761 r238804  
    115115
    116116            template.prefix = <<-EOF
    117             #pragma once
     117#pragma once
    118118
    119             #include "ArithProfile.h"
    120             #include "BytecodeDumper.h"
    121             #include "BytecodeGenerator.h"
    122             #include "Fits.h"
    123             #include "GetByIdMetadata.h"
    124             #include "Instruction.h"
    125             #include "Opcode.h"
    126             #include "ToThisStatus.h"
     119#include "ArithProfile.h"
     120#include "BytecodeDumper.h"
     121#include "BytecodeGenerator.h"
     122#include "Fits.h"
     123#include "GetByIdMetadata.h"
     124#include "Instruction.h"
     125#include "Opcode.h"
     126#include "ToThisStatus.h"
    127127
    128             namespace JSC {
    129             EOF
     128namespace JSC {
     129EOF
    130130
    131131            template.body = <<-EOF
    132             #{opcodes.map(&:struct).join("\n")}
    133 
    134             #{Opcode.dump_bytecode(opcodes)}
    135             EOF
    136 
     132#{opcodes.map(&:struct).join("\n")}
     133#{Opcode.dump_bytecode(opcodes)}
     134EOF
    137135            template.suffix = "} // namespace JSC"
    138136        end
    … …  
    153151
    154152        GeneratedFile::create(indices_filename, bytecode_list) do |template|
    155             template.prefix = "namespace JSC {"
     153            template.prefix = "namespace JSC {\n"
    156154            template.body = opcodes.map(&:struct_indices).join("\n")
    157             template.suffix = "} // namespace JSC"
     155            template.suffix = "\n} // namespace JSC"
    158156        end
    159157    end

  • trunk/Source/JavaScriptCore/generator/Fits.rb

    r237547 r238804  
    3232
    3333    def self.write(size, name, type)
    34         "__generator->write(#{convert(size, name, type)});"
     34        "gen->write(#{convert(size, name, type)});"
    3535    end
    3636end

  • trunk/Source/JavaScriptCore/generator/Metadata.rb

    r237734 r238804  
    4343        return if empty?
    4444
    45         def convertFields(fields)
     45        def convertFields(prefix, fields)
    4646            fields.map do |field, type|
    4747                if type.kind_of? Hash
    48                     "union {\n#{convertFields(type)}\n};"
     48                    "#{prefix}union {\n#{convertFields(prefix + '    ', type)}\n#{prefix}};"
    4949                else
    50                     "#{type.to_s} #{field.to_s};"
     50                    "#{prefix}#{type.to_s} #{field.to_s};"
    5151                end
    5252            end.join("\n")
    5353        end
    5454
    55         fields = convertFields(@fields)
     55        fields = convertFields("        ", @fields)
    5656
    5757        inits = nil
    5858        if @initializers && (not @initializers.empty?)
    59             inits = ": " + @initializers.map do |metadata, arg|
     59            inits = "\n            : " + @initializers.map do |metadata, arg|
    6060                "#{metadata}(__op.#{arg})"
    61             end.join(", ")
     61            end.join("\n            , ").concat("\n       ");
    6262        end
    6363
    6464        <<-EOF
    65         struct Metadata {
    66             WTF_MAKE_NONCOPYABLE(Metadata);
    6765
    68         public:
    69             Metadata(const #{op.capitalized_name}&#{" __op" if inits})
    70             #{inits}
    71             { }
     66    struct Metadata {
     67        WTF_MAKE_NONCOPYABLE(Metadata);
    7268
    73             #{fields}
    74         };
    75         EOF
     69    public:
     70        Metadata(const #{op.capitalized_name}&#{" __op" if inits})#{inits} { }
     71
     72#{fields}
     73    };
     74EOF
    7675    end
    7776
    … …  
    8079
    8180        <<-EOF
    82         Metadata& metadata(CodeBlock* codeBlock) const
    83         {
    84             return codeBlock->metadata<Metadata>(opcodeID, #{Metadata.field_name});
    85         }
    8681
    87         Metadata& metadata(ExecState* exec) const
    88         {
    89             return metadata(exec->codeBlock());
    90         }
    91         EOF
     82    Metadata& metadata(CodeBlock* codeBlock) const
     83    {
     84        return codeBlock->metadata<Metadata>(opcodeID, #{Metadata.field_name});
     85    }
     86
     87    Metadata& metadata(ExecState* exec) const
     88    {
     89        return metadata(exec->codeBlock());
     90    }
     91EOF
    9292    end
    9393
    94     def field
     94    def field(prefix)
    9595        return if empty?
    9696
    97         "unsigned #{Metadata.field_name};"
     97        "\n#{prefix}unsigned #{Metadata.field_name};"
    9898    end
    9999
    … …  
    107107        return if empty?
    108108
    109         <<-EOF
    110         auto #{emitter_local.name} = __generator->addMetadataFor(opcodeID);
     109        <<-EOF.chomp
     110
     111        auto #{emitter_local.name} = gen->addMetadataFor(opcodeID);
    111112        EOF
    112113    end

  • trunk/Source/JavaScriptCore/generator/Opcode.rb

    r238414 r238804  
    5757    def print_args(&block)
    5858        return if @args.nil?
    59 
    6059        @args.map(&block).join "\n"
     60    end
     61
     62    def print_members(prefix, &block)
     63        return if @args.nil?
     64        @args.map(&block).map { |arg| "#{prefix}#{arg}" }.join "\n"
    6165    end
    6266
    … …  
    7781    end
    7882
    79     def map_fields_with_size(size, &block)
     83    def map_fields_with_size(prefix, size, &block)
    8084        args = [Argument.new("opcodeID", :unsigned, 0)]
    8185        args += @args.dup if @args
    … …  
    8387            args << @metadata.emitter_local
    8488        end
    85         args.map { |arg| block.call(arg, size) }
     89        args.map { |arg| "#{prefix}#{block.call(arg, size)}" }
    8690    end
    8791
    8892    def struct
    8993        <<-EOF
    90         struct #{capitalized_name} : public Instruction {
    91             #{opcodeID}
    92 
    93             #{emitter}
    94 
    95             #{dumper}
    96 
    97             #{constructors}
    98 
    99             #{setters}
    100 
    101             #{metadata_struct_and_accessor}
    102 
    103             #{members}
    104         };
    105         EOF
     94struct #{capitalized_name} : public Instruction {
     95    #{opcodeID}
     96
     97#{emitter}
     98#{dumper}
     99#{constructors}
     100#{setters}#{metadata_struct_and_accessor}
     101#{members}
     102};
     103EOF
    106104    end
    107105
    … …  
    114112        metadata_param = @metadata.empty? ? "" : ", #{@metadata.emitter_local.create_param}"
    115113        metadata_arg = @metadata.empty? ? "" : ", #{@metadata.emitter_local.name}"
    116         <<-EOF
    117         static void emit(BytecodeGenerator* __generator#{typed_args})
    118         {
    119             __generator->recordOpcode(opcodeID);
    120             #{@metadata.create_emitter_local}
    121             emit<OpcodeSize::Narrow, NoAssert, false>(__generator#{untyped_args}#{metadata_arg}) || emit<OpcodeSize::Wide, Assert, false>(__generator#{untyped_args}#{metadata_arg});
     114        <<-EOF.chomp
     115    static void emit(BytecodeGenerator* gen#{typed_args})
     116    {
     117        gen->recordOpcode(opcodeID);#{@metadata.create_emitter_local}
     118        emit<OpcodeSize::Narrow, NoAssert, false>(gen#{untyped_args}#{metadata_arg})
     119            || emit<OpcodeSize::Wide, Assert, false>(gen#{untyped_args}#{metadata_arg});
     120    }
     121#{%{
     122    template<OpcodeSize size, FitsAssertion shouldAssert = Assert>
     123    static bool emit(BytecodeGenerator* gen#{typed_args})
     124    {#{@metadata.create_emitter_local}
     125        return emit<size, shouldAssert>(gen#{untyped_args}#{metadata_arg});
     126    }
     127} unless @metadata.empty?}
     128    template<OpcodeSize size, FitsAssertion shouldAssert = Assert, bool recordOpcode = true>
     129    static bool emit(BytecodeGenerator* gen#{typed_args}#{metadata_param})
     130    {
     131        if (recordOpcode)
     132            gen->recordOpcode(opcodeID);
     133        bool didEmit = emitImpl<size>(gen#{untyped_args}#{metadata_arg});
     134        if (shouldAssert == Assert)
     135            ASSERT(didEmit);
     136        return didEmit;
     137    }
     138
     139private:
     140    template<OpcodeSize size>
     141    static bool emitImpl(BytecodeGenerator* gen#{typed_args}#{metadata_param})
     142    {
     143        if (size == OpcodeSize::Wide)
     144            gen->alignWideOpcode();
     145        if (#{map_fields_with_size("", "size", &:fits_check).join "\n            && "}
     146            && (size == OpcodeSize::Wide ? #{op_wide.fits_check(Size::Narrow)} : true)) {
     147            if (size == OpcodeSize::Wide)
     148                #{op_wide.fits_write Size::Narrow}
     149#{map_fields_with_size("            ", "size", &:fits_write).join "\n"}
     150            return true;
    122151        }
    123 
    124         #{%{
    125         template<OpcodeSize size, FitsAssertion shouldAssert = Assert>
    126         static bool emit(BytecodeGenerator* __generator#{typed_args})
    127         {
    128             #{@metadata.create_emitter_local}
    129             return emit<size, shouldAssert>(__generator#{untyped_args}#{metadata_arg});
    130         }
    131         } unless @metadata.empty?}
    132 
    133         template<OpcodeSize size, FitsAssertion shouldAssert = Assert, bool recordOpcode = true>
    134         static bool emit(BytecodeGenerator* __generator#{typed_args}#{metadata_param})
    135         {
    136             if (recordOpcode)
    137                 __generator->recordOpcode(opcodeID);
    138             bool didEmit = emitImpl<size>(__generator#{untyped_args}#{metadata_arg});
    139             if (shouldAssert == Assert)
    140                 ASSERT(didEmit);
    141             return didEmit;
    142         }
    143 
    144         private:
    145         template<OpcodeSize size>
    146         static bool emitImpl(BytecodeGenerator* __generator#{typed_args}#{metadata_param})
    147         {
    148             if (size == OpcodeSize::Wide)
    149                 __generator->alignWideOpcode();
    150             if (#{map_fields_with_size("size", &:fits_check).join " && "} && (size == OpcodeSize::Wide ? #{op_wide.fits_check(Size::Narrow)} : true)) {
    151                 if (size == OpcodeSize::Wide)
    152                     #{op_wide.fits_write Size::Narrow}
    153                 #{map_fields_with_size("size", &:fits_write).join "\n"}
    154                 return true;
    155             }
    156             return false;
    157         }
    158         public:
    159         EOF
     152        return false;
     153    }
     154
     155public:
     156EOF
    160157    end
    161158
    162159    def dumper
    163160        <<-EOF
    164         template<typename Block>
    165         void dump(BytecodeDumper<Block>* __dumper, InstructionStream::Offset __location, bool __isWide)
    166         {
    167             __dumper->printLocationAndOp(__location, &"*#{@name}"[!__isWide]);
    168             #{print_args { |arg|
    169             <<-EOF
    170                 __dumper->dumpOperand(#{arg.name}, #{arg.index == 1});
    171             EOF
    172             }}
    173         }
    174         EOF
     161    template<typename Block>
     162    void dump(BytecodeDumper<Block>* dumper, InstructionStream::Offset __location, bool __isWide)
     163    {
     164        dumper->printLocationAndOp(__location, &"*#{@name}"[!__isWide]);
     165#{print_args { |arg|
     166<<-EOF.chomp
     167        dumper->dumpOperand(#{arg.name}, #{arg.index == 1});
     168EOF
     169    }}
     170    }
     171EOF
    175172    end
    176173
    177174    def constructors
    178175        fields = (@args || []) + (@metadata.empty? ? [] : [@metadata])
    179         init = ->(size) { fields.empty?  ? "" : ": #{fields.map.with_index { |arg, i| arg.load_from_stream(i + 1, size) }.join ",\n" }" }
     176        init = ->(size) { fields.empty?  ? "" : ": #{fields.map.with_index { |arg, i| arg.load_from_stream(i + 1, size) }.join "\n        , " }" }
    180177
    181178        <<-EOF
    182         #{capitalized_name}(const uint8_t* stream)
    183             #{init.call("OpcodeSize::Narrow")}
    184         { ASSERT_UNUSED(stream, stream[0] == opcodeID); }
    185 
    186         #{capitalized_name}(const uint32_t* stream)
    187             #{init.call("OpcodeSize::Wide")}
    188         { ASSERT_UNUSED(stream, stream[0] == opcodeID); }
    189 
    190         static #{capitalized_name} decode(const uint8_t* stream)
    191         {
    192             if (*stream != op_wide)
    193                 return { stream };
    194 
    195             auto wideStream = bitwise_cast<const uint32_t*>(stream + 1);
    196             return { wideStream };
    197         }
    198 
    199         EOF
     179    #{capitalized_name}(const uint8_t* stream)
     180        #{init.call("OpcodeSize::Narrow")}
     181    {
     182        ASSERT_UNUSED(stream, stream[0] == opcodeID);
     183    }
     184
     185    #{capitalized_name}(const uint32_t* stream)
     186        #{init.call("OpcodeSize::Wide")}
     187    {
     188        ASSERT_UNUSED(stream, stream[0] == opcodeID);
     189    }
     190
     191    static #{capitalized_name} decode(const uint8_t* stream)
     192    {
     193        if (*stream != op_wide)
     194            return { stream };
     195
     196        auto wideStream = bitwise_cast<const uint32_t*>(stream + 1);
     197        return { wideStream };
     198    }
     199EOF
    200200    end
    201201
    … …  
    205205
    206206    def metadata_struct_and_accessor
    207         <<-EOF
    208         #{@metadata.struct(self)}
    209 
    210         #{@metadata.accessor}
    211         EOF
     207        <<-EOF.chomp
     208#{@metadata.struct(self)}#{@metadata.accessor}
     209EOF
    212210    end
    213211
    214212    def members
    215         <<-EOF
    216         #{print_args(&:field)}
    217         #{@metadata.field}
    218         EOF
     213        <<-EOF.chomp
     214#{print_members("    ", &:field)}#{@metadata.field("    ")}
     215EOF
    219216    end
    220217
    … …  
    249246
    250247    def self.dump_bytecode(opcodes)
    251         <<-EOF
    252         template<typename Block>
    253         static void dumpBytecode(BytecodeDumper<Block>* __dumper, InstructionStream::Offset __location, const Instruction* __instruction)
    254         {
    255             switch (__instruction->opcodeID()) {
    256             #{opcodes.map { |op|
    257                 <<-EOF
    258                 case #{op.name}:
    259                     __instruction->as<#{op.capitalized_name}>().dump(__dumper, __location, __instruction->isWide());
    260                     break;
    261                 EOF
    262             }.join "\n"}
    263             default:
    264                 ASSERT_NOT_REACHED();
    265             }
    266         }
    267         EOF
     248        <<-EOF.chomp
     249template<typename Block>
     250static void dumpBytecode(BytecodeDumper<Block>* dumper, InstructionStream::Offset __location, const Instruction* __instruction)
     251{
     252    switch (__instruction->opcodeID()) {
     253#{opcodes.map { |op|
     254        <<-EOF.chomp
     255    case #{op.name}:
     256        __instruction->as<#{op.capitalized_name}>().dump(dumper, __location, __instruction->isWide());
     257        break;
     258EOF
     259    }.join "\n"}
     260    default:
     261        ASSERT_NOT_REACHED();
     262    }
     263}
     264EOF
    268265    end
    269266end
Note: See TracChangeset for help on using the changeset viewer.