Revision f230a1cf deps/v8/test/cctest/test-assembler-mips.cc

View differences:

deps/v8/test/cctest/test-assembler-mips.cc
49 49

  
50 50
TEST(MIPS0) {
51 51
  CcTest::InitializeVM();
52
  Isolate* isolate = Isolate::Current();
52
  Isolate* isolate = CcTest::i_isolate();
53 53
  HandleScope scope(isolate);
54 54

  
55 55
  MacroAssembler assm(isolate, NULL, 0);
......
61 61

  
62 62
  CodeDesc desc;
63 63
  assm.GetCode(&desc);
64
  Object* code = HEAP->CreateCode(
64
  Object* code = CcTest::heap()->CreateCode(
65 65
      desc,
66 66
      Code::ComputeFlags(Code::STUB),
67 67
      Handle<Code>())->ToObjectChecked();
......
75 75

  
76 76
TEST(MIPS1) {
77 77
  CcTest::InitializeVM();
78
  Isolate* isolate = Isolate::Current();
78
  Isolate* isolate = CcTest::i_isolate();
79 79
  HandleScope scope(isolate);
80 80

  
81 81
  MacroAssembler assm(isolate, NULL, 0);
......
100 100

  
101 101
  CodeDesc desc;
102 102
  assm.GetCode(&desc);
103
  Object* code = HEAP->CreateCode(
103
  Object* code = CcTest::heap()->CreateCode(
104 104
      desc,
105 105
      Code::ComputeFlags(Code::STUB),
106 106
      Handle<Code>())->ToObjectChecked();
......
114 114

  
115 115
TEST(MIPS2) {
116 116
  CcTest::InitializeVM();
117
  Isolate* isolate = Isolate::Current();
117
  Isolate* isolate = CcTest::i_isolate();
118 118
  HandleScope scope(isolate);
119 119

  
120 120
  MacroAssembler assm(isolate, NULL, 0);
......
241 241

  
242 242
  CodeDesc desc;
243 243
  assm.GetCode(&desc);
244
  Object* code = HEAP->CreateCode(
244
  Object* code = CcTest::heap()->CreateCode(
245 245
      desc,
246 246
      Code::ComputeFlags(Code::STUB),
247 247
      Handle<Code>())->ToObjectChecked();
......
256 256
TEST(MIPS3) {
257 257
  // Test floating point instructions.
258 258
  CcTest::InitializeVM();
259
  Isolate* isolate = Isolate::Current();
259
  Isolate* isolate = CcTest::i_isolate();
260 260
  HandleScope scope(isolate);
261 261

  
262 262
  typedef struct {
......
314 314

  
315 315
  CodeDesc desc;
316 316
  assm.GetCode(&desc);
317
  Object* code = HEAP->CreateCode(
317
  Object* code = CcTest::heap()->CreateCode(
318 318
      desc,
319 319
      Code::ComputeFlags(Code::STUB),
320 320
      Handle<Code>())->ToObjectChecked();
......
346 346
TEST(MIPS4) {
347 347
  // Test moves between floating point and integer registers.
348 348
  CcTest::InitializeVM();
349
  Isolate* isolate = Isolate::Current();
349
  Isolate* isolate = CcTest::i_isolate();
350 350
  HandleScope scope(isolate);
351 351

  
352 352
  typedef struct {
......
382 382

  
383 383
  CodeDesc desc;
384 384
  assm.GetCode(&desc);
385
  Object* code = HEAP->CreateCode(
385
  Object* code = CcTest::heap()->CreateCode(
386 386
      desc,
387 387
      Code::ComputeFlags(Code::STUB),
388 388
      Handle<Code>())->ToObjectChecked();
......
403 403
TEST(MIPS5) {
404 404
  // Test conversions between doubles and integers.
405 405
  CcTest::InitializeVM();
406
  Isolate* isolate = Isolate::Current();
406
  Isolate* isolate = CcTest::i_isolate();
407 407
  HandleScope scope(isolate);
408 408

  
409 409
  typedef struct {
......
448 448

  
449 449
  CodeDesc desc;
450 450
  assm.GetCode(&desc);
451
  Object* code = HEAP->CreateCode(
451
  Object* code = CcTest::heap()->CreateCode(
452 452
      desc,
453 453
      Code::ComputeFlags(Code::STUB),
454 454
      Handle<Code>())->ToObjectChecked();
......
471 471
TEST(MIPS6) {
472 472
  // Test simple memory loads and stores.
473 473
  CcTest::InitializeVM();
474
  Isolate* isolate = Isolate::Current();
474
  Isolate* isolate = CcTest::i_isolate();
475 475
  HandleScope scope(isolate);
476 476

  
477 477
  typedef struct {
......
521 521

  
522 522
  CodeDesc desc;
523 523
  assm.GetCode(&desc);
524
  Object* code = HEAP->CreateCode(
524
  Object* code = CcTest::heap()->CreateCode(
525 525
      desc,
526 526
      Code::ComputeFlags(Code::STUB),
527 527
      Handle<Code>())->ToObjectChecked();
......
544 544
TEST(MIPS7) {
545 545
  // Test floating point compare and branch instructions.
546 546
  CcTest::InitializeVM();
547
  Isolate* isolate = Isolate::Current();
547
  Isolate* isolate = CcTest::i_isolate();
548 548
  HandleScope scope(isolate);
549 549

  
550 550
  typedef struct {
......
598 598

  
599 599
  CodeDesc desc;
600 600
  assm.GetCode(&desc);
601
  Object* code = HEAP->CreateCode(
601
  Object* code = CcTest::heap()->CreateCode(
602 602
      desc,
603 603
      Code::ComputeFlags(Code::STUB),
604 604
      Handle<Code>())->ToObjectChecked();
......
622 622
TEST(MIPS8) {
623 623
  // Test ROTR and ROTRV instructions.
624 624
  CcTest::InitializeVM();
625
  Isolate* isolate = Isolate::Current();
625
  Isolate* isolate = CcTest::i_isolate();
626 626
  HandleScope scope(isolate);
627 627

  
628 628
  typedef struct {
......
697 697

  
698 698
  CodeDesc desc;
699 699
  assm.GetCode(&desc);
700
  Object* code = HEAP->CreateCode(
700
  Object* code = CcTest::heap()->CreateCode(
701 701
      desc,
702 702
      Code::ComputeFlags(Code::STUB),
703 703
      Handle<Code>())->ToObjectChecked();
......
727 727
TEST(MIPS9) {
728 728
  // Test BRANCH improvements.
729 729
  CcTest::InitializeVM();
730
  Isolate* isolate = Isolate::Current();
730
  Isolate* isolate = CcTest::i_isolate();
731 731
  HandleScope scope(isolate);
732 732

  
733 733
  MacroAssembler assm(isolate, NULL, 0);
......
745 745

  
746 746
  CodeDesc desc;
747 747
  assm.GetCode(&desc);
748
  Object* code = HEAP->CreateCode(
748
  Object* code = CcTest::heap()->CreateCode(
749 749
      desc,
750 750
      Code::ComputeFlags(Code::STUB),
751 751
      Handle<Code>())->ToObjectChecked();
......
757 757
  // Test conversions between doubles and long integers.
758 758
  // Test hos the long ints map to FP regs pairs.
759 759
  CcTest::InitializeVM();
760
  Isolate* isolate = Isolate::Current();
760
  Isolate* isolate = CcTest::i_isolate();
761 761
  HandleScope scope(isolate);
762 762

  
763 763
  typedef struct {
......
805 805

  
806 806
    CodeDesc desc;
807 807
    assm.GetCode(&desc);
808
    Object* code = HEAP->CreateCode(
808
    Object* code = CcTest::heap()->CreateCode(
809 809
        desc,
810 810
        Code::ComputeFlags(Code::STUB),
811 811
        Handle<Code>())->ToObjectChecked();
......
830 830
TEST(MIPS11) {
831 831
  // Test LWL, LWR, SWL and SWR instructions.
832 832
  CcTest::InitializeVM();
833
  Isolate* isolate = Isolate::Current();
833
  Isolate* isolate = CcTest::i_isolate();
834 834
  HandleScope scope(isolate);
835 835

  
836 836
  typedef struct {
......
938 938

  
939 939
  CodeDesc desc;
940 940
  assm.GetCode(&desc);
941
  Object* code = HEAP->CreateCode(
941
  Object* code = CcTest::heap()->CreateCode(
942 942
      desc,
943 943
      Code::ComputeFlags(Code::STUB),
944 944
      Handle<Code>())->ToObjectChecked();
......
974 974

  
975 975
TEST(MIPS12) {
976 976
  CcTest::InitializeVM();
977
  Isolate* isolate = Isolate::Current();
977
  Isolate* isolate = CcTest::i_isolate();
978 978
  HandleScope scope(isolate);
979 979

  
980 980
  typedef struct {
......
1043 1043

  
1044 1044
  CodeDesc desc;
1045 1045
  assm.GetCode(&desc);
1046
  Object* code = HEAP->CreateCode(
1046
  Object* code = CcTest::heap()->CreateCode(
1047 1047
      desc,
1048 1048
      Code::ComputeFlags(Code::STUB),
1049 1049
      Handle<Code>())->ToObjectChecked();
......
1066 1066
TEST(MIPS13) {
1067 1067
  // Test Cvt_d_uw and Trunc_uw_d macros.
1068 1068
  CcTest::InitializeVM();
1069
  Isolate* isolate = Isolate::Current();
1069
  Isolate* isolate = CcTest::i_isolate();
1070 1070
  HandleScope scope(isolate);
1071 1071

  
1072 1072
  typedef struct {
......
1100 1100

  
1101 1101
  CodeDesc desc;
1102 1102
  assm.GetCode(&desc);
1103
  Object* code = HEAP->CreateCode(
1103
  Object* code = CcTest::heap()->CreateCode(
1104 1104
      desc,
1105 1105
      Code::ComputeFlags(Code::STUB),
1106 1106
      Handle<Code>())->ToObjectChecked();
......
1125 1125
TEST(MIPS14) {
1126 1126
  // Test round, floor, ceil, trunc, cvt.
1127 1127
  CcTest::InitializeVM();
1128
  Isolate* isolate = Isolate::Current();
1128
  Isolate* isolate = CcTest::i_isolate();
1129 1129
  HandleScope scope(isolate);
1130 1130

  
1131 1131
#define ROUND_STRUCT_ELEMENT(x) \
......
1221 1221

  
1222 1222
  CodeDesc desc;
1223 1223
  assm.GetCode(&desc);
1224
  Object* code = HEAP->CreateCode(
1224
  Object* code = CcTest::heap()->CreateCode(
1225 1225
      desc,
1226 1226
      Code::ComputeFlags(Code::STUB),
1227 1227
      Handle<Code>())->ToObjectChecked();
......
1258 1258
TEST(MIPS15) {
1259 1259
  // Test chaining of label usages within instructions (issue 1644).
1260 1260
  CcTest::InitializeVM();
1261
  Isolate* isolate = Isolate::Current();
1261
  Isolate* isolate = CcTest::i_isolate();
1262 1262
  HandleScope scope(isolate);
1263 1263
  Assembler assm(isolate, NULL, 0);
1264 1264

  

Also available in: Unified diff