OLD | NEW |
1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file |
2 // for details. All rights reserved. Use of this source code is governed by a | 2 // for details. All rights reserved. Use of this source code is governed by a |
3 // BSD-style license that can be found in the LICENSE file. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
5 #include "platform/globals.h" | 5 #include "platform/globals.h" |
6 | 6 |
7 #include "vm/assembler.h" | 7 #include "vm/assembler.h" |
8 #include "vm/class_finalizer.h" | 8 #include "vm/class_finalizer.h" |
9 #include "vm/dart_api_impl.h" | 9 #include "vm/dart_api_impl.h" |
10 #include "vm/dart_entry.h" | 10 #include "vm/dart_entry.h" |
11 #include "vm/debugger.h" | 11 #include "vm/debugger.h" |
12 #include "vm/isolate.h" | 12 #include "vm/isolate.h" |
13 #include "vm/object.h" | 13 #include "vm/object.h" |
14 #include "vm/object_store.h" | 14 #include "vm/object_store.h" |
15 #include "vm/simulator.h" | 15 #include "vm/simulator.h" |
16 #include "vm/symbols.h" | 16 #include "vm/symbols.h" |
17 #include "vm/unit_test.h" | 17 #include "vm/unit_test.h" |
| 18 #include "vm/code_descriptors.h" |
18 | 19 |
19 namespace dart { | 20 namespace dart { |
20 | 21 |
21 DECLARE_FLAG(bool, write_protect_code); | 22 DECLARE_FLAG(bool, write_protect_code); |
22 | 23 |
23 static RawLibrary* CreateDummyLibrary(const String& library_name) { | 24 static RawLibrary* CreateDummyLibrary(const String& library_name) { |
24 return Library::New(library_name); | 25 return Library::New(library_name); |
25 } | 26 } |
26 | 27 |
27 | 28 |
(...skipping 2830 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2858 EXPECT(!handlers.HasCatchAll(0)); | 2859 EXPECT(!handlers.HasCatchAll(0)); |
2859 EXPECT_EQ(20u, info.handler_pc_offset); | 2860 EXPECT_EQ(20u, info.handler_pc_offset); |
2860 EXPECT_EQ(1, handlers.OuterTryIndex(3)); | 2861 EXPECT_EQ(1, handlers.OuterTryIndex(3)); |
2861 EXPECT_EQ(150u, handlers.HandlerPCOffset(3)); | 2862 EXPECT_EQ(150u, handlers.HandlerPCOffset(3)); |
2862 EXPECT(!handlers.NeedsStacktrace(3)); | 2863 EXPECT(!handlers.NeedsStacktrace(3)); |
2863 EXPECT(handlers.HasCatchAll(3)); | 2864 EXPECT(handlers.HasCatchAll(3)); |
2864 } | 2865 } |
2865 | 2866 |
2866 | 2867 |
2867 TEST_CASE(PcDescriptors) { | 2868 TEST_CASE(PcDescriptors) { |
2868 const int kNumEntries = 6; | 2869 DescriptorList* builder = new DescriptorList(0); |
2869 // Add PcDescriptors to the code. | 2870 |
| 2871 // kind, pc_offset, deopt_id, token_pos, try_index |
| 2872 builder->AddDescriptor(RawPcDescriptors::kOther, 10, 1, 20, 1); |
| 2873 builder->AddDescriptor(RawPcDescriptors::kDeopt, 20, 2, 30, 0); |
| 2874 builder->AddDescriptor(RawPcDescriptors::kOther, 30, 3, 40, 1); |
| 2875 builder->AddDescriptor(RawPcDescriptors::kOther, 10, 4, 40, 2); |
| 2876 builder->AddDescriptor(RawPcDescriptors::kOther, 10, 5, 80, 3); |
| 2877 builder->AddDescriptor(RawPcDescriptors::kOther, 80, 6, 150, 3); |
| 2878 |
2870 PcDescriptors& descriptors = PcDescriptors::Handle(); | 2879 PcDescriptors& descriptors = PcDescriptors::Handle(); |
2871 descriptors ^= PcDescriptors::New(kNumEntries, true); | 2880 descriptors ^= builder->FinalizePcDescriptors(0); |
2872 descriptors.AddDescriptor(0, 10, RawPcDescriptors::kOther, 1, 20, 1); | |
2873 descriptors.AddDescriptor(1, 20, RawPcDescriptors::kDeopt, 2, 30, 0); | |
2874 descriptors.AddDescriptor(2, 30, RawPcDescriptors::kOther, 3, 40, 1); | |
2875 descriptors.AddDescriptor(3, 10, RawPcDescriptors::kOther, 4, 40, 2); | |
2876 descriptors.AddDescriptor(4, 10, RawPcDescriptors::kOther, 5, 80, 3); | |
2877 descriptors.AddDescriptor(5, 80, RawPcDescriptors::kOther, 6, 150, 3); | |
2878 | 2881 |
2879 extern void GenerateIncrement(Assembler* assembler); | 2882 extern void GenerateIncrement(Assembler* assembler); |
2880 Assembler _assembler_; | 2883 Assembler _assembler_; |
2881 GenerateIncrement(&_assembler_); | 2884 GenerateIncrement(&_assembler_); |
2882 Code& code = Code::Handle(Code::FinalizeCode( | 2885 Code& code = Code::Handle(Code::FinalizeCode( |
2883 *CreateFunction("Test_Code"), &_assembler_)); | 2886 *CreateFunction("Test_Code"), &_assembler_)); |
2884 code.set_pc_descriptors(descriptors); | 2887 code.set_pc_descriptors(descriptors); |
2885 | 2888 |
2886 // Verify the PcDescriptor entries by accessing them. | 2889 // Verify the PcDescriptor entries by accessing them. |
2887 const PcDescriptors& pc_descs = PcDescriptors::Handle(code.pc_descriptors()); | 2890 const PcDescriptors& pc_descs = PcDescriptors::Handle(code.pc_descriptors()); |
(...skipping 24 matching lines...) Expand all Loading... |
2912 | 2915 |
2913 EXPECT_EQ(3, iter.TryIndex()); | 2916 EXPECT_EQ(3, iter.TryIndex()); |
2914 EXPECT_EQ(static_cast<uword>(80), iter.PcOffset()); | 2917 EXPECT_EQ(static_cast<uword>(80), iter.PcOffset()); |
2915 EXPECT_EQ(150, iter.TokenPos()); | 2918 EXPECT_EQ(150, iter.TokenPos()); |
2916 EXPECT_EQ(RawPcDescriptors::kOther, iter.Kind()); | 2919 EXPECT_EQ(RawPcDescriptors::kOther, iter.Kind()); |
2917 | 2920 |
2918 EXPECT_EQ(false, iter.MoveNext()); | 2921 EXPECT_EQ(false, iter.MoveNext()); |
2919 } | 2922 } |
2920 | 2923 |
2921 | 2924 |
2922 TEST_CASE(PcDescriptorsCompressed) { | 2925 TEST_CASE(PcDescriptorsLargeDeltas) { |
2923 const int kNumEntries = 6; | 2926 DescriptorList* builder = new DescriptorList(0); |
2924 // Add PcDescriptors to the code. | 2927 |
| 2928 // kind, pc_offset, deopt_id, token_pos, try_index |
| 2929 builder->AddDescriptor(RawPcDescriptors::kOther, 100, 1, 200, 1); |
| 2930 builder->AddDescriptor(RawPcDescriptors::kDeopt, 200, 2, 300, 0); |
| 2931 builder->AddDescriptor(RawPcDescriptors::kOther, 300, 3, 400, 1); |
| 2932 builder->AddDescriptor(RawPcDescriptors::kOther, 100, 4, 0, 2); |
| 2933 builder->AddDescriptor(RawPcDescriptors::kOther, 100, 5, 800, 3); |
| 2934 builder->AddDescriptor(RawPcDescriptors::kOther, 800, 6, 150, 3); |
| 2935 |
2925 PcDescriptors& descriptors = PcDescriptors::Handle(); | 2936 PcDescriptors& descriptors = PcDescriptors::Handle(); |
2926 // PcDescriptors have no try-index. | 2937 descriptors ^= builder->FinalizePcDescriptors(0); |
2927 descriptors ^= PcDescriptors::New(kNumEntries, false); | |
2928 descriptors.AddDescriptor(0, 10, RawPcDescriptors::kOther, 1, 20, -1); | |
2929 descriptors.AddDescriptor(1, 20, RawPcDescriptors::kDeopt, 2, 30, -1); | |
2930 descriptors.AddDescriptor(2, 30, RawPcDescriptors::kOther, 3, 40, -1); | |
2931 descriptors.AddDescriptor(3, 10, RawPcDescriptors::kOther, 4, 40, -1); | |
2932 descriptors.AddDescriptor(4, 10, RawPcDescriptors::kOther, 5, 80, -1); | |
2933 descriptors.AddDescriptor(5, 80, RawPcDescriptors::kOther, 6, 150, -1); | |
2934 | 2938 |
2935 extern void GenerateIncrement(Assembler* assembler); | 2939 extern void GenerateIncrement(Assembler* assembler); |
2936 Assembler _assembler_; | 2940 Assembler _assembler_; |
2937 GenerateIncrement(&_assembler_); | 2941 GenerateIncrement(&_assembler_); |
2938 Code& code = Code::Handle(Code::FinalizeCode( | 2942 Code& code = Code::Handle(Code::FinalizeCode( |
2939 *CreateFunction("Test_Code"), &_assembler_)); | 2943 *CreateFunction("Test_Code"), &_assembler_)); |
2940 code.set_pc_descriptors(descriptors); | 2944 code.set_pc_descriptors(descriptors); |
2941 | 2945 |
2942 // Verify the PcDescriptor entries by accessing them. | 2946 // Verify the PcDescriptor entries by accessing them. |
2943 const PcDescriptors& pc_descs = PcDescriptors::Handle(code.pc_descriptors()); | 2947 const PcDescriptors& pc_descs = PcDescriptors::Handle(code.pc_descriptors()); |
2944 PcDescriptors::Iterator iter(pc_descs, RawPcDescriptors::kAnyKind); | 2948 PcDescriptors::Iterator iter(pc_descs, RawPcDescriptors::kAnyKind); |
2945 | 2949 |
2946 EXPECT_EQ(true, iter.MoveNext()); | 2950 EXPECT_EQ(true, iter.MoveNext()); |
2947 EXPECT_EQ(static_cast<uword>(10), iter.PcOffset()); | 2951 EXPECT_EQ(200, iter.TokenPos()); |
2948 EXPECT_EQ(-1, iter.TryIndex()); | 2952 EXPECT_EQ(1, iter.TryIndex()); |
| 2953 EXPECT_EQ(static_cast<uword>(100), iter.PcOffset()); |
2949 EXPECT_EQ(1, iter.DeoptId()); | 2954 EXPECT_EQ(1, iter.DeoptId()); |
2950 EXPECT_EQ(20, iter.TokenPos()); | 2955 EXPECT_EQ(RawPcDescriptors::kOther, iter.Kind()); |
2951 | 2956 |
2952 EXPECT_EQ(true, iter.MoveNext()); | 2957 EXPECT_EQ(true, iter.MoveNext()); |
| 2958 EXPECT_EQ(300, iter.TokenPos()); |
| 2959 EXPECT_EQ(RawPcDescriptors::kDeopt, iter.Kind()); |
| 2960 |
2953 EXPECT_EQ(true, iter.MoveNext()); | 2961 EXPECT_EQ(true, iter.MoveNext()); |
| 2962 EXPECT_EQ(400, iter.TokenPos()); |
| 2963 |
2954 EXPECT_EQ(true, iter.MoveNext()); | 2964 EXPECT_EQ(true, iter.MoveNext()); |
| 2965 EXPECT_EQ(0, iter.TokenPos()); |
| 2966 |
2955 EXPECT_EQ(true, iter.MoveNext()); | 2967 EXPECT_EQ(true, iter.MoveNext()); |
| 2968 EXPECT_EQ(800, iter.TokenPos()); |
| 2969 |
2956 EXPECT_EQ(true, iter.MoveNext()); | 2970 EXPECT_EQ(true, iter.MoveNext()); |
| 2971 EXPECT_EQ(150, iter.TokenPos()); |
2957 | 2972 |
2958 EXPECT_EQ(-1, iter.TryIndex()); | 2973 EXPECT_EQ(3, iter.TryIndex()); |
2959 EXPECT_EQ(static_cast<uword>(80), iter.PcOffset()); | 2974 EXPECT_EQ(static_cast<uword>(800), iter.PcOffset()); |
2960 EXPECT_EQ(150, iter.TokenPos()); | 2975 EXPECT_EQ(150, iter.TokenPos()); |
| 2976 EXPECT_EQ(RawPcDescriptors::kOther, iter.Kind()); |
2961 | 2977 |
2962 EXPECT_EQ(false, iter.MoveNext()); | 2978 EXPECT_EQ(false, iter.MoveNext()); |
2963 } | 2979 } |
2964 | 2980 |
2965 | 2981 |
2966 | |
2967 static RawClass* CreateTestClass(const char* name) { | 2982 static RawClass* CreateTestClass(const char* name) { |
2968 const String& class_name = String::Handle(Symbols::New(name)); | 2983 const String& class_name = String::Handle(Symbols::New(name)); |
2969 const Class& cls = Class::Handle( | 2984 const Class& cls = Class::Handle( |
2970 CreateDummyClass(class_name, Script::Handle())); | 2985 CreateDummyClass(class_name, Script::Handle())); |
2971 return cls.raw(); | 2986 return cls.raw(); |
2972 } | 2987 } |
2973 | 2988 |
2974 | 2989 |
2975 static RawField* CreateTestField(const char* name) { | 2990 static RawField* CreateTestField(const char* name) { |
2976 const Class& cls = Class::Handle(CreateTestClass("global:")); | 2991 const Class& cls = Class::Handle(CreateTestClass("global:")); |
(...skipping 1601 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4578 EXPECT_VALID(h_result); | 4593 EXPECT_VALID(h_result); |
4579 Integer& result = Integer::Handle(); | 4594 Integer& result = Integer::Handle(); |
4580 result ^= Api::UnwrapHandle(h_result); | 4595 result ^= Api::UnwrapHandle(h_result); |
4581 String& foo = String::Handle(String::New("foo")); | 4596 String& foo = String::Handle(String::New("foo")); |
4582 Integer& expected = Integer::Handle(); | 4597 Integer& expected = Integer::Handle(); |
4583 expected ^= foo.HashCode(); | 4598 expected ^= foo.HashCode(); |
4584 EXPECT(result.IsIdenticalTo(expected)); | 4599 EXPECT(result.IsIdenticalTo(expected)); |
4585 } | 4600 } |
4586 | 4601 |
4587 } // namespace dart | 4602 } // namespace dart |
OLD | NEW |