Bug 757375: Selftest regeneration for workers integration CL@1111530
authorBrent Baker <brbaker@adobe.com>
Thu, 04 Oct 2012 05:47:58 -0700
changeset 7559 22eb6ca016af12c342fbcf283b6de23cf29ce550
parent 7558 9cdb18e9a83325ee36ea0fb7970c01c14f419d38
child 7560 b30f9228398aa8265657e67ea9c513d2387880b6
push id4260
push userdschaffe@adobe.com
push dateFri, 05 Oct 2012 17:33:23 +0000
bugs757375, 1111530, 757076, 1091218, 716548, 1111602, 1120756
Bug 757375: Selftest regeneration for workers integration CL@1111530 Bug 757076: Selftest regeneration for making page protection check optional CL@1091218 Bug 716548: Selftest regeneration for updating license in tamarin source code to MPL2 CL@1111602 CL@1120756
extensions/ST_nanojit_codealloc.st
extensions/ST_workers_Promise.st
extensions/SelftestExec.cpp
--- a/extensions/ST_nanojit_codealloc.st
+++ b/extensions/ST_nanojit_codealloc.st
@@ -121,17 +121,21 @@ void CodeAllocDriver::makeCodeList(uint3
 }
 
 // Repeatedly construct and destroy codelists.
 // We maintain a pool of codelists.  On each iteration, we replace one
 // of the existing codelists with a new one, freeing the old.
 
 void CodeAllocDriver::run(uint32_t iterations)
 {
-    CodeAlloc alloc;
+    nanojit::Config config;
+    // Enable page protection flag checking during test code
+    config.check_page_flags = true;
+
+    CodeAlloc alloc(&config);
 
     CodeList** codelists = mmfx_new_array(CodeList*, n_active);
 
     VMPI_memset(codelists, 0, n_active * sizeof(CodeList*));
 
     for (uint32_t i = 0; i < iterations; i++) {
         uint32_t victim = rand.range(0, n_active);
         alloc.freeAll(codelists[victim]);
--- a/extensions/ST_workers_Promise.st
+++ b/extensions/ST_workers_Promise.st
@@ -16,11 +16,11 @@
 
 %%test MainWorker
     // verify the main worker can be retrieved from AvmCore
     %%verify main!=NULL
     uint32_t state=main->getAggregate()->queryState(main);
     // verify state == RUNNING
     %%verify state==3
 
-    %%verify main->targetCore() == core
+    %%verify main->getAvmCore() == core
     %%verify main->isParentOf(main) == false
 
--- a/extensions/SelftestExec.cpp
+++ b/extensions/SelftestExec.cpp
@@ -1,15 +1,16 @@
+// Generated from ST_avmplus_basics.st, ST_avmplus_builtins.st, ST_avmplus_peephole.st, ST_avmplus_vector_accessors.st, ST_mmgc_543560.st, ST_mmgc_575631.st, ST_mmgc_580603.st, ST_mmgc_603411.st, ST_mmgc_637993.st, ST_mmgc_basics.st, ST_mmgc_dependent.st, ST_mmgc_exact.st, ST_mmgc_externalalloc.st, ST_mmgc_finalize_uninit.st, ST_mmgc_fixedmalloc_findbeginning.st, ST_mmgc_gcheap.st, ST_mmgc_gcoption.st, ST_mmgc_mmfx_array.st, ST_mmgc_threads.st, ST_mmgc_weakref.st, ST_nanojit_codealloc.st, ST_vmbase_concurrency.st, ST_vmbase_safepoints.st, ST_vmpi_threads.st, ST_workers_Buffer.st, ST_workers_NoSyncSingleItemBuffer.st, ST_workers_Promise.st
 // Generated from ST_avmplus_basics.st
 // -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
 // vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
 //
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 #include "avmshell.h"
 #ifdef VMCFG_SELFTEST
 namespace avmplus {
 namespace ST_avmplus_basics {
 class ST_avmplus_basics : public Selftest {
 public:
 ST_avmplus_basics(AvmCore* core);
@@ -41,60 +42,60 @@ case 4: test4(); return;
 case 5: test5(); return;
 case 6: test6(); return;
 case 7: test7(); return;
 }
 }
 void ST_avmplus_basics::test0() {
 
 // Does right shift of unsigned quantities work?
-// line 47 "ST_avmplus_basics.st"
+// line 14 "ST_avmplus_basics.st"
 verifyPass((int)(~0U >> 1) > 0, "(int)(~0U >> 1) > 0", __FILE__, __LINE__);
 
 }
 void ST_avmplus_basics::test1() {
 
 // Does right shift of signed quantities work?
-// line 52 "ST_avmplus_basics.st"
+// line 19 "ST_avmplus_basics.st"
 verifyPass((-1 >> 1) == -1, "(-1 >> 1) == -1", __FILE__, __LINE__);
 
 // verify that the "latin1" literal string calls work properly for hi-bit latin1 chars
 }
 void ST_avmplus_basics::test2() {
     Stringp s = core->newConstantStringLatin1("ev\xADident");
     bool equals = s->equalsLatin1("ev\xADident");
-// line 58 "ST_avmplus_basics.st"
+// line 25 "ST_avmplus_basics.st"
 verifyPass(equals == true, "equals == true", __FILE__, __LINE__);
 
 }
 void ST_avmplus_basics::test3() {
     Stringp s = core->newConstantStringLatin1("ev\xADident");
     bool found = s->containsLatin1("\xAD");
-// line 63 "ST_avmplus_basics.st"
+// line 30 "ST_avmplus_basics.st"
 verifyPass(found == true, "found == true", __FILE__, __LINE__);
 
 }
 void ST_avmplus_basics::test4() {
     Stringp s = core->newConstantStringLatin1("ev\xADident");
     int index = s->indexOfLatin1("\xAD");
-// line 68 "ST_avmplus_basics.st"
+// line 35 "ST_avmplus_basics.st"
 verifyPass(index == 2, "index == 2", __FILE__, __LINE__);
 
 }
 void ST_avmplus_basics::test5() {
     Stringp s = core->newConstantStringLatin1("ev\xADident");
     bool matches1 = s->matchesLatin1("\xADi", 2, 2);
-// line 73 "ST_avmplus_basics.st"
+// line 40 "ST_avmplus_basics.st"
 verifyPass(matches1 == true, "matches1 == true", __FILE__, __LINE__);
 
 }
 void ST_avmplus_basics::test6() {
     Stringp s = core->newConstantStringLatin1("ev\xADident");
     bool matches2 = s->matchesLatin1_caseless("\xADIDENT", 2, 2);
-// line 78 "ST_avmplus_basics.st"
+// line 45 "ST_avmplus_basics.st"
 verifyPass(matches2 == true, "matches2 == true", __FILE__, __LINE__);
 
 
 }
 void ST_avmplus_basics::test7() {
 // XMLParser omits the last char of a DOCTYPE node
 Stringp str = core->newConstantStringLatin1("<?xml version=\"1.0\"?><!DOCTYPE greeting SYSTEM><greeting>Hello, world!</greeting>");
 XMLParser parser(core, str);
@@ -109,17 +110,17 @@ while ((m_status = parser.getNext(tag)) 
         case XMLTag::kDocTypeDeclaration:
         {
             pass = false;
             pass = tag.text->equalsLatin1("<!DOCTYPE greeting SYSTEM>");
         }
     break;
     }
 }
-// line 101 "ST_avmplus_basics.st"
+// line 68 "ST_avmplus_basics.st"
 verifyPass(pass == true, "pass == true", __FILE__, __LINE__);
 
     // FIXME: this needs a "register this object with the GC" mechanism; this abuse of the GCRoot mechanism
     // is no longer allowed
 //%%test bug610022
 //    Stringp str = core->newConstantStringLatin1("some string that is likely to be unique");
 //    WeakRefList<String> list(core->GetGC(), 0);
     // We are going to skip scanning the stack (so that "str" won't hold the string in place)
@@ -139,19 +140,20 @@ verifyPass(pass == true, "pass == true",
 void create_avmplus_basics(AvmCore* core) { new ST_avmplus_basics(core); }
 }
 }
 #endif
 
 // Generated from ST_avmplus_builtins.st
 // -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
 // vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 #include "avmshell.h"
 #ifdef VMCFG_SELFTEST
 namespace avmplus {
 namespace ST_avmplus_builtins {
 class ST_avmplus_builtins : public Selftest {
 public:
 ST_avmplus_builtins(AvmCore* core);
@@ -186,32 +188,32 @@ void ST_avmplus_builtins::test0() {
         Atom a = tbl->get(atomFromIntptrValue(i));
         if (a != AtomConstants::undefinedAtom)
             sum++;
     }
     core->gc->UnlockObject(fhtagn_lock);
     printf("fhtagn sum: %d\n", sum);
 
 // Retain at least 250, but it would be unreasonable to retain more than 300
-// line 64 "ST_avmplus_builtins.st"
+// line 31 "ST_avmplus_builtins.st"
 verifyPass(sum >= 250 && sum <= 300, "sum >= 250 && sum <= 300", __FILE__, __LINE__);
 
 }
 void create_avmplus_builtins(AvmCore* core) { new ST_avmplus_builtins(core); }
 }
 }
 #endif
 
 // Generated from ST_avmplus_peephole.st
 // -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
 // vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
 //
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 #include "avmshell.h"
 #ifdef VMCFG_SELFTEST
 #if defined AVMPLUS_PEEPHOLE_OPTIMIZER
 namespace avmplus {
 namespace ST_avmplus_peephole {
 class ST_avmplus_peephole : public Selftest {
 public:
@@ -261,48 +263,48 @@ void ST_avmplus_peephole::test0() {
      t->emitOp1(WOP_getlocal, 5);
      t->emitOp1(WOP_getlocal, 4);
      t->emitOp1(WOP_getlocal, 65536);
      t->emitOp1(WOP_getlocal, 7);
      t->emitOp1(WOP_getlocal, 6);
      uintptr_t* code;
 uint32_t len = (uint32_t)t->epilogue(&code);
 
-// line 76 "ST_avmplus_peephole.st"
+// line 43 "ST_avmplus_peephole.st"
 verifyPass(len == 6, "len == 6", __FILE__, __LINE__);
-// line 77 "ST_avmplus_peephole.st"
+// line 44 "ST_avmplus_peephole.st"
 verifyPass(code[0] == NEW_OPCODE(WOP_get2locals), "code[0] == NEW_OPCODE(WOP_get2locals)", __FILE__, __LINE__);
-// line 78 "ST_avmplus_peephole.st"
+// line 45 "ST_avmplus_peephole.st"
 verifyPass(code[1] == ((4 << 16) | 5), "code[1] == ((4 << 16) | 5)", __FILE__, __LINE__);
-// line 79 "ST_avmplus_peephole.st"
+// line 46 "ST_avmplus_peephole.st"
 verifyPass(code[2] == NEW_OPCODE(WOP_getlocal), "code[2] == NEW_OPCODE(WOP_getlocal)", __FILE__, __LINE__);
-// line 80 "ST_avmplus_peephole.st"
+// line 47 "ST_avmplus_peephole.st"
 verifyPass(code[3] == 65536, "code[3] == 65536", __FILE__, __LINE__);
-// line 81 "ST_avmplus_peephole.st"
+// line 48 "ST_avmplus_peephole.st"
 verifyPass(code[4] == NEW_OPCODE(WOP_get2locals), "code[4] == NEW_OPCODE(WOP_get2locals)", __FILE__, __LINE__);
-// line 82 "ST_avmplus_peephole.st"
+// line 49 "ST_avmplus_peephole.st"
 verifyPass(code[5] == ((6 << 16) | 7), "code[5] == ((6 << 16) | 7)", __FILE__, __LINE__);
 
     delete t;
 
 
 }
 void create_avmplus_peephole(AvmCore* core) { new ST_avmplus_peephole(core); }
 }
 }
 #endif
 #endif
 
 // Generated from ST_avmplus_vector_accessors.st
 // -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
 // vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
 //
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 // Bugzilla 609145 - VectorObject needs fast inline getter/setters
 // Make sure the APIs, which are used by the Flash Player and AIR only, do not disappear.
 //
 // NOTE, the following comment is stale and we can fix the code, see the code for
 // VectorAccessor further down for how to access a toplevel.
 //
 // We can't test them because we don't have access to a Toplevel*, but we can reference
@@ -349,46 +351,46 @@ case 0: test0(); return;
 case 1: test1(); return;
 case 2: test2(); return;
 case 3: test3(); return;
 case 4: test4(); return;
 }
 }
 void ST_avmplus_vector_accessors::test0() {
 
-// line 69 "ST_avmplus_vector_accessors.st"
+// line 36 "ST_avmplus_vector_accessors.st"
 verifyPass(true, "true", __FILE__, __LINE__);
 
 }
 void ST_avmplus_vector_accessors::test1() {
 
 DataList<int> dl(core->GetGC(), 3);
 dl.add(1);
 dl.add(1);
 dl.add(2);
 dl.add(3);
 dl.add(5);
 dl.add(8);
 dl.add(13);
 DataListAccessor<int> dla(&dl);
 int* xs = dla.addr();
 
-// line 84 "ST_avmplus_vector_accessors.st"
+// line 51 "ST_avmplus_vector_accessors.st"
 verifyPass(xs[0] == 1, "xs[0] == 1", __FILE__, __LINE__);
-// line 85 "ST_avmplus_vector_accessors.st"
+// line 52 "ST_avmplus_vector_accessors.st"
 verifyPass(xs[1] == 1, "xs[1] == 1", __FILE__, __LINE__);
-// line 86 "ST_avmplus_vector_accessors.st"
+// line 53 "ST_avmplus_vector_accessors.st"
 verifyPass(xs[2] == 2, "xs[2] == 2", __FILE__, __LINE__);
-// line 87 "ST_avmplus_vector_accessors.st"
+// line 54 "ST_avmplus_vector_accessors.st"
 verifyPass(xs[3] == 3, "xs[3] == 3", __FILE__, __LINE__);
-// line 88 "ST_avmplus_vector_accessors.st"
+// line 55 "ST_avmplus_vector_accessors.st"
 verifyPass(xs[4] == 5, "xs[4] == 5", __FILE__, __LINE__);
-// line 89 "ST_avmplus_vector_accessors.st"
+// line 56 "ST_avmplus_vector_accessors.st"
 verifyPass(xs[5] == 8, "xs[5] == 8", __FILE__, __LINE__);
-// line 90 "ST_avmplus_vector_accessors.st"
+// line 57 "ST_avmplus_vector_accessors.st"
 verifyPass(xs[6] == 13, "xs[6] == 13", __FILE__, __LINE__);
 
 }
 void ST_avmplus_vector_accessors::test2() {
 
 #ifdef VMCFG_FLOAT
 
 DataList<float4_t, 16> dl4(core->GetGC(), 3);
@@ -396,26 +398,26 @@ float4_t x0 = { 1,1,2,3 };
 float4_t x1 = { 5,8,13,21 };
 float4_t x2 = { 34,55,89,144 };
 dl4.add(x0);
 dl4.add(x1);
 dl4.add(x2);
 DataListAccessor<float4_t,16> dla4(&dl4);
 float4_t* x4s = dla4.addr();
 
-// line 106 "ST_avmplus_vector_accessors.st"
+// line 73 "ST_avmplus_vector_accessors.st"
 verifyPass(f4_eq_i(x4s[0], x0) == 1, "f4_eq_i(x4s[0], x0) == 1", __FILE__, __LINE__);
-// line 107 "ST_avmplus_vector_accessors.st"
+// line 74 "ST_avmplus_vector_accessors.st"
 verifyPass(f4_eq_i(x4s[1], x1) == 1, "f4_eq_i(x4s[1], x1) == 1", __FILE__, __LINE__);
-// line 108 "ST_avmplus_vector_accessors.st"
+// line 75 "ST_avmplus_vector_accessors.st"
 verifyPass(f4_eq_i(x4s[2], x2) == 1, "f4_eq_i(x4s[2], x2) == 1", __FILE__, __LINE__);
 
 #else
 
-// line 112 "ST_avmplus_vector_accessors.st"
+// line 79 "ST_avmplus_vector_accessors.st"
 verifyPass(true, "true", __FILE__, __LINE__);
 
 #endif
 
 }
 void ST_avmplus_vector_accessors::test3() {
 
 #ifdef AVMSHELL_BUILD
@@ -430,34 +432,34 @@ vec->_setNativeUintProperty(2, 2);
 vec->_setNativeUintProperty(3, 3);
 vec->_setNativeUintProperty(4, 5);
 vec->_setNativeUintProperty(5, 8);
 vec->_setNativeUintProperty(6, 13);
 
 IntVectorAccessor va(vec);
 int* xs = va.addr();
 
-// line 135 "ST_avmplus_vector_accessors.st"
+// line 102 "ST_avmplus_vector_accessors.st"
 verifyPass(xs[0] == 1, "xs[0] == 1", __FILE__, __LINE__);
-// line 136 "ST_avmplus_vector_accessors.st"
+// line 103 "ST_avmplus_vector_accessors.st"
 verifyPass(xs[1] == 1, "xs[1] == 1", __FILE__, __LINE__);
-// line 137 "ST_avmplus_vector_accessors.st"
+// line 104 "ST_avmplus_vector_accessors.st"
 verifyPass(xs[2] == 2, "xs[2] == 2", __FILE__, __LINE__);
-// line 138 "ST_avmplus_vector_accessors.st"
+// line 105 "ST_avmplus_vector_accessors.st"
 verifyPass(xs[3] == 3, "xs[3] == 3", __FILE__, __LINE__);
-// line 139 "ST_avmplus_vector_accessors.st"
+// line 106 "ST_avmplus_vector_accessors.st"
 verifyPass(xs[4] == 5, "xs[4] == 5", __FILE__, __LINE__);
-// line 140 "ST_avmplus_vector_accessors.st"
+// line 107 "ST_avmplus_vector_accessors.st"
 verifyPass(xs[5] == 8, "xs[5] == 8", __FILE__, __LINE__);
-// line 141 "ST_avmplus_vector_accessors.st"
+// line 108 "ST_avmplus_vector_accessors.st"
 verifyPass(xs[6] == 13, "xs[6] == 13", __FILE__, __LINE__);
 
 #else
 
-// line 145 "ST_avmplus_vector_accessors.st"
+// line 112 "ST_avmplus_vector_accessors.st"
 verifyPass(true, "true", __FILE__, __LINE__);
 
 #endif // AVMSHELL_BUILD
 
 }
 void ST_avmplus_vector_accessors::test4() {
 
 #if defined VMCFG_FLOAT && defined AVMSHELL_BUILD
@@ -472,43 +474,43 @@ float4_t x2 = { 34,55,89,144 };
 
 vec->_setNativeUintProperty(0, x0);
 vec->_setNativeUintProperty(1, x1);
 vec->_setNativeUintProperty(2, x2);
 
 Float4VectorAccessor va(vec);
 float4_t* x4s = va.addr();
 
-// line 168 "ST_avmplus_vector_accessors.st"
+// line 135 "ST_avmplus_vector_accessors.st"
 verifyPass(f4_eq_i(x4s[0], x0) == 1, "f4_eq_i(x4s[0], x0) == 1", __FILE__, __LINE__);
-// line 169 "ST_avmplus_vector_accessors.st"
+// line 136 "ST_avmplus_vector_accessors.st"
 verifyPass(f4_eq_i(x4s[1], x1) == 1, "f4_eq_i(x4s[1], x1) == 1", __FILE__, __LINE__);
-// line 170 "ST_avmplus_vector_accessors.st"
+// line 137 "ST_avmplus_vector_accessors.st"
 verifyPass(f4_eq_i(x4s[2], x2) == 1, "f4_eq_i(x4s[2], x2) == 1", __FILE__, __LINE__);
 
 #else
 
-// line 174 "ST_avmplus_vector_accessors.st"
+// line 141 "ST_avmplus_vector_accessors.st"
 verifyPass(true, "true", __FILE__, __LINE__);
 
 #endif // AVMSHELL_BUILD
 
 }
 void create_avmplus_vector_accessors(AvmCore* core) { new ST_avmplus_vector_accessors(core); }
 }
 }
 #endif
 
 // Generated from ST_mmgc_543560.st
 // -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
 // vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
 //
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 // Bugzilla 543560 - here we risk deleting an object that is still on the mark stack because
 // of how we perform large-object splitting.  The setup is that user code that deletes the object
 // gets to run after the first part of the large object has been popped off the mark stack
 // but before the rest has been handled.
 
 #include "avmshell.h"
 #ifdef VMCFG_SELFTEST
@@ -649,34 +651,34 @@ void ST_mmgc_bugzilla_543560::test0() {
                 MMgc::GCHeap::GetGCHeap()->Decommit();
             }
         }
 
     }
     delete theRoot;
 
     // Will crash if it fails so the %%verify is just token
-// line 168 "ST_mmgc_543560.st"
+// line 135 "ST_mmgc_543560.st"
 verifyPass(true, "true", __FILE__, __LINE__);
 
 }
 void create_mmgc_bugzilla_543560(AvmCore* core) { new ST_mmgc_bugzilla_543560(core); }
 }
 }
 #endif
 #endif
 #endif
 
 // Generated from ST_mmgc_575631.st
 // -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
 // vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5)
 //
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 // Bugzilla 565631 - We occasionally interleave invoking finalizers
 // and clearing mark bits in GCAlloc::Finalize; so a finalizer can
 // observe a live object that does not have its mark bit set.
 //
 // This complicates things because we want to ensure that unmarked
 // weakly-referenced objects are resurrected by the GC if the weak
 // reference is dereferenced during presweep, but we do not want to
@@ -776,49 +778,49 @@ void ST_mmgc_bugzilla_575631::test0() {
     int delta = compute_stride(arr_len, destructs);
 
     for (int i=0; i < arr_len; i += delta) {
         objs[i] = NULL;
         collect2();
     }
 
     // not assert failing within get() is passing the test.
-// line 132 "ST_mmgc_575631.st"
+// line 99 "ST_mmgc_575631.st"
 verifyPass(1, "1", __FILE__, __LINE__);
           ; // (make my auto-indenter happy)
 
     // cleanup code; letting ~Snoopy occur outside test extent is big no-no.
     {
         for (int i=0; i < arr_len; ++i ) {
             if (! refs[i]->isNull())
                 delete objs[i];
         }
 
         // if something went wrong above and some Snoopy's are still alive,
         // we'll get burned during their destructors.  Make sure that
         // does not happen.
-// line 145 "ST_mmgc_575631.st"
+// line 112 "ST_mmgc_575631.st"
 verifyPass((Snoopy::alive_count == 0), "(Snoopy::alive_count == 0)", __FILE__, __LINE__);
               ;
     }
 }
 
 }
 void create_mmgc_bugzilla_575631(AvmCore* core) { new ST_mmgc_bugzilla_575631(core); }
 }
 }
 #endif
 
 // Generated from ST_mmgc_580603.st
 // -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
 // vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
 //
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 // Bugzilla 580603 - adversarial mmgc: dispersive w.r.t. address space
 // Bugzilla 445780 - Page map needs to be sparse
 // 
 // Tommy: "problems in 64-bit linux b/c VMPI_allocateAlignedMemory provides
 // memory from low 32 bit-addresses, and mmap is giving us addresses from
 // 0x7fxxxxxxxxxxxxxx so we need a 4 GB page map."
 //
@@ -1063,17 +1065,17 @@ void ST_mmgc_bugzilla_580603::test0() {
     my_free(h[1], via_heap);
     // print_minmax();
 
     char *g[m_num_iters*m_num_sizes]; (void)g;
     do_allocs(g, via_heap);
 
     // print_minmax();
 
-// line 275 "ST_mmgc_580603.st"
+// line 242 "ST_mmgc_580603.st"
 verifyPass(1, "1", __FILE__, __LINE__);
 }
 
 }
 void ST_mmgc_bugzilla_580603::test1() {
 {
     char *h[3];
     h[0] = my_alloc( 256*GCHeap::kBlockSize, via_heap);
@@ -1082,33 +1084,35 @@ void ST_mmgc_bugzilla_580603::test1() {
     my_free(h[1], via_heap);
     // print_minmax();
 
     char *g[m_num_iters*m_num_sizes]; (void)g;
     do_allocs(g, via_gc);
 
     // print_minmax();
 
-// line 292 "ST_mmgc_580603.st"
+// line 259 "ST_mmgc_580603.st"
 verifyPass(1, "1", __FILE__, __LINE__);
 }
 
 }
 void create_mmgc_bugzilla_580603(AvmCore* core) { new ST_mmgc_bugzilla_580603(core); }
 }
 }
 #endif
 #endif
 
 // Generated from ST_mmgc_603411.st
 // -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */
 //
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// Bug 603411 - SECURITY: AvmCore dtor needs to clear CallStackNode chain
 
 #include "avmshell.h"
 #ifdef VMCFG_SELFTEST
 #if defined DEBUGGER
 namespace avmplus {
 namespace ST_mmgc_bugzilla_603411 {
 
 class MyDebugger : public Debugger
@@ -1221,33 +1225,33 @@ void ST_mmgc_bugzilla_603411::epilogue()
 
 }
 void ST_mmgc_bugzilla_603411::test0() {
     // create our own core
     testCore = new MyAvmCore(core->gc);
     testClass = new MyTestClass(testCore);
     testClass->testAvmCoreDelete();
 
-// line 141 "ST_mmgc_603411.st"
+// line 108 "ST_mmgc_603411.st"
 verifyPass(true, "true", __FILE__, __LINE__);
 
 }
 void create_mmgc_bugzilla_603411(AvmCore* core) { new ST_mmgc_bugzilla_603411(core); }
 }
 }
 #endif
 #endif
 
 // Generated from ST_mmgc_637993.st
 // -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
 // vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
 //
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 // Bugzilla 637993: rehashing a GCHashtable in the midst of iteration
 // is unsound; here we check that we are guarding against it.
 
 #include "avmshell.h"
 #ifdef VMCFG_SELFTEST
 namespace avmplus {
 namespace ST_mmgc_bugzilla_637993 {
@@ -1299,33 +1303,33 @@ void ST_mmgc_bugzilla_637993::test0() {
     {
         MMgc::GCHashtable::Iterator it(&m_table);
         while (it.nextKey()) {
             m_table.remove(it.value(), /*allowrehash=*/false);
         }
     }
     m_table.clear();
     delete elems;
-// line 74 "ST_mmgc_637993.st"
+// line 41 "ST_mmgc_637993.st"
 verifyPass(true, "true", __FILE__, __LINE__);
          ;
 
 }
 void ST_mmgc_bugzilla_637993::test1() {
     elems = new int32_t[elem_count];
     add_first_half();
     {
         MMgc::GCHashtable::Iterator it(&m_table);
         while (it.nextKey()) {
             m_table.remove(it.value());
         }
     }
     m_table.clear();
     delete elems;
-// line 88 "ST_mmgc_637993.st"
+// line 55 "ST_mmgc_637993.st"
 verifyPass(false, "false", __FILE__, __LINE__);
          ;
 
 // This test is a trivial success; it is meant to be compared against
 // the cases that *fail* below, in order to make it clear what is
 // wrong with the intentionally asserting cases.
 }
 void ST_mmgc_bugzilla_637993::test2() {
@@ -1334,17 +1338,17 @@ void ST_mmgc_bugzilla_637993::test2() {
     {
         MMgc::GCHashtable::Iterator it(&m_table);
         it.nextKey();
         it.nextKey();
     }
     add_second_half(); // rule satisfied; (Iterator is out of scope).
     m_table.clear();
     delete elems;
-// line 105 "ST_mmgc_637993.st"
+// line 72 "ST_mmgc_637993.st"
 verifyPass(true, "true", __FILE__, __LINE__);
          ;
 
   // (This test should definitely assert.)
 }
 void ST_mmgc_bugzilla_637993::test3() {
     elems = new int32_t[elem_count];
     add_first_half();
@@ -1353,17 +1357,17 @@ void ST_mmgc_bugzilla_637993::test3() {
         it.nextKey();
         add_second_half(); // this is where we break the rule
         it.nextKey();
     }
 
     m_table.clear();
     delete elems;
     // we should never get here, the assertion should happen up above.
-// line 122 "ST_mmgc_637993.st"
+// line 89 "ST_mmgc_637993.st"
 verifyPass(false, "false", __FILE__, __LINE__);
           ;
 
 // This test will assert even though the iteration is "done",
 // because the rule is that we cannot modify the hashtable while
 // any iterator is still "in scope"
 }
 void ST_mmgc_bugzilla_637993::test4() {
@@ -1374,33 +1378,33 @@ void ST_mmgc_bugzilla_637993::test4() {
         it.nextKey();
         it.nextKey();
         add_second_half(); // this is where we break the rule
     }
 
     m_table.clear();
     delete elems;
     // we should never get here, the assertion should happen up above.
-// line 141 "ST_mmgc_637993.st"
+// line 108 "ST_mmgc_637993.st"
 verifyPass(false, "false", __FILE__, __LINE__);
           ;
 
 }
 void create_mmgc_bugzilla_637993(AvmCore* core) { new ST_mmgc_bugzilla_637993(core); }
 }
 }
 #endif
 
 // Generated from ST_mmgc_basics.st
 // -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
 // vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
 //
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 #include "avmshell.h"
 #ifdef VMCFG_SELFTEST
 namespace avmplus {
 namespace ST_mmgc_basics {
 class ST_mmgc_basics : public Selftest {
 public:
 ST_mmgc_basics(AvmCore* core);
@@ -1568,145 +1572,145 @@ public:
     }
 };
 
 GCObjectLock* LockerAndUnlocker::lock[numlocked];
 GCObjectLock* LockerAndUnlocker::lock2[numlocked];
 int LockerAndUnlocker::counter = 0;
 
 void ST_mmgc_basics::test0() {
-// line 161 "ST_mmgc_basics.st"
+// line 128 "ST_mmgc_basics.st"
 verifyPass(gc != NULL, "gc != NULL", __FILE__, __LINE__);
 
 }
 void ST_mmgc_basics::test1() {
     MMGC_GCENTER(gc);
     MyGCObject *mygcobject;
     mygcobject = (MyGCObject *)new (gc) MyGCObject();
-// line 167 "ST_mmgc_basics.st"
+// line 134 "ST_mmgc_basics.st"
 verifyPass(mygcobject!=NULL, "mygcobject!=NULL", __FILE__, __LINE__);
     mygcobject->i=10;
-// line 169 "ST_mmgc_basics.st"
+// line 136 "ST_mmgc_basics.st"
 verifyPass(mygcobject->i==10, "mygcobject->i==10", __FILE__, __LINE__);
 
 }
 void ST_mmgc_basics::test2() {
     MMGC_GCENTER(gc);
     MyGCObject *mygcobject;
     int inuse=(int)gc->GetBytesInUse();
     mygcobject = (MyGCObject *)new (gc) MyGCObject();
 //    AvmLog("bytes in use before %d after %d\n",inuse,(int)gc->GetBytesInUse());
-// line 177 "ST_mmgc_basics.st"
+// line 144 "ST_mmgc_basics.st"
 verifyPass(gc->GetBytesInUse()==inuse + sizeof(MyGCObject) + DebugSize(), "gc->GetBytesInUse()==inuse + sizeof(MyGCObject) + DebugSize()", __FILE__, __LINE__);
     delete mygcobject;
 
 }
 void ST_mmgc_basics::test3() {
     MMGC_GCENTER(gc);
     MyGCObject *mygcobject;
     int inuse=(int)gc->GetBytesInUse();
     mygcobject = (MyGCObject *)new (gc) MyGCObject();
-// line 185 "ST_mmgc_basics.st"
+// line 152 "ST_mmgc_basics.st"
 verifyPass((int)gc->GetBytesInUse()>inuse, "(int)gc->GetBytesInUse()>inuse", __FILE__, __LINE__);
     delete mygcobject;
 //    AvmLog("collect: inuse=%d current=%d\n",inuse,(int)gc->GetBytesInUse());
     gc->Collect();
 //    AvmLog("collect: inuse=%d current=%d\n",inuse,(int)gc->GetBytesInUse());
-// line 190 "ST_mmgc_basics.st"
+// line 157 "ST_mmgc_basics.st"
 verifyPass((int)gc->GetBytesInUse()<=inuse, "(int)gc->GetBytesInUse()<=inuse", __FILE__, __LINE__);
 
 }
 void ST_mmgc_basics::test4() {
-// line 193 "ST_mmgc_basics.st"
+// line 160 "ST_mmgc_basics.st"
 verifyPass(gc->GetGCHeap()!=NULL, "gc->GetGCHeap()!=NULL", __FILE__, __LINE__);
 
 }
 void ST_mmgc_basics::test5() {
     MMgc::FixedAlloc *fa;
     fa=new MMgc::FixedAlloc(2048,MMgc::GCHeap::GetGCHeap());
-// line 198 "ST_mmgc_basics.st"
+// line 165 "ST_mmgc_basics.st"
 verifyPass((int)fa->GetMaxAlloc()==0, "(int)fa->GetMaxAlloc()==0", __FILE__, __LINE__);
-// line 199 "ST_mmgc_basics.st"
+// line 166 "ST_mmgc_basics.st"
 verifyPass((int)fa->GetNumBlocks()==0, "(int)fa->GetNumBlocks()==0", __FILE__, __LINE__);
     void *data1=fa->Alloc(2048);
-// line 201 "ST_mmgc_basics.st"
+// line 168 "ST_mmgc_basics.st"
 verifyPass(MMgc::FixedAlloc::GetFixedAlloc(data1)==fa, "MMgc::FixedAlloc::GetFixedAlloc(data1)==fa", __FILE__, __LINE__);
-// line 202 "ST_mmgc_basics.st"
+// line 169 "ST_mmgc_basics.st"
 verifyPass(fa->GetBytesInUse()==DebugSize()+2048, "fa->GetBytesInUse()==DebugSize()+2048", __FILE__, __LINE__);
-// line 203 "ST_mmgc_basics.st"
+// line 170 "ST_mmgc_basics.st"
 verifyPass(fa->GetItemSize()==2048, "fa->GetItemSize()==2048", __FILE__, __LINE__);
     void *data2=fa->Alloc(2048);
-// line 205 "ST_mmgc_basics.st"
+// line 172 "ST_mmgc_basics.st"
 verifyPass(MMgc::FixedAlloc::GetFixedAlloc(data2)==fa, "MMgc::FixedAlloc::GetFixedAlloc(data2)==fa", __FILE__, __LINE__);
 //    AvmLog("fa->GetItemSize=%d\n",(int)fa->GetItemSize());
-// line 207 "ST_mmgc_basics.st"
+// line 174 "ST_mmgc_basics.st"
 verifyPass((int)fa->GetItemSize()==2048, "(int)fa->GetItemSize()==2048", __FILE__, __LINE__);
     fa->Free(data1);
-// line 209 "ST_mmgc_basics.st"
+// line 176 "ST_mmgc_basics.st"
 verifyPass((int)fa->GetItemSize()==2048, "(int)fa->GetItemSize()==2048", __FILE__, __LINE__);
-// line 210 "ST_mmgc_basics.st"
+// line 177 "ST_mmgc_basics.st"
 verifyPass((int)fa->GetMaxAlloc()==1, "(int)fa->GetMaxAlloc()==1", __FILE__, __LINE__);
-// line 211 "ST_mmgc_basics.st"
+// line 178 "ST_mmgc_basics.st"
 verifyPass((int)fa->GetNumBlocks()==1, "(int)fa->GetNumBlocks()==1", __FILE__, __LINE__);
     fa->Free(data2);
     delete fa;
 
 }
 void ST_mmgc_basics::test6() {
     fm=MMgc::FixedMalloc::GetFixedMalloc();
     int start=(int)fm->GetBytesInUse();
     int starttotal=(int)fm->GetTotalSize();
 //    AvmLog("fm->GetBytesInUse()=%d\n",(int)fm->GetBytesInUse());
-// line 220 "ST_mmgc_basics.st"
+// line 187 "ST_mmgc_basics.st"
 verifyPass((int)fm->GetBytesInUse()==start, "(int)fm->GetBytesInUse()==start", __FILE__, __LINE__);
 //    AvmLog("fm->GetTotalSize()=%d\n",(int)fm->GetTotalSize());
-// line 222 "ST_mmgc_basics.st"
+// line 189 "ST_mmgc_basics.st"
 verifyPass((int)fm->GetTotalSize()==starttotal, "(int)fm->GetTotalSize()==starttotal", __FILE__, __LINE__);
     void *obj=fm->Alloc(8192);
 //    AvmLog("fm->GetBytesInUse()=%d\n",(int)fm->GetBytesInUse());
 //    %%verify fm->GetBytesInUse()==start + 8192 + MMgc::DebugSize()
 //    AvmLog("fm->GetTotalSize()=%d\n",(int)fm->GetTotalSize());
 //    %%verify (int)fm->GetTotalSize()==starttotal+2
     fm->Free(obj);
 //    AvmLog("fm->GetBytesInUse()=%d\n",(int)fm->GetBytesInUse());
-// line 230 "ST_mmgc_basics.st"
+// line 197 "ST_mmgc_basics.st"
 verifyPass((int)fm->GetBytesInUse()==start, "(int)fm->GetBytesInUse()==start", __FILE__, __LINE__);
 //    AvmLog("fm->GetTotalSize()=%d\n",(int)fm->GetTotalSize());
-// line 232 "ST_mmgc_basics.st"
+// line 199 "ST_mmgc_basics.st"
 verifyPass((int)fm->GetTotalSize()==starttotal, "(int)fm->GetTotalSize()==starttotal", __FILE__, __LINE__);
     obj=fm->Calloc(1024,10);
 //    AvmLog("fm->GetBytesInUse()=%d\n",(int)fm->GetBytesInUse());
 // FixedMalloc is currently (as of redux 3229) tracking large allocs using a list of
 // small objects, in some debug modes.  So we can't have a precise test here.
-// line 237 "ST_mmgc_basics.st"
+// line 204 "ST_mmgc_basics.st"
 verifyPass((int)fm->GetBytesInUse()>=start+1024*12 && (int)fm->GetBytesInUse()<=start+1024*12+64, "(int)fm->GetBytesInUse()>=start+1024*12 && (int)fm->GetBytesInUse()<=start+1024*12+64", __FILE__, __LINE__);
 //    AvmLog("fm->GetTotalSize()=%d\n",(int)fm->GetTotalSize());
-// line 239 "ST_mmgc_basics.st"
+// line 206 "ST_mmgc_basics.st"
 verifyPass((int)fm->GetTotalSize()==starttotal+3, "(int)fm->GetTotalSize()==starttotal+3", __FILE__, __LINE__);
     fm->Free(obj);
-// line 241 "ST_mmgc_basics.st"
+// line 208 "ST_mmgc_basics.st"
 verifyPass((int)fm->GetBytesInUse()==start, "(int)fm->GetBytesInUse()==start", __FILE__, __LINE__);
-// line 242 "ST_mmgc_basics.st"
+// line 209 "ST_mmgc_basics.st"
 verifyPass((int)fm->GetTotalSize()==starttotal, "(int)fm->GetTotalSize()==starttotal", __FILE__, __LINE__);
 
 }
 void ST_mmgc_basics::test7() {
     MMgc::GCHeap *gh=MMgc::GCHeap::GetGCHeap();
     int startfreeheap=(int)gh->GetFreeHeapSize();
 //    %%verify (int)gh->GetTotalHeapSize()==128
 //    AvmLog("gh->GetFreeHeapSize()=%d\n",(int)gh->GetFreeHeapSize());
-// line 249 "ST_mmgc_basics.st"
+// line 216 "ST_mmgc_basics.st"
 verifyPass((int)gh->GetFreeHeapSize()==startfreeheap, "(int)gh->GetFreeHeapSize()==startfreeheap", __FILE__, __LINE__);
 //gh->Config().heapLimit = 1024;
 //    %%verify (int)gh->GetTotalHeapSize()==128
 //    AvmLog("gh->GetFreeHeapSize()=%d\n",(int)gh->GetFreeHeapSize());
-// line 253 "ST_mmgc_basics.st"
+// line 220 "ST_mmgc_basics.st"
 verifyPass((int)gh->GetFreeHeapSize()==startfreeheap, "(int)gh->GetFreeHeapSize()==startfreeheap", __FILE__, __LINE__);
     void *data = gh->Alloc(10,MMgc::GCHeap::kExpand | MMgc::GCHeap::kZero);
-// line 255 "ST_mmgc_basics.st"
+// line 222 "ST_mmgc_basics.st"
 verifyPass((int)gh->GetTotalHeapSize()>startfreeheap, "(int)gh->GetTotalHeapSize()>startfreeheap", __FILE__, __LINE__);
 //    AvmLog("gh->GetFreeHeapSize()=%d\n",(int)gh->GetFreeHeapSize());
     gh->FreeNoProfile(data);
        
 }
 void ST_mmgc_basics::test8() {
     MMgc::GCHeap *gh=MMgc::GCHeap::GetGCHeap();
 
@@ -1718,49 +1722,49 @@ void ST_mmgc_basics::test8() {
         gh->Free(data);
     }
     for ( unsigned i=0 ; i < ARRAY_SIZE(d) ; i++ )
         gh->Free(d[i]);
 
     // 
     for ( size_t k=2 ; k <= 256 ; k *= 2 ) {
         void *data = gh->Alloc(10,MMgc::GCHeap::flags_Alloc, k);
-// line 275 "ST_mmgc_basics.st"
+// line 242 "ST_mmgc_basics.st"
 verifyPass(((uintptr_t)data & (k*MMgc::GCHeap::kBlockSize - 1)) == 0, "((uintptr_t)data & (k*MMgc::GCHeap::kBlockSize - 1)) == 0", __FILE__, __LINE__);
-// line 276 "ST_mmgc_basics.st"
+// line 243 "ST_mmgc_basics.st"
 verifyPass(gh->Size(data) == 10, "gh->Size(data) == 10", __FILE__, __LINE__);
         gh->Free(data);
     }
 
 }
 void ST_mmgc_basics::test9() {
     MMGC_GCENTER(gc);
     MyGCObject *mygcobject;
     mygcobject = (MyGCObject *)new (gc) MyGCObject();
-// line 284 "ST_mmgc_basics.st"
+// line 251 "ST_mmgc_basics.st"
 verifyPass((MyGCObject *)gc->FindBeginningGuarded(mygcobject)==mygcobject, "(MyGCObject *)gc->FindBeginningGuarded(mygcobject)==mygcobject", __FILE__, __LINE__);
-// line 285 "ST_mmgc_basics.st"
+// line 252 "ST_mmgc_basics.st"
 verifyPass((MyGCObject *)gc->FindBeginningFast(mygcobject)==mygcobject, "(MyGCObject *)gc->FindBeginningFast(mygcobject)==mygcobject", __FILE__, __LINE__);
 
 // Bugzilla 542529 - in debug mode we would assert here due to logic flaws in the allocatr
 }
 void ST_mmgc_basics::test10() {
     MMGC_GCENTER(gc);
     new (gc) AllocInFinalizer();
     gc->Collect(false);
-// line 292 "ST_mmgc_basics.st"
+// line 259 "ST_mmgc_basics.st"
 verifyPass(true, "true", __FILE__, __LINE__);
 
 }
 void ST_mmgc_basics::test11() {
     MMGC_GCENTER(gc);
     new (gc) DeleteInFinalizer(new (gc, 100) GCFinalizedObject(), new (gc) GCFinalizedObject());
     //delete m; delete m; // this verifies we crash, it does
     gc->Collect(false);
-// line 299 "ST_mmgc_basics.st"
+// line 266 "ST_mmgc_basics.st"
 verifyPass(true, "true", __FILE__, __LINE__);
     GCFinalizedObject *gcfo = new (gc) GCFinalizedObject();
     gcfo->~GCFinalizedObject();
     gcfo->~GCFinalizedObject(); // this used to be a deleteing dtor and would crash, not anymore
 
 
 
 }
@@ -1775,17 +1779,17 @@ void ST_mmgc_basics::test12() {
         {
             MMGC_GCENTER(gc);
             a = gc->Alloc(8);
         }
         a = gcb->Alloc(8);
     }
     a = gc->Alloc(8);
     // just fishing for asserts/hangs/crashes
-// line 322 "ST_mmgc_basics.st"
+// line 289 "ST_mmgc_basics.st"
 verifyPass(true, "true", __FILE__, __LINE__);
     delete gcb;
 
 }
 void ST_mmgc_basics::test13() {
     {
         GCConfig config;
         GC *gcb = new GC(GCHeap::GetGCHeap(), config);
@@ -1794,58 +1798,58 @@ void ST_mmgc_basics::test13() {
             gcb->Alloc(8);
         }
 
         // this will cause a Collection in gcb
         GCHeap::SignalExternalFreeMemory();
         delete gcb;
 
         // just fishing for asserts/hangs/crashes
-// line 339 "ST_mmgc_basics.st"
+// line 306 "ST_mmgc_basics.st"
 verifyPass(true, "true", __FILE__, __LINE__);
     }
 
 }
 void ST_mmgc_basics::test14() {
     {
         GCConfig config;
         GC *gc = new GC(GCHeap::GetGCHeap(), config);
         MMGC_GCENTER(gc);
 
-// line 348 "ST_mmgc_basics.st"
+// line 315 "ST_mmgc_basics.st"
 verifyPass(LockerAndUnlocker::createAndLockObjects(gc), "LockerAndUnlocker::createAndLockObjects(gc)", __FILE__, __LINE__);
         gc->Collect();
         gc->Collect();
-// line 351 "ST_mmgc_basics.st"
+// line 318 "ST_mmgc_basics.st"
 verifyPass(LockerAndUnlocker::testLocksHeld(gc, 1), "LockerAndUnlocker::testLocksHeld(gc, 1)", __FILE__, __LINE__);
         gc->Collect();
         gc->Collect();
-// line 354 "ST_mmgc_basics.st"
+// line 321 "ST_mmgc_basics.st"
 verifyPass(LockerAndUnlocker::lockLevel2(gc), "LockerAndUnlocker::lockLevel2(gc)", __FILE__, __LINE__);
         gc->Collect();
         gc->Collect();
-// line 357 "ST_mmgc_basics.st"
+// line 324 "ST_mmgc_basics.st"
 verifyPass(LockerAndUnlocker::testLocksHeld(gc, 2), "LockerAndUnlocker::testLocksHeld(gc, 2)", __FILE__, __LINE__);
         gc->Collect();
         gc->Collect();
-// line 360 "ST_mmgc_basics.st"
+// line 327 "ST_mmgc_basics.st"
 verifyPass(LockerAndUnlocker::unlockLevel2(gc), "LockerAndUnlocker::unlockLevel2(gc)", __FILE__, __LINE__);
         gc->Collect();
         gc->Collect();
-// line 363 "ST_mmgc_basics.st"
+// line 330 "ST_mmgc_basics.st"
 verifyPass(LockerAndUnlocker::testLocksHeld(gc, 1), "LockerAndUnlocker::testLocksHeld(gc, 1)", __FILE__, __LINE__);
         gc->Collect();
         gc->Collect();
-// line 366 "ST_mmgc_basics.st"
+// line 333 "ST_mmgc_basics.st"
 verifyPass(LockerAndUnlocker::unlockLevel1(gc), "LockerAndUnlocker::unlockLevel1(gc)", __FILE__, __LINE__);
 
         // Bug 637695: be aware: conservative retention may foil verify below
         gc->Collect();
         gc->Collect();
-// line 371 "ST_mmgc_basics.st"
+// line 338 "ST_mmgc_basics.st"
 verifyPass(LockerAndUnlocker::testLocksNotHeld(gc), "LockerAndUnlocker::testLocksNotHeld(gc)", __FILE__, __LINE__);
 
         delete gc;
     }
 
 }
 void ST_mmgc_basics::test15() {
     {
@@ -1871,17 +1875,17 @@ void ST_mmgc_basics::test15() {
                 //    %%verify sentinel != 0
                 //}
                 //delete [] (char*)fauxRoot->Get();
                 //delete fauxRoot;
                 //if(sentinel) {
                 //    %%verify ms.P(sentinel) == GCMarkStack::kDeadItem
                 //    %%verify ms.GetSentinel1TypeAt(ms.GetItemAbove(sentinel)) == GCMarkStack::kDeadItem
                 //}
-// line 405 "ST_mmgc_basics.st"
+// line 372 "ST_mmgc_basics.st"
 verifyPass(true, "true", __FILE__, __LINE__);
             }
             testGC->Mark();
             testGC->ClearMarkStack();
             testGC->ClearMarks();
         }
         delete testGC;
     }
@@ -1895,57 +1899,57 @@ void ST_mmgc_basics::test16() {
     MMGC_GCENTER(gc);
     MyGCObject *mygcobject;
     mygcobject = (MyGCObject *)new (gc) MyGCObject();
     gc->addToBlacklist(mygcobject);
     gc->Collect();
     gc->removeFromBlacklist(mygcobject);
     delete gc;
 #endif
-// line 427 "ST_mmgc_basics.st"
+// line 394 "ST_mmgc_basics.st"
 verifyPass(true, "true", __FILE__, __LINE__);
 
 }
 void ST_mmgc_basics::test17() {
     MMGC_GCENTER(gc);
     MyGCObject *mygcobject;
     mygcobject = (MyGCObject *) new (gc) MyGCObject();
-// line 433 "ST_mmgc_basics.st"
+// line 400 "ST_mmgc_basics.st"
 verifyPass(gc->GetBytesInUse() == gc->GetBytesInUseFast(), "gc->GetBytesInUse() == gc->GetBytesInUseFast()", __FILE__, __LINE__);
     delete mygcobject;
-// line 435 "ST_mmgc_basics.st"
+// line 402 "ST_mmgc_basics.st"
 verifyPass(gc->GetBytesInUse() == gc->GetBytesInUseFast(), "gc->GetBytesInUse() == gc->GetBytesInUseFast()", __FILE__, __LINE__);
     gc->Collect();
-// line 437 "ST_mmgc_basics.st"
+// line 404 "ST_mmgc_basics.st"
 verifyPass(gc->GetBytesInUse() == gc->GetBytesInUseFast(), "gc->GetBytesInUse() == gc->GetBytesInUseFast()", __FILE__, __LINE__);
     MyGCLargeObject *mygclargeobject;
     mygclargeobject = (MyGCLargeObject *) new (gc) MyGCLargeObject();
-// line 440 "ST_mmgc_basics.st"
+// line 407 "ST_mmgc_basics.st"
 verifyPass(gc->GetBytesInUse() == gc->GetBytesInUseFast(), "gc->GetBytesInUse() == gc->GetBytesInUseFast()", __FILE__, __LINE__);
     delete mygclargeobject;
-// line 442 "ST_mmgc_basics.st"
+// line 409 "ST_mmgc_basics.st"
 verifyPass(gc->GetBytesInUse() == gc->GetBytesInUseFast(), "gc->GetBytesInUse() == gc->GetBytesInUseFast()", __FILE__, __LINE__);
     gc->Collect();
-// line 444 "ST_mmgc_basics.st"
+// line 411 "ST_mmgc_basics.st"
 verifyPass(gc->GetBytesInUse() == gc->GetBytesInUseFast() , "gc->GetBytesInUse() == gc->GetBytesInUseFast() ", __FILE__, __LINE__);
      
 
 }
 void create_mmgc_basics(AvmCore* core) { new ST_mmgc_basics(core); }
 }
 }
 #endif
 
 // Generated from ST_mmgc_dependent.st
 // -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
 // vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
 //
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 // Bugzilla 543560 - here we risk deleting an object that is still on the mark stack because
 // of how we perform large-object splitting.  The setup is that user code that deletes the object
 // gets to run after the first part of the large object has been popped off the mark stack
 // but before the rest has been handled.
 
 #include "avmshell.h"
 #ifdef VMCFG_SELFTEST
@@ -2023,109 +2027,109 @@ void ST_mmgc_dependent::test0() {
                 maxheap = heapsize;
         }
     }
 
     // This is tricky to get right but for this test the 16MB blocks will dominate
     // completely.  So assume that heap size must stay below L*2*16MB for the
     // L that applies at 32MB.
 
-// line 101 "ST_mmgc_dependent.st"
+// line 68 "ST_mmgc_dependent.st"
 verifyPass(size_t(gc->policy.queryLoadForHeapsize(double(2*nbytes)) * 2.0 * double(nbytes)) >= maxheap, "size_t(gc->policy.queryLoadForHeapsize(double(2*nbytes)) * 2.0 * double(nbytes)) >= maxheap", __FILE__, __LINE__);
 
 }
 void ST_mmgc_dependent::test1() {
 #if defined VMCFG_TELEMETRY && defined AVMSHELL_BUILD
     size_t depMem_start,depMem_end;
     depMem_start = depMem_end = 0;
     MMgc::GC* gc = core->gc;
 
     // Check total dependent memory consistency
     for(int i = 0; i < MMgc::typeCount; i++)
         depMem_start += gc->getDependentMemory((MMgc::DependentMemoryType)i);
-// line 112 "ST_mmgc_dependent.st"
+// line 79 "ST_mmgc_dependent.st"
 verifyPass(depMem_start == gc->policy.dependentAllocation, "depMem_start == gc->policy.dependentAllocation", __FILE__, __LINE__);
 
     // Check byteArray type dependent memory
     avmshell::ShellCore* c = (avmshell::ShellCore*)core;
     avmshell::ShellToplevel* top = c->shell_toplevel;
 
     size_t byteArray_bytes1 = gc->getDependentMemory(MMgc::typeByteArray);
     ByteArrayObject* byteArray = top->byteArrayClass()->constructByteArray();
     byteArray->writeBoolean(false);
     byteArray->writeDouble(3.14);
 
     // Allocate known type dependent memory
     size_t byteArray_bytes2 = gc->getDependentMemory(MMgc::typeByteArray);
-// line 125 "ST_mmgc_dependent.st"
+// line 92 "ST_mmgc_dependent.st"
 verifyPass(byteArray_bytes2 > byteArray_bytes1, "byteArray_bytes2 > byteArray_bytes1", __FILE__, __LINE__);
 
     // Allocate unknown dependent memory
     DependentAllocHolder* obj = new (gc) DependentAllocHolder();
 
     size_t byteArray_bytes3 = gc->getDependentMemory(MMgc::typeByteArray);
-// line 131 "ST_mmgc_dependent.st"
+// line 98 "ST_mmgc_dependent.st"
 verifyPass(byteArray_bytes3 == byteArray_bytes2, "byteArray_bytes3 == byteArray_bytes2", __FILE__, __LINE__);
     byteArray->clear();
  
-// line 134 "ST_mmgc_dependent.st"
+// line 101 "ST_mmgc_dependent.st"
 verifyPass(gc->getDependentMemory(MMgc::typeByteArray) == byteArray_bytes1, "gc->getDependentMemory(MMgc::typeByteArray) == byteArray_bytes1", __FILE__, __LINE__);
     delete obj;
 
     // Consistency check
     for(int i = 0; i < MMgc::typeCount; i++)
         depMem_end += gc->getDependentMemory((MMgc::DependentMemoryType)i);
-// line 140 "ST_mmgc_dependent.st"
+// line 107 "ST_mmgc_dependent.st"
 verifyPass(depMem_end == gc->policy.dependentAllocation, "depMem_end == gc->policy.dependentAllocation", __FILE__, __LINE__);
-// line 141 "ST_mmgc_dependent.st"
+// line 108 "ST_mmgc_dependent.st"
 verifyPass(depMem_end == depMem_start, "depMem_end == depMem_start", __FILE__, __LINE__);
 
 #if !defined DEBUG && !defined DEBUGGER
     // Get memory for out of bounds type
     // getDependentMemory has assert; skip in debug build
-// line 146 "ST_mmgc_dependent.st"
+// line 113 "ST_mmgc_dependent.st"
 verifyPass(gc->getDependentMemory(MMgc::typeCount) == 0, "gc->getDependentMemory(MMgc::typeCount) == 0", __FILE__, __LINE__);
 #endif
-// line 148 "ST_mmgc_dependent.st"
+// line 115 "ST_mmgc_dependent.st"
 verifyPass(true, "true", __FILE__, __LINE__);
 #endif
 
 }
 void ST_mmgc_dependent::test2() {
 #if defined VMCFG_TELEMETRY && defined AVMSHELL_BUILD
     // Check unknown type dependent memory
     MMgc::GC* gc = core->gc;
     size_t unknownDependentMem_start = gc->getDependentMemory(MMgc::typeUnknown);
     DependentAllocHolder* obj = new (gc) DependentAllocHolder();
     size_t unknownDependentMem_end = gc->getDependentMemory(MMgc::typeUnknown);
-// line 158 "ST_mmgc_dependent.st"
+// line 125 "ST_mmgc_dependent.st"
 verifyPass((unknownDependentMem_end - unknownDependentMem_start) == nbytes, "(unknownDependentMem_end - unknownDependentMem_start) == nbytes", __FILE__, __LINE__);
     
     delete obj;
-// line 161 "ST_mmgc_dependent.st"
+// line 128 "ST_mmgc_dependent.st"
 verifyPass(unknownDependentMem_start == gc->getDependentMemory(MMgc::typeUnknown), "unknownDependentMem_start == gc->getDependentMemory(MMgc::typeUnknown)", __FILE__, __LINE__);
 #else
-// line 163 "ST_mmgc_dependent.st"
+// line 130 "ST_mmgc_dependent.st"
 verifyPass(true, "true", __FILE__, __LINE__);
 #endif
 
 
 }
 void create_mmgc_dependent(AvmCore* core) { new ST_mmgc_dependent(core); }
 }
 }
 #endif
 
 // Generated from ST_mmgc_exact.st
 // -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
 // vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
 //
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 #include "avmshell.h"
 #ifdef VMCFG_SELFTEST
 namespace avmplus {
 namespace ST_mmgc_exact {
 
 class Cthulhu : public MMgc::GCTraceableObject
 {
@@ -2170,32 +2174,32 @@ case 0: test0(); return;
 }
 void ST_mmgc_exact::test0() {
     // Create an object that stays alive so that its tracer will be called
     MMgc::GCObjectLock* lock = core->gc->LockObject(Cthulhu::create(core->gc));
     core->gc->Collect();
     core->gc->Collect();
     core->gc->UnlockObject(lock);
 
-// line 75 "ST_mmgc_exact.st"
+// line 42 "ST_mmgc_exact.st"
 verifyPass(true, "true", __FILE__, __LINE__);
 
 
 }
 void create_mmgc_exact(AvmCore* core) { new ST_mmgc_exact(core); }
 }
 }
 #endif
 
 // Generated from ST_mmgc_externalalloc.st
 // -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */
 //
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 #include "avmshell.h"
 #ifdef VMCFG_SELFTEST
 namespace avmplus {
 namespace ST_mmgc_externalalloc {
 using namespace MMgc;
 class MyCallback : public MMgc::OOMCallback
 {
@@ -2247,38 +2251,42 @@ void ST_mmgc_externalalloc::epilogue() {
 
 }
 void ST_mmgc_externalalloc::test0() {
     MMGC_GCENTER(core->gc);
     size_t softlimit = GCHeap::GetGCHeap()->Config().heapSoftLimit;
     // Remove the heapSoftLimit, this should ensure that we are not in a MMgc::kMemSoftLimit state,
     // and hopefully we are in a kMemNormal state otherwise we are in a kMemAbort state and all bets are off.
     GCHeap::GetGCHeap()->Config().heapSoftLimit = 0;
-// line 78 "ST_mmgc_externalalloc.st"
+// line 45 "ST_mmgc_externalalloc.st"
 verifyPass(cb->status==MMgc::kMemNormal, "cb->status==MMgc::kMemNormal", __FILE__, __LINE__);
     GCHeap::GetGCHeap()->Config().heapSoftLimit = GCHeap::GetGCHeap()->GetTotalHeapSize();
     MMgc::GCHeap::SignalExternalAllocation(1024*1024);
-// line 81 "ST_mmgc_externalalloc.st"
+// line 48 "ST_mmgc_externalalloc.st"
 verifyPass(cb->status==MMgc::kMemSoftLimit, "cb->status==MMgc::kMemSoftLimit", __FILE__, __LINE__);
     MMgc::GCHeap::SignalExternalDeallocation(1024*1024);
-// line 83 "ST_mmgc_externalalloc.st"
+// line 50 "ST_mmgc_externalalloc.st"
 verifyPass(cb->status==MMgc::kMemNormal, "cb->status==MMgc::kMemNormal", __FILE__, __LINE__);
     GCHeap::GetGCHeap()->Config().heapSoftLimit = softlimit;
     softlimit = 0;
 
 
 
 }
 void create_mmgc_externalalloc(AvmCore* core) { new ST_mmgc_externalalloc(core); }
 }
 }
 #endif
 
 // Generated from ST_mmgc_finalize_uninit.st
 // -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
 // vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
 
 // Bugzilla 573737 - a throw from an argument to a constructor can
 // cause an object to be allocated on the gc-heap before it has been
 // fully initialized.  (In particular, its vtable could be missing.)
 // Since finalizers use the virtual destructor method, a missing
 // vtable is a problem.
 //
@@ -2363,17 +2371,17 @@ void ST_mmgc_finalize_uninit::test0() {
     }
     (void) d;
 
     core->gc->Collect(); // finish any prior incremental work ...
     core->gc->Collect(); // ... and ensure we got fresh + complete gc.
 
     // printf("D::finalized_count(): %d\n", D::finalized_count());
 
-// line 71 "ST_mmgc_finalize_uninit.st"
+// line 75 "ST_mmgc_finalize_uninit.st"
 verifyPass((D::finalized_count() > 90), "(D::finalized_count() > 90)", __FILE__, __LINE__);
 }
 
 // Test illustrates of the kind of code that exposed the original bug;
 // here, constructor argument subexpression throws.
 }
 void ST_mmgc_finalize_uninit::test1() {
 {
@@ -2397,17 +2405,17 @@ void ST_mmgc_finalize_uninit::test1() {
     (void) d;
 
     // if things go badly, one of the collections below will segfault
     // during finalization.
     core->gc->Collect();
     core->gc->Collect();
 
     // (not dying is passing.)
-// line 103 "ST_mmgc_finalize_uninit.st"
+// line 107 "ST_mmgc_finalize_uninit.st"
 verifyPass(true, "true", __FILE__, __LINE__);
 }
 
 // C++ standard says "The order of evaluation to an operator new() to
 // get memory and the evaluation of arguments to constructors is
 // undefined."
 //
 // Unfortunately, it is difficult to directly express the particular
@@ -2440,17 +2448,17 @@ void ST_mmgc_finalize_uninit::test2() {
     }
     (void) d;
 
     core->gc->Collect(); // finish any prior incremental work ...
     core->gc->Collect(); // ... and ensure we got fresh + complete gc.
 
     // printf("D::finalized_count(): %d\n", D::finalized_count());
 
-// line 144 "ST_mmgc_finalize_uninit.st"
+// line 148 "ST_mmgc_finalize_uninit.st"
 verifyPass((D::finalized_count() > 90), "(D::finalized_count() > 90)", __FILE__, __LINE__);
 }
 
 
 // Test forces evil order of evaluation via desugaring of
 // construction; keep in sync with original_death above.
 }
 void ST_mmgc_finalize_uninit::test3() {
@@ -2477,33 +2485,33 @@ void ST_mmgc_finalize_uninit::test3() {
     (void) d;
 
     // if things go badly, one of the collections below will segfault
     // during finalization.
     core->gc->Collect();
     core->gc->Collect();
 
     // (not dying is passing.)
-// line 179 "ST_mmgc_finalize_uninit.st"
+// line 183 "ST_mmgc_finalize_uninit.st"
 verifyPass(true, "true", __FILE__, __LINE__);
 }
 
 }
 void create_mmgc_finalize_uninit(AvmCore* core) { new ST_mmgc_finalize_uninit(core); }
 }
 }
 #endif
 
 // Generated from ST_mmgc_fixedmalloc_findbeginning.st
 // -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
 // vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
 //
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 // Bugzilla 663508: Add FixedMalloc::FindBeginning
 
 #include "avmshell.h"
 #ifdef VMCFG_SELFTEST
 namespace avmplus {
 namespace ST_mmgc_fixedmalloc_findbeginning {
 using namespace MMgc;
@@ -2619,172 +2627,172 @@ case 11: test11(); return;
 void ST_mmgc_fixedmalloc_findbeginning::prologue() {
     fm = MMgc::FixedMalloc::GetFixedMalloc();
 
 }
 
 void ST_mmgc_fixedmalloc_findbeginning::test0() {
     {
         size_t sz = FixedMalloc::kSizeClasses[0];
-// line 124 "ST_mmgc_fixedmalloc_findbeginning.st"
+// line 91 "ST_mmgc_fixedmalloc_findbeginning.st"
 verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
               ;
     }
 
 }
 void ST_mmgc_fixedmalloc_findbeginning::test1() {
     {
         size_t sz = FixedMalloc::kSizeClasses[1];
-// line 131 "ST_mmgc_fixedmalloc_findbeginning.st"
+// line 98 "ST_mmgc_fixedmalloc_findbeginning.st"
 verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
               ;
     }
 
 }
 void ST_mmgc_fixedmalloc_findbeginning::test2() {
     {
         size_t sz = FixedMalloc::kSizeClasses[2];
-// line 138 "ST_mmgc_fixedmalloc_findbeginning.st"
+// line 105 "ST_mmgc_fixedmalloc_findbeginning.st"
 verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
               ;
     }
 
 }
 void ST_mmgc_fixedmalloc_findbeginning::test3() {
     {
         size_t sz = FixedMalloc::kSizeClasses[3];
-// line 145 "ST_mmgc_fixedmalloc_findbeginning.st"
+// line 112 "ST_mmgc_fixedmalloc_findbeginning.st"
 verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
               ;
     }
 
 }
 void ST_mmgc_fixedmalloc_findbeginning::test4() {
     {
         size_t sz = FixedMalloc::kLargestAlloc - 1;
         sz = sz - DebugSize();
-// line 153 "ST_mmgc_fixedmalloc_findbeginning.st"
+// line 120 "ST_mmgc_fixedmalloc_findbeginning.st"
 verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
               ;
         sz = sz + DebugSize();
-// line 156 "ST_mmgc_fixedmalloc_findbeginning.st"
+// line 123 "ST_mmgc_fixedmalloc_findbeginning.st"
 verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
               ;
     }
 
 }
 void ST_mmgc_fixedmalloc_findbeginning::test5() {
     {
         size_t sz = FixedMalloc::kLargestAlloc;
         sz = sz - DebugSize();
-// line 164 "ST_mmgc_fixedmalloc_findbeginning.st"
+// line 131 "ST_mmgc_fixedmalloc_findbeginning.st"
 verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
               ;
         sz = sz + DebugSize();
-// line 167 "ST_mmgc_fixedmalloc_findbeginning.st"
+// line 134 "ST_mmgc_fixedmalloc_findbeginning.st"
 verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
               ;
     }
 
 }
 void ST_mmgc_fixedmalloc_findbeginning::test6() {
     {
         size_t sz = FixedMalloc::kLargestAlloc+1;
         sz = sz - DebugSize();
-// line 175 "ST_mmgc_fixedmalloc_findbeginning.st"
+// line 142 "ST_mmgc_fixedmalloc_findbeginning.st"
 verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
               ;
         sz = sz + DebugSize();
-// line 178 "ST_mmgc_fixedmalloc_findbeginning.st"
+// line 145 "ST_mmgc_fixedmalloc_findbeginning.st"
 verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
               ;
     }
 
 }
 void ST_mmgc_fixedmalloc_findbeginning::test7() {
     {
         size_t sz = GCHeap::kBlockSize-1;
         sz = sz - DebugSize();
-// line 186 "ST_mmgc_fixedmalloc_findbeginning.st"
+// line 153 "ST_mmgc_fixedmalloc_findbeginning.st"
 verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
               ;
         sz = sz + DebugSize();
-// line 189 "ST_mmgc_fixedmalloc_findbeginning.st"
+// line 156 "ST_mmgc_fixedmalloc_findbeginning.st"
 verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
               ;
     }
 
 }
 void ST_mmgc_fixedmalloc_findbeginning::test8() {
     {
         size_t sz = GCHeap::kBlockSize;
         sz = sz - DebugSize();
-// line 197 "ST_mmgc_fixedmalloc_findbeginning.st"
+// line 164 "ST_mmgc_fixedmalloc_findbeginning.st"
 verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
               ;
         sz = sz + DebugSize();
-// line 200 "ST_mmgc_fixedmalloc_findbeginning.st"
+// line 167 "ST_mmgc_fixedmalloc_findbeginning.st"
 verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
               ;
     }
 
 }
 void ST_mmgc_fixedmalloc_findbeginning::test9() {
     {
         size_t sz = GCHeap::kBlockSize+1;
         sz = sz - DebugSize();
-// line 208 "ST_mmgc_fixedmalloc_findbeginning.st"
+// line 175 "ST_mmgc_fixedmalloc_findbeginning.st"
 verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
               ;
         sz = sz + DebugSize();
-// line 211 "ST_mmgc_fixedmalloc_findbeginning.st"
+// line 178 "ST_mmgc_fixedmalloc_findbeginning.st"
 verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
               ;
     }
 
 }
 void ST_mmgc_fixedmalloc_findbeginning::test10() {
     {
         size_t sz = GCHeap::kBlockSize*2;
         sz = sz - DebugSize();
-// line 219 "ST_mmgc_fixedmalloc_findbeginning.st"
+// line 186 "ST_mmgc_fixedmalloc_findbeginning.st"
 verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
               ;
         sz = sz + DebugSize();
-// line 222 "ST_mmgc_fixedmalloc_findbeginning.st"
+// line 189 "ST_mmgc_fixedmalloc_findbeginning.st"
 verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
               ;
     }
 
 }
 void ST_mmgc_fixedmalloc_findbeginning::test11() {
     {
         size_t sz = GCHeap::kBlockSize*10;
         sz = sz - DebugSize();
-// line 230 "ST_mmgc_fixedmalloc_findbeginning.st"
+// line 197 "ST_mmgc_fixedmalloc_findbeginning.st"
 verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
               ;
         sz = sz + DebugSize();
-// line 233 "ST_mmgc_fixedmalloc_findbeginning.st"
+// line 200 "ST_mmgc_fixedmalloc_findbeginning.st"
 verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
               ;
     }
 
 }
 void create_mmgc_fixedmalloc_findbeginning(AvmCore* core) { new ST_mmgc_fixedmalloc_findbeginning(core); }
 }
 }
 #endif
 
 // Generated from ST_mmgc_gcheap.st
 // -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */
 //
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 #include "avmshell.h"
 #ifdef VMCFG_SELFTEST
 namespace avmplus {
 namespace ST_mmgc_gcheap {
 class ST_mmgc_gcheap : public Selftest {
 public:
 ST_mmgc_gcheap(AvmCore* core);
@@ -2807,49 +2815,49 @@ case 1: test1(); return;
 }
 }
 using namespace MMgc;
 
 void ST_mmgc_gcheap::test0() {
        GCHeap *heap = GCHeap::GetGCHeap();
        for(int i=1;i<4;i++) {
           void *item = heap->Alloc(GCHeap::kOSAllocThreshold*i);
-// line 50 "ST_mmgc_gcheap.st"
+// line 17 "ST_mmgc_gcheap.st"
 verifyPass(heap->Size(item) == GCHeap::kOSAllocThreshold*i, "heap->Size(item) == GCHeap::kOSAllocThreshold*i", __FILE__, __LINE__);
           heap->Free(item);
        }
-// line 53 "ST_mmgc_gcheap.st"
+// line 20 "ST_mmgc_gcheap.st"
 verifyPass(true, "true", __FILE__, __LINE__);
 
 }
 void ST_mmgc_gcheap::test1() {
        GCHeap *heap = GCHeap::GetGCHeap();
        for(int i=1;i<10;i++) {
           void *item = heap->Alloc(GCHeap::kOSAllocThreshold*i, GCHeap::flags_Alloc, 1<<i);
-// line 59 "ST_mmgc_gcheap.st"
+// line 26 "ST_mmgc_gcheap.st"
 verifyPass(heap->Size(item) == GCHeap::kOSAllocThreshold*i, "heap->Size(item) == GCHeap::kOSAllocThreshold*i", __FILE__, __LINE__);
-// line 60 "ST_mmgc_gcheap.st"
+// line 27 "ST_mmgc_gcheap.st"
 verifyPass(uintptr_t(((GCHeap::kBlockSize<<(i-1))-1) & uintptr_t(item)) == 0, "uintptr_t(((GCHeap::kBlockSize<<(i-1))-1) & uintptr_t(item)) == 0", __FILE__, __LINE__);
           heap->Free(item);
        }
 
 
 }
 void create_mmgc_gcheap(AvmCore* core) { new ST_mmgc_gcheap(core); }
 }
 }
 #endif
 
 // Generated from ST_mmgc_gcoption.st
 // -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
 // vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
 //
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 #include "avmshell.h"
 #ifdef VMCFG_SELFTEST
 namespace avmplus {
 namespace ST_mmgc_gcoption {
 using namespace MMgc;
 
 class ST_mmgc_gcoption : public Selftest {
@@ -2937,302 +2945,302 @@ void ST_mmgc_gcoption::prologue() {
 void ST_mmgc_gcoption::epilogue() {
 {
     restoreHeapConfig();
 }
 
 }
 void ST_mmgc_gcoption::test0() {
 {
-// line 108 "ST_mmgc_gcoption.st"
+// line 75 "ST_mmgc_gcoption.st"
 verifyPass(isParamOption("-memlimit"), "isParamOption(\"-memlimit\")", __FILE__, __LINE__);
-// line 109 "ST_mmgc_gcoption.st"
+// line 76 "ST_mmgc_gcoption.st"
 verifyPass(isParamOption("-load"), "isParamOption(\"-load\")", __FILE__, __LINE__);
-// line 110 "ST_mmgc_gcoption.st"
+// line 77 "ST_mmgc_gcoption.st"
 verifyPass(isParamOption("-loadCeiling"), "isParamOption(\"-loadCeiling\")", __FILE__, __LINE__);
-// line 111 "ST_mmgc_gcoption.st"
+// line 78 "ST_mmgc_gcoption.st"
 verifyPass(isParamOption("-gcwork"), "isParamOption(\"-gcwork\")", __FILE__, __LINE__);
-// line 112 "ST_mmgc_gcoption.st"
+// line 79 "ST_mmgc_gcoption.st"
 verifyPass(isParamOption("-gcstack"), "isParamOption(\"-gcstack\")", __FILE__, __LINE__);
 
-// line 114 "ST_mmgc_gcoption.st"
+// line 81 "ST_mmgc_gcoption.st"
 verifyPass(notParamOption("-memlimit=10"), "notParamOption(\"-memlimit=10\")", __FILE__, __LINE__);
-// line 115 "ST_mmgc_gcoption.st"
+// line 82 "ST_mmgc_gcoption.st"
 verifyPass(notParamOption("-load 1.5"), "notParamOption(\"-load 1.5\")", __FILE__, __LINE__);
-// line 116 "ST_mmgc_gcoption.st"
+// line 83 "ST_mmgc_gcoption.st"
 verifyPass(notParamOption("-loadCeiling 1.5"), "notParamOption(\"-loadCeiling 1.5\")", __FILE__, __LINE__);
-// line 117 "ST_mmgc_gcoption.st"
+// line 84 "ST_mmgc_gcoption.st"
 verifyPass(notParamOption("-gcwork 1.5"), "notParamOption(\"-gcwork 1.5\")", __FILE__, __LINE__);
-// line 118 "ST_mmgc_gcoption.st"
+// line 85 "ST_mmgc_gcoption.st"
 verifyPass(notParamOption("-gcstack 10"), "notParamOption(\"-gcstack 10\")", __FILE__, __LINE__);
 
-// line 120 "ST_mmgc_gcoption.st"
+// line 87 "ST_mmgc_gcoption.st"
 verifyPass(notParamOption("-not_an_option_and_never_will_be"), "notParamOption(\"-not_an_option_and_never_will_be\")", __FILE__, __LINE__);
-// line 121 "ST_mmgc_gcoption.st"
+// line 88 "ST_mmgc_gcoption.st"
 verifyPass(notParamOption("-not_an_option_and_never_will_be 10"), "notParamOption(\"-not_an_option_and_never_will_be 10\")", __FILE__, __LINE__);
-// line 122 "ST_mmgc_gcoption.st"
+// line 89 "ST_mmgc_gcoption.st"
 verifyPass(notParamOption("-not_an_option_and_never_will_be=10"), "notParamOption(\"-not_an_option_and_never_will_be=10\")", __FILE__, __LINE__);
           ;
 }
 
 }
 void ST_mmgc_gcoption::test1() {
 {
     // sanity checks:
     // - make sure our configUnchanged check is sane
     // - make sure our restoreHeapConfig works.
-// line 131 "ST_mmgc_gcoption.st"
+// line 98 "ST_mmgc_gcoption.st"
 verifyPass(configUnchanged(), "configUnchanged()", __FILE__, __LINE__);
     memset(&m_heap->config, 0xfe, sizeof(GCHeapConfig));
-// line 133 "ST_mmgc_gcoption.st"
+// line 100 "ST_mmgc_gcoption.st"
 verifyPass(!configUnchanged(), "!configUnchanged()", __FILE__, __LINE__);
     restoreHeapConfig();
-// line 135 "ST_mmgc_gcoption.st"
+// line 102 "ST_mmgc_gcoption.st"
 verifyPass(configUnchanged(), "configUnchanged()", __FILE__, __LINE__);
           ;
 
     parseApply("-memstats");
-// line 139 "ST_mmgc_gcoption.st"
+// line 106 "ST_mmgc_gcoption.st"
 verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
-// line 140 "ST_mmgc_gcoption.st"
+// line 107 "ST_mmgc_gcoption.st"
 verifyPass(m_heap->config.gcstats && m_heap->config.autoGCStats, "m_heap->config.gcstats && m_heap->config.autoGCStats", __FILE__, __LINE__);
           ;
     restoreHeapConfig();
 
     parseApply("-memstats-verbose");
-// line 145 "ST_mmgc_gcoption.st"
+// line 112 "ST_mmgc_gcoption.st"
 verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
-// line 146 "ST_mmgc_gcoption.st"
+// line 113 "ST_mmgc_gcoption.st"
 verifyPass(m_heap->config.gcstats && m_heap->config.autoGCStats && m_heap->config.verbose, "m_heap->config.gcstats && m_heap->config.autoGCStats && m_heap->config.verbose", __FILE__, __LINE__);
           ;
     restoreHeapConfig();
 }
 }
 void ST_mmgc_gcoption::test2() {
 {
     parseApply("-memlimit   10");
-// line 153 "ST_mmgc_gcoption.st"
+// line 120 "ST_mmgc_gcoption.st"
 verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
-// line 154 "ST_mmgc_gcoption.st"
+// line 121 "ST_mmgc_gcoption.st"
 verifyPass(m_heap->config.heapLimit == 10, "m_heap->config.heapLimit == 10", __FILE__, __LINE__);
           ;
     restoreHeapConfig();
 
     parseApply("-memlimit=11");
-// line 159 "ST_mmgc_gcoption.st"
+// line 126 "ST_mmgc_gcoption.st"
 verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
-// line 160 "ST_mmgc_gcoption.st"
+// line 127 "ST_mmgc_gcoption.st"
 verifyPass(m_heap->config.heapLimit == 11, "m_heap->config.heapLimit == 11", __FILE__, __LINE__);
           ;
     restoreHeapConfig();
 
     parseApply("-memlimit = 12");
-// line 165 "ST_mmgc_gcoption.st"
+// line 132 "ST_mmgc_gcoption.st"
 verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
-// line 166 "ST_mmgc_gcoption.st"
+// line 133 "ST_mmgc_gcoption.st"
 verifyPass(m_heap->config.heapLimit == 12, "m_heap->config.heapLimit == 12", __FILE__, __LINE__);
           ;
     restoreHeapConfig();
 
     parseApply("-memlimit");
-// line 171 "ST_mmgc_gcoption.st"
+// line 138 "ST_mmgc_gcoption.st"
 verifyPass(gcoptionButIncorrectFormat(), "gcoptionButIncorrectFormat()", __FILE__, __LINE__);
-// line 172 "ST_mmgc_gcoption.st"
+// line 139 "ST_mmgc_gcoption.st"
 verifyPass(m_heap->config.heapLimit == m_config_orig.heapLimit, "m_heap->config.heapLimit == m_config_orig.heapLimit", __FILE__, __LINE__);
           ;
     restoreHeapConfig();
 
     parseApply("-memlimit", "13");
-// line 177 "ST_mmgc_gcoption.st"
+// line 144 "ST_mmgc_gcoption.st"
 verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
-// line 178 "ST_mmgc_gcoption.st"
+// line 145 "ST_mmgc_gcoption.st"
 verifyPass(m_heap->config.heapLimit == 13, "m_heap->config.heapLimit == 13", __FILE__, __LINE__);
           ;
     restoreHeapConfig();
 }
 }
 void ST_mmgc_gcoption::test3() {
 {
 #ifdef MMGC_POLICY_PROFILING
     parseApply("-gcbehavior");
-// line 186 "ST_mmgc_gcoption.st"
+// line 153 "ST_mmgc_gcoption.st"
 verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
-// line 187 "ST_mmgc_gcoption.st"
+// line 154 "ST_mmgc_gcoption.st"
 verifyPass((m_heap->config.gcbehavior == 2), "(m_heap->config.gcbehavior == 2)", __FILE__, __LINE__);
           ;
     restoreHeapConfig();
 
     parseApply("-gcsummary");
-// line 192 "ST_mmgc_gcoption.st"
+// line 159 "ST_mmgc_gcoption.st"
 verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
-// line 193 "ST_mmgc_gcoption.st"
+// line 160 "ST_mmgc_gcoption.st"
 verifyPass((m_heap->config.gcbehavior == 1), "(m_heap->config.gcbehavior == 1)", __FILE__, __LINE__);
           ;
     restoreHeapConfig();
 #endif
 
     parseApply("-eagersweep");
-// line 199 "ST_mmgc_gcoption.st"
+// line 166 "ST_mmgc_gcoption.st"
 verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
-// line 200 "ST_mmgc_gcoption.st"
+// line 167 "ST_mmgc_gcoption.st"
 verifyPass(m_heap->config.eagerSweeping, "m_heap->config.eagerSweeping", __FILE__, __LINE__);
           ;
     restoreHeapConfig();
 }
 }
 void ST_mmgc_gcoption::test4() {
 {
     parseApply("-load 7.0");
-// line 207 "ST_mmgc_gcoption.st"
+// line 174 "ST_mmgc_gcoption.st"
 verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
-// line 208 "ST_mmgc_gcoption.st"
+// line 175 "ST_mmgc_gcoption.st"
 verifyPass(approxEqual(m_heap->config.gcLoad[0], 7.0), "approxEqual(m_heap->config.gcLoad[0], 7.0)", __FILE__, __LINE__);
           ;
     restoreHeapConfig();
 
     // test load with '<space><param>'
     parseApply("-load 6.0,10,5.0");
-// line 214 "ST_mmgc_gcoption.st"
+// line 181 "ST_mmgc_gcoption.st"
 verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
-// line 215 "ST_mmgc_gcoption.st"
+// line 182 "ST_mmgc_gcoption.st"
 verifyPass(approxEqual(m_heap->config.gcLoad[0], 6.0), "approxEqual(m_heap->config.gcLoad[0], 6.0)", __FILE__, __LINE__);
-// line 216 "ST_mmgc_gcoption.st"
+// line 183 "ST_mmgc_gcoption.st"
 verifyPass(approxEqual(m_heap->config.gcLoadCutoff[0], 10.0), "approxEqual(m_heap->config.gcLoadCutoff[0], 10.0)", __FILE__, __LINE__);
-// line 217 "ST_mmgc_gcoption.st"
+// line 184 "ST_mmgc_gcoption.st"
 verifyPass(approxEqual(m_heap->config.gcLoad[1], 5.0), "approxEqual(m_heap->config.gcLoad[1], 5.0)", __FILE__, __LINE__);
           ;
     restoreHeapConfig();
 
     // test load with separate <param>
     parseApply("-load", "8.0,20.5,7.0");
-// line 223 "ST_mmgc_gcoption.st"
+// line 190 "ST_mmgc_gcoption.st"
 verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
-// line 224 "ST_mmgc_gcoption.st"
+// line 191 "ST_mmgc_gcoption.st"
 verifyPass(approxEqual(m_heap->config.gcLoad[0], 8.0), "approxEqual(m_heap->config.gcLoad[0], 8.0)", __FILE__, __LINE__);
-// line 225 "ST_mmgc_gcoption.st"
+// line 192 "ST_mmgc_gcoption.st"
 verifyPass(approxEqual(m_heap->config.gcLoadCutoff[0], 20.5), "approxEqual(m_heap->config.gcLoadCutoff[0], 20.5)", __FILE__, __LINE__);
-// line 226 "ST_mmgc_gcoption.st"
+// line 193 "ST_mmgc_gcoption.st"
 verifyPass(approxEqual(m_heap->config.gcLoad[1], 7.0), "approxEqual(m_heap->config.gcLoad[1], 7.0)", __FILE__, __LINE__);
           ;
     restoreHeapConfig();
 
     // test load with '=<param>'
     parseApply("-load=10.0,30.5,9.0");
-// line 232 "ST_mmgc_gcoption.st"
+// line 199 "ST_mmgc_gcoption.st"
 verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
-// line 233 "ST_mmgc_gcoption.st"
+// line 200 "ST_mmgc_gcoption.st"
 verifyPass(approxEqual(m_heap->config.gcLoad[0], 10.0), "approxEqual(m_heap->config.gcLoad[0], 10.0)", __FILE__, __LINE__);
-// line 234 "ST_mmgc_gcoption.st"
+// line 201 "ST_mmgc_gcoption.st"
 verifyPass(approxEqual(m_heap->config.gcLoadCutoff[0], 30.5), "approxEqual(m_heap->config.gcLoadCutoff[0], 30.5)", __FILE__, __LINE__);
-// line 235 "ST_mmgc_gcoption.st"
+// line 202 "ST_mmgc_gcoption.st"
 verifyPass(approxEqual(m_heap->config.gcLoad[1], 9.0), "approxEqual(m_heap->config.gcLoad[1], 9.0)", __FILE__, __LINE__);
           ;
     restoreHeapConfig();
 
     // Max load pairs is 7
     parseApply("-load 1.5,1.5,2,2,3,3,4,4,5,5,6,6,7,7,8,8");
-// line 241 "ST_mmgc_gcoption.st"
+// line 208 "ST_mmgc_gcoption.st"
 verifyPass(gcoptionButIncorrectFormat(), "gcoptionButIncorrectFormat()", __FILE__, __LINE__);
-// line 242 "ST_mmgc_gcoption.st"
+// line 209 "ST_mmgc_gcoption.st"
 verifyPass(configUnchanged(), "configUnchanged()", __FILE__, __LINE__);
     restoreHeapConfig();
 
     // Ensure that the last load value is ignored
     parseApply("-load=10.0,30.0,9.0,60.0");
-// line 247 "ST_mmgc_gcoption.st"
+// line 214 "ST_mmgc_gcoption.st"
 verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
-// line 248 "ST_mmgc_gcoption.st"
+// line 215 "ST_mmgc_gcoption.st"
 verifyPass(approxEqual(m_heap->config.gcLoad[0], 10.0), "approxEqual(m_heap->config.gcLoad[0], 10.0)", __FILE__, __LINE__);
-// line 249 "ST_mmgc_gcoption.st"
+// line 216 "ST_mmgc_gcoption.st"
 verifyPass(approxEqual(m_heap->config.gcLoadCutoff[0], 30.0), "approxEqual(m_heap->config.gcLoadCutoff[0], 30.0)", __FILE__, __LINE__);
-// line 250 "ST_mmgc_gcoption.st"
+// line 217 "ST_mmgc_gcoption.st"
 verifyPass(approxEqual(m_heap->config.gcLoad[1], 9.0), "approxEqual(m_heap->config.gcLoad[1], 9.0)", __FILE__, __LINE__);
-// line 251 "ST_mmgc_gcoption.st"
+// line 218 "ST_mmgc_gcoption.st"
 verifyPass(!approxEqual(m_heap->config.gcLoadCutoff[1], 60.0), "!approxEqual(m_heap->config.gcLoadCutoff[1], 60.0)", __FILE__, __LINE__);
           ;
     restoreHeapConfig();
 
     parseApply("-load");
-// line 256 "ST_mmgc_gcoption.st"
+// line 223 "ST_mmgc_gcoption.st"
 verifyPass(gcoptionButIncorrectFormat(), "gcoptionButIncorrectFormat()", __FILE__, __LINE__);
-// line 257 "ST_mmgc_gcoption.st"
+// line 224 "ST_mmgc_gcoption.st"
 verifyPass(configUnchanged(), "configUnchanged()", __FILE__, __LINE__);
           ;
     restoreHeapConfig();
 
     // L (load) must be > 1
     parseApply("-load 1,30");
-// line 263 "ST_mmgc_gcoption.st"
+// line 230 "ST_mmgc_gcoption.st"
 verifyPass(gcoptionButIncorrectFormat(), "gcoptionButIncorrectFormat()", __FILE__, __LINE__);
-// line 264 "ST_mmgc_gcoption.st"
+// line 231 "ST_mmgc_gcoption.st"
 verifyPass(configUnchanged(), "configUnchanged()", __FILE__, __LINE__);
           ;
     restoreHeapConfig();
 
     parseApply("-load badvalue");
-// line 269 "ST_mmgc_gcoption.st"
+// line 236 "ST_mmgc_gcoption.st"
 verifyPass(gcoptionButIncorrectFormat(), "gcoptionButIncorrectFormat()", __FILE__, __LINE__);
-// line 270 "ST_mmgc_gcoption.st"
+// line 237 "ST_mmgc_gcoption.st"
 verifyPass(configUnchanged(), "configUnchanged()", __FILE__, __LINE__);
           ;
     restoreHeapConfig();
 
 
     parseApply("-loadCeiling 11.5");
-// line 276 "ST_mmgc_gcoption.st"
+// line 243 "ST_mmgc_gcoption.st"
 verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
-// line 277 "ST_mmgc_gcoption.st"
+// line 244 "ST_mmgc_gcoption.st"
 verifyPass(approxEqual(m_heap->config.gcLoadCeiling, 11.5), "approxEqual(m_heap->config.gcLoadCeiling, 11.5)", __FILE__, __LINE__);
           ;
     restoreHeapConfig();
 
     parseApply("-gcwork 12.5");
-// line 282 "ST_mmgc_gcoption.st"
+// line 249 "ST_mmgc_gcoption.st"
 verifyPass(gcoptionButIncorrectFormat(), "gcoptionButIncorrectFormat()", __FILE__, __LINE__);
           ;
     restoreHeapConfig();
 
     parseApply("-gcwork 0.123456");
-// line 287 "ST_mmgc_gcoption.st"
+// line 254 "ST_mmgc_gcoption.st"
 verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
-// line 288 "ST_mmgc_gcoption.st"
+// line 255 "ST_mmgc_gcoption.st"
 verifyPass(approxEqual(m_heap->config.gcEfficiency, .123456), "approxEqual(m_heap->config.gcEfficiency, .123456)", __FILE__, __LINE__);
           ;
     restoreHeapConfig();
 
     parseApply("-gcwork=0.23456");
-// line 293 "ST_mmgc_gcoption.st"
+// line 260 "ST_mmgc_gcoption.st"
 verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
-// line 294 "ST_mmgc_gcoption.st"
+// line 261 "ST_mmgc_gcoption.st"
 verifyPass(approxEqual(m_heap->config.gcEfficiency, .23456), "approxEqual(m_heap->config.gcEfficiency, .23456)", __FILE__, __LINE__);
           ;
     restoreHeapConfig();
 
     parseApply("-gcwork", "0.3456");
-// line 299 "ST_mmgc_gcoption.st"
+// line 266 "ST_mmgc_gcoption.st"
 verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
-// line 300 "ST_mmgc_gcoption.st"
+// line 267 "ST_mmgc_gcoption.st"
 verifyPass(approxEqual(m_heap->config.gcEfficiency, .3456), "approxEqual(m_heap->config.gcEfficiency, .3456)", __FILE__, __LINE__);
           ;
     restoreHeapConfig();
 
 }
 
 }
 void create_mmgc_gcoption(AvmCore* core) { new ST_mmgc_gcoption(core); }
 }
 }
 #endif
 
 // Generated from ST_mmgc_mmfx_array.st
 // -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */
 //
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 #include "avmshell.h"
 #ifdef VMCFG_SELFTEST
 namespace avmplus {
 namespace ST_mmgc_mmfx_array {
 class ST_mmgc_mmfx_array : public Selftest {
 public:
 ST_mmgc_mmfx_array(AvmCore* core);
@@ -3267,52 +3275,52 @@ using namespace MMgc;
 //     -> it should OOM and shutdown
 
 
 void ST_mmgc_mmfx_array::test0() {
     // This will cause an OOM abort and exit, run with -memlimit 1024
     int* m_ints = mmfx_new_array(int, 1048576);
     mmfx_delete_array(m_ints);
     m_ints = NULL;
-// line 60 "ST_mmgc_mmfx_array.st"
+// line 27 "ST_mmgc_mmfx_array.st"
 verifyPass(false, "false", __FILE__, __LINE__);
 
 }
 void ST_mmgc_mmfx_array::test1() {
     // This should fail and return NULL, run with -memlimit 1024
     int* m_ints = mmfx_new_array_opt(int, 1048576, MMgc::kCanFail);
-// line 65 "ST_mmgc_mmfx_array.st"
+// line 32 "ST_mmgc_mmfx_array.st"
 verifyPass(m_ints == NULL, "m_ints == NULL", __FILE__, __LINE__);
     mmfx_delete_array(m_ints);
     m_ints = NULL;
 
 }
 void ST_mmgc_mmfx_array::test2() {
     // This will cause an OOM abort and exit, run with -memlimit 1024
     int* m_ints = mmfx_new_array_opt(int, 1048576, MMgc::kZero);
     mmfx_delete_array(m_ints);
     m_ints = NULL;
-// line 74 "ST_mmgc_mmfx_array.st"
+// line 41 "ST_mmgc_mmfx_array.st"
 verifyPass(false, "false", __FILE__, __LINE__);
 
 
 
 }
 void create_mmgc_mmfx_array(AvmCore* core) { new ST_mmgc_mmfx_array(core); }
 }
 }
 #endif
 
 // Generated from ST_mmgc_threads.st
 // -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
 // vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
 //
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 #include "avmshell.h"
 #ifdef VMCFG_SELFTEST
 #if defined VMCFG_WORKERTHREADS
 namespace avmplus {
 namespace ST_mmgc_threads {
 class ST_mmgc_threads : public Selftest {
 public:
@@ -3440,26 +3448,26 @@ public:
 void ST_mmgc_threads::test0() {
        startSlave();
        MMGC_GCENTER(gc);
        RCObjectNotifier *obj = new (gc) RCObjectNotifier(&isDead);
        {
           gc->CreateRootFromCurrentStack(kickAndWait, this);
        }
 
-// line 155 "ST_mmgc_threads.st"
+// line 122 "ST_mmgc_threads.st"
 verifyPass(result, "result", __FILE__, __LINE__);
 
-// line 157 "ST_mmgc_threads.st"
+// line 124 "ST_mmgc_threads.st"
 verifyPass(!isDead, "!isDead", __FILE__, __LINE__);
        gc->ReapZCT();
-// line 159 "ST_mmgc_threads.st"
+// line 126 "ST_mmgc_threads.st"
 verifyPass(!isDead, "!isDead", __FILE__, __LINE__);
        gc->Collect();
-// line 161 "ST_mmgc_threads.st"
+// line 128 "ST_mmgc_threads.st"
 verifyPass(!isDead, "!isDead", __FILE__, __LINE__);
 
        pthread_join(pthread, NULL);
 
        printf("Ignore this: %d\n", *obj->isDead);
 
 }
 void create_mmgc_threads(AvmCore* core) { new ST_mmgc_threads(core); }
@@ -3467,19 +3475,19 @@ void create_mmgc_threads(AvmCore* core) 
 }
 #endif
 #endif
 
 // Generated from ST_mmgc_weakref.st
 // -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
 // vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
 //
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 #include "avmshell.h"
 #ifdef VMCFG_SELFTEST
 namespace avmplus {
 namespace ST_mmgc_weakref {
 using namespace MMgc;
 
 class C : public GCFinalizedObject
@@ -3588,17 +3596,17 @@ void ST_mmgc_weakref::test0() {
 
     delete cb;
 
     // Now reference all the odd-numbered objects and check the
     // integrity of their 'next' objects.  There's a chance this may
     // crash.
 
     for ( int i=1 ; i < 1000 ; i+= 2 ) {
-// line 137 "ST_mmgc_weakref.st"
+// line 104 "ST_mmgc_weakref.st"
 verifyPass(objs[i]->next->key == i-1, "objs[i]->next->key == i-1", __FILE__, __LINE__);
     }
 
     // Clean up
     VMPI_memset(refs, 0, sizeof(refs));
     VMPI_memset(objs, 0, sizeof(objs));
 }
 
@@ -3633,33 +3641,33 @@ void ST_mmgc_weakref::test1() {
 
     for ( int i=0 ; i < 1000 ; i+=2 )
         objs[i] = NULL;
 
     // Now trigger the collector again.
 
     gc->Collect();
 
-// line 180 "ST_mmgc_weakref.st"
+// line 147 "ST_mmgc_weakref.st"
 verifyPass(true, "true", __FILE__, __LINE__);
 }
 
 }
 void create_mmgc_weakref(AvmCore* core) { new ST_mmgc_weakref(core); }
 }
 }
 #endif
 
 // Generated from ST_nanojit_codealloc.st
 // -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
 // vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5)
 //
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 #include "avmshell.h"
 #ifdef VMCFG_SELFTEST
 namespace avmplus {
 namespace ST_nanojit_codealloc {
 
 // This conditionalization is clumsy, but we don't seem to have any other
 // mechanism to enable a selftest conditionally upon the configuration.
@@ -3855,33 +3863,33 @@ for (uint32_t i = 0; i < n_ap; i++) {
     driver->run(20000);
 #endif
     mmfx_delete(driver);
  }
 
 #endif /* VMCFG_NANOJIT */
 
 // We pass if we don't crash or assert.
-// line 223 "ST_nanojit_codealloc.st"
+// line 194 "ST_nanojit_codealloc.st"
 verifyPass(true, "true", __FILE__, __LINE__);
 
 
 }
 void create_nanojit_codealloc(AvmCore* core) { new ST_nanojit_codealloc(core); }
 }
 }
 #endif
 
 // Generated from ST_vmbase_concurrency.st
 // -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
 // vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
 //
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 #include "avmshell.h"
 #ifdef VMCFG_SELFTEST
 namespace avmplus {
 namespace ST_vmbase_concurrency {
 using namespace MMgc;
 using namespace vmbase;
 
@@ -4230,57 +4238,57 @@ case 8: test8(); return;
 case 9: test9(); return;
 }
 }
 void ST_vmbase_concurrency::test0() {
 #ifndef UNDER_CE
     TestRunner runner(THREAD_QTY);
     MutexTest test(ITERATIONS);
     runner.runTest(test);
-// line 361 "ST_vmbase_concurrency.st"
+// line 328 "ST_vmbase_concurrency.st"
 verifyPass(test.sharedCounter == THREAD_QTY * ITERATIONS, "test.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
 #endif
 
 }
 void ST_vmbase_concurrency::test1() {
 #ifndef UNDER_CE
     TestRunner runner(THREAD_QTY);
     ConditionTest test(ITERATIONS, THREAD_QTY);
     runner.runTest(test);
-// line 369 "ST_vmbase_concurrency.st"
+// line 336 "ST_vmbase_concurrency.st"
 verifyPass(test.sharedCounter == THREAD_QTY * ITERATIONS, "test.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
 #endif
 
 }
 void ST_vmbase_concurrency::test2() {
 #ifndef UNDER_CE
     TestRunner runner(THREAD_QTY);
     AtomicCounterTest test(ITERATIONS, THREAD_QTY);
     runner.runTest(test);
-// line 377 "ST_vmbase_concurrency.st"
+// line 344 "ST_vmbase_concurrency.st"
 verifyPass(test.sharedCounter == 0, "test.sharedCounter == 0", __FILE__, __LINE__);
 #endif
 
 }
 void ST_vmbase_concurrency::test3() {
 #ifndef UNDER_CE
     TestRunner runner(THREAD_QTY);
     CASTest test(ITERATIONS, false);
     runner.runTest(test);
-// line 385 "ST_vmbase_concurrency.st"
+// line 352 "ST_vmbase_concurrency.st"
 verifyPass(test.sharedCounter == THREAD_QTY * ITERATIONS, "test.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
 #endif
 
 }
 void ST_vmbase_concurrency::test4() {
 #ifndef UNDER_CE
     TestRunner runner(THREAD_QTY);
     CASTest test(ITERATIONS, true);
     runner.runTest(test);
-// line 393 "ST_vmbase_concurrency.st"
+// line 360 "ST_vmbase_concurrency.st"
 verifyPass(test.sharedCounter == THREAD_QTY * ITERATIONS, "test.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
 #endif
 
 }
 void ST_vmbase_concurrency::test5() {
 #ifndef UNDER_CE
     /* This test is failing on Windows and Mac OSX 10.4.
      * For Windows, see bug 609820.
@@ -4288,66 +4296,66 @@ void ST_vmbase_concurrency::test5() {
      * It could also be the test, or the compiler!
      * FIXME: bug 609943 Selftests to stress memory barriers (fences)
 
     // Note that the memory barrier test is based on a Dekker lock, so we
     // only ever use 2 threads.
     TestRunner runner(2);
     MemoryBarrierTest test(ITERATIONS);
     runner.runTest(test);
-// line 409 "ST_vmbase_concurrency.st"
+// line 376 "ST_vmbase_concurrency.st"
 verifyPass(test.sharedCounter == 2 * ITERATIONS, "test.sharedCounter == 2 * ITERATIONS", __FILE__, __LINE__);
     */
     
-// line 412 "ST_vmbase_concurrency.st"
+// line 379 "ST_vmbase_concurrency.st"
 verifyPass(true, "true", __FILE__, __LINE__);
 #endif
 
 }
 void ST_vmbase_concurrency::test6() {
 #ifndef UNDER_CE
     TestRunner runner(THREAD_QTY);
     ConditionWithWaitTest test(2000); // Use 2000 iterations with a 1 ms wait
     runner.runTest(test);
-// line 420 "ST_vmbase_concurrency.st"
+// line 387 "ST_vmbase_concurrency.st"
 verifyPass(test.sharedCounter == THREAD_QTY * 2000, "test.sharedCounter == THREAD_QTY * 2000", __FILE__, __LINE__);
 #endif
 
 }
 void ST_vmbase_concurrency::test7() {
 #ifndef UNDER_CE
     TestRunner runner(THREAD_QTY);
     SleepTest test(2000); // Use 2000 iterations with a 1 ms sleep
     runner.runTest(test);
-// line 428 "ST_vmbase_concurrency.st"
+// line 395 "ST_vmbase_concurrency.st"
 verifyPass(test.sharedCounter == THREAD_QTY * 2000, "test.sharedCounter == THREAD_QTY * 2000", __FILE__, __LINE__);
 #endif
 
 }
 void ST_vmbase_concurrency::test8() {
 #ifndef UNDER_CE
     TestRunner runner(THREAD_QTY);
     VMThreadLocalTest test(ITERATIONS);
     runner.runTest(test);
-// line 436 "ST_vmbase_concurrency.st"
+// line 403 "ST_vmbase_concurrency.st"
 verifyPass(test.sharedCounter == THREAD_QTY * ITERATIONS, "test.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
 #endif
 
 }
 void ST_vmbase_concurrency::test9() {
 #ifndef UNDER_CE
     // We should be able to run the dtor of a non-started VMThread.
     {
         VMThread vmthread;
     }
     // Run the mutex test but call the VMThread dtors without joining first
     TestRunner runner(THREAD_QTY, false);
     MutexTest test(ITERATIONS);
     runner.runTest(test);
-// line 449 "ST_vmbase_concurrency.st"
+// line 416 "ST_vmbase_concurrency.st"
 verifyPass(test.sharedCounter == THREAD_QTY * ITERATIONS, "test.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
 #endif
 
 
 
 
 
 }
@@ -4355,19 +4363,19 @@ void create_vmbase_concurrency(AvmCore* 
 }
 }
 #endif
 
 // Generated from ST_vmbase_safepoints.st
 // -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
 // vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
 //
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 #include "avmshell.h"
 #ifdef VMCFG_SELFTEST
 #if defined VMCFG_SAFEPOINTS && defined BUG_754918
 namespace avmplus {
 namespace ST_vmbase_safepoints {
 using namespace MMgc;
 using namespace vmbase;
@@ -4869,37 +4877,37 @@ case 1: test1(); return;
 case 2: test2(); return;
 }
 }
 void ST_vmbase_safepoints::test0() {
 #ifndef UNDER_CE
     TestRunner runner(THREAD_QTY!=0);
     SimpleTest test(runner.safepointManager(), ITERATIONS, THREAD_QTY);
     runner.runTest(test);
-// line 529 "ST_vmbase_safepoints.st"
+// line 496 "ST_vmbase_safepoints.st"
 verifyPass(test.sharedCounter == THREAD_QTY * ITERATIONS, "test.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
 #endif
 
 }
 void ST_vmbase_safepoints::test1() {
 #ifndef UNDER_CE
     TestRunner runner(THREAD_QTY!=0);
     ProducerConsumerTest test(runner.safepointManager(), ITERATIONS, THREAD_QTY);
     runner.runTest(test);
-// line 537 "ST_vmbase_safepoints.st"
+// line 504 "ST_vmbase_safepoints.st"
 verifyPass(test.sharedCounter == THREAD_QTY * ITERATIONS, "test.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
 #endif
 
 }
 void ST_vmbase_safepoints::test2() {
 #ifndef UNDER_CE
     TestRunner runner(THREAD_QTY!=0);
     NestedProducerConsumerTest test(runner.safepointManager(), ITERATIONS * 100, THREAD_QTY, NESTING_DEPTH);
     runner.runTest(test);
-// line 545 "ST_vmbase_safepoints.st"
+// line 512 "ST_vmbase_safepoints.st"
 verifyPass(test.sharedCounter == THREAD_QTY * ITERATIONS * 100, "test.sharedCounter == THREAD_QTY * ITERATIONS * 100", __FILE__, __LINE__);
 #endif
 
 
 
 
 }
 void create_vmbase_safepoints(AvmCore* core) { new ST_vmbase_safepoints(core); }
@@ -4907,19 +4915,19 @@ void create_vmbase_safepoints(AvmCore* c
 }
 #endif
 #endif
 
 // Generated from ST_vmpi_threads.st
 // -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
 // vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
 //
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 // Bugzilla 543560 - here we risk deleting an object that is still on the mark stack because
 // of how we perform large-object splitting.  The setup is that user code that deletes the object
 // gets to run after the first part of the large object has been popped off the mark stack
 // but before the rest has been handled.
 
 #include "avmshell.h"
 #ifdef VMCFG_SELFTEST
@@ -5282,182 +5290,181 @@ case 11: test11(); return;
 case 12: test12(); return;
 case 13: test13(); return;
 }
 }
 void ST_vmpi_threads::test0() {
 #ifndef UNDER_CE
     MutexTest mutexTest(THREAD_QTY, ITERATIONS);
     mutexTest.runTest();
-// line 367 "ST_vmpi_threads.st"
+// line 334 "ST_vmpi_threads.st"
 verifyPass(mutexTest.sharedCounter == THREAD_QTY * ITERATIONS, "mutexTest.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
 #endif
 
 }
 void ST_vmpi_threads::test1() {
 #ifndef UNDER_CE
     ConditionTest conditionTest(THREAD_QTY, ITERATIONS);
     conditionTest.runTest();
-// line 374 "ST_vmpi_threads.st"
+// line 341 "ST_vmpi_threads.st"
 verifyPass(conditionTest.sharedCounter == THREAD_QTY * ITERATIONS, "conditionTest.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
 #endif
 
 }
 void ST_vmpi_threads::test2() {
 #ifndef UNDER_CE
     AtomicIncrementTest atomicIncrementTest(THREAD_QTY, ITERATIONS, false);
     atomicIncrementTest.runTest();
-// line 381 "ST_vmpi_threads.st"
+// line 348 "ST_vmpi_threads.st"
 verifyPass(atomicIncrementTest.sharedCounter == THREAD_QTY * ITERATIONS, "atomicIncrementTest.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
 #endif
     
 }
 void ST_vmpi_threads::test3() {
 #ifndef UNDER_CE
     AtomicDecrementTest atomicDecrementTest(THREAD_QTY, ITERATIONS, false);
     atomicDecrementTest.runTest();
-// line 388 "ST_vmpi_threads.st"
+// line 355 "ST_vmpi_threads.st"
 verifyPass(atomicDecrementTest.sharedCounter == -(THREAD_QTY * ITERATIONS), "atomicDecrementTest.sharedCounter == -(THREAD_QTY * ITERATIONS)", __FILE__, __LINE__);
 #endif
     
 }
 void ST_vmpi_threads::test4() {
 #ifndef UNDER_CE
     CASTest casTest(THREAD_QTY, ITERATIONS, false);
     casTest.runTest();
-// line 395 "ST_vmpi_threads.st"
+// line 362 "ST_vmpi_threads.st"
 verifyPass(casTest.sharedCounter == THREAD_QTY * ITERATIONS, "casTest.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
 #endif
 
 }
 void ST_vmpi_threads::test5() {
 #ifndef UNDER_CE
     AtomicIncrementTest atomicIncrementTest(THREAD_QTY, ITERATIONS, true);
     atomicIncrementTest.runTest();
-// line 402 "ST_vmpi_threads.st"
+// line 369 "ST_vmpi_threads.st"
 verifyPass(atomicIncrementTest.sharedCounter == THREAD_QTY * ITERATIONS, "atomicIncrementTest.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
 #endif
     
 }
 void ST_vmpi_threads::test6() {
 #ifndef UNDER_CE
     AtomicDecrementTest atomicDecrementTest(THREAD_QTY, ITERATIONS, true);
     atomicDecrementTest.runTest();
-// line 409 "ST_vmpi_threads.st"
+// line 376 "ST_vmpi_threads.st"
 verifyPass(atomicDecrementTest.sharedCounter == -(THREAD_QTY * ITERATIONS), "atomicDecrementTest.sharedCounter == -(THREAD_QTY * ITERATIONS)", __FILE__, __LINE__);
 #endif
     
 }
 void ST_vmpi_threads::test7() {
 #ifndef UNDER_CE
     CASTest casTest(THREAD_QTY, ITERATIONS, true);
     casTest.runTest();
-// line 416 "ST_vmpi_threads.st"
+// line 383 "ST_vmpi_threads.st"
 verifyPass(casTest.sharedCounter == THREAD_QTY * ITERATIONS, "casTest.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
 #endif
 
 }
 void ST_vmpi_threads::test8() {
 #ifndef UNDER_CE
     /* This test is failing on Windows and Mac OSX 10.4.
      * For Windows, see bug 609820.
      * For Mac, are the 10.4 APIs not reliable?
      * It could also be the test, or the compiler!
      * FIXME: bug 609943 Selftests to stress memory barriers (fences)
     
     // Note that the memory barrier test is based on a Dekker lock, so we
     // only ever use 2 threads.
     MemoryBarrierTest memoryBarrierTest(ITERATIONS);
     memoryBarrierTest.runTest();
-// line 431 "ST_vmpi_threads.st"
+// line 398 "ST_vmpi_threads.st"
 verifyPass(memoryBarrierTest.sharedCounter == 2 * ITERATIONS, "memoryBarrierTest.sharedCounter == 2 * ITERATIONS", __FILE__, __LINE__);
     
     */
-// line 434 "ST_vmpi_threads.st"
+// line 401 "ST_vmpi_threads.st"
 verifyPass(true, "true", __FILE__, __LINE__);
 #endif
 
 }
 void ST_vmpi_threads::test9() {
 #ifndef UNDER_CE
     TryLockTest tryLockTest(THREAD_QTY, ITERATIONS);
     tryLockTest.runTest();
-// line 441 "ST_vmpi_threads.st"
+// line 408 "ST_vmpi_threads.st"
 verifyPass(tryLockTest.sharedCounter == THREAD_QTY * ITERATIONS, "tryLockTest.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
 #endif
 
 }
 void ST_vmpi_threads::test10() {
 #ifndef UNDER_CE
     // Use 2000 iterations with a 1 ms wait
     ConditionWithWaitTest conditionWithWaitTest(THREAD_QTY, 2000);
     conditionWithWaitTest.runTest();
-// line 449 "ST_vmpi_threads.st"
+// line 416 "ST_vmpi_threads.st"
 verifyPass(conditionWithWaitTest.sharedCounter == THREAD_QTY * 2000, "conditionWithWaitTest.sharedCounter == THREAD_QTY * 2000", __FILE__, __LINE__);
 #endif
 
 }
 void ST_vmpi_threads::test11() {
 #ifndef UNDER_CE
     // Use 2000 iterations with a 1 ms sleep
     SleepTest sleepTest(THREAD_QTY, 2000);
     sleepTest.runTest();
-// line 457 "ST_vmpi_threads.st"
+// line 424 "ST_vmpi_threads.st"
 verifyPass(sleepTest.sharedCounter == THREAD_QTY * 2000, "sleepTest.sharedCounter == THREAD_QTY * 2000", __FILE__, __LINE__);
 #endif
 
 }
 void ST_vmpi_threads::test12() {
 #ifndef UNDER_CE
     // We can't really test for much here...
     vmpi_thread_t thread;
     VMPI_threadCreate(&thread, NULL, ThreadTestBase::detachbleThreadEntry, NULL);
-// line 465 "ST_vmpi_threads.st"
+// line 432 "ST_vmpi_threads.st"
 verifyPass(true, "true", __FILE__, __LINE__);
 #endif
 
 }
 void ST_vmpi_threads::test13() {
 #ifndef UNDER_CE
     vmpi_thread_attr_t attr;
-// line 471 "ST_vmpi_threads.st"
+// line 438 "ST_vmpi_threads.st"
 verifyPass(VMPI_threadAttrInit(&attr) == true, "VMPI_threadAttrInit(&attr) == true", __FILE__, __LINE__);
     
     VMPI_threadAttrSetGuardSize(&attr, VMPI_threadAttrDefaultGuardSize());
     VMPI_threadAttrSetStackSize(&attr, VMPI_threadAttrDefaultStackSize());
     VMPI_threadAttrSetPriorityLow(&attr);
     VMPI_threadAttrSetPriorityNormal(&attr);
     VMPI_threadAttrSetPriorityHigh(&attr);
     
     vmpi_thread_t thread;
     bool started = VMPI_threadCreate(&thread, &attr, ThreadTestBase::joinableThreadEntry, NULL);
-// line 481 "ST_vmpi_threads.st"
+// line 448 "ST_vmpi_threads.st"
 verifyPass(started == true, "started == true", __FILE__, __LINE__);
     if (started) {
         VMPI_threadJoin(thread);
     }
     
-// line 486 "ST_vmpi_threads.st"
+// line 453 "ST_vmpi_threads.st"
 verifyPass(VMPI_threadAttrDestroy(&attr) == true, "VMPI_threadAttrDestroy(&attr) == true", __FILE__, __LINE__);
 #endif
 
 
 }
 void create_vmpi_threads(AvmCore* core) { new ST_vmpi_threads(core); }
 }
 }
 #endif
 
 // Generated from ST_workers_Buffer.st
-// -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
-// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
-//
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
+// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5)
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 #include "avmshell.h"
 #ifdef VMCFG_SELFTEST
 #if !defined DEBUGGER
 namespace avmplus {
 namespace ST_workers_Buffers {
 class ST_workers_Buffers : public Selftest {
 public:
@@ -5476,17 +5483,16 @@ void test4();
 void test5();
 void test6();
 void test7();
     MMgc::GC *gc;
     NoSyncSingleItemBuffer *singleItemBuffer;
     NoSyncMultiItemBuffer *multiItemBuffer;
     NonBlockingMultiItemBuffer *nonBlockMultiItemBuffer;
     Atom *atom;
-    ChannelItem* itemp;
  
 };
 ST_workers_Buffers::ST_workers_Buffers(AvmCore* core)
     : Selftest(core, "workers", "Buffers", ST_workers_Buffers::ST_names,ST_workers_Buffers::ST_explicits)
 {}
 const char* ST_workers_Buffers::ST_names[] = {"NonBlockMultiItemConstructor","NonBlockMultiItemEmptyBuffer","NonBlockMultiItemFullBuffer","SingleConstructor","SingleEmptyBuffer","SingleFullBuffer","MultiConstructor","MultiEmptyBuffer", NULL };
 const bool ST_workers_Buffers::ST_explicits[] = {false,false,false,false,false,false,false,false, false };
 void ST_workers_Buffers::run(int n) {
@@ -5515,124 +5521,124 @@ void ST_workers_Buffers::epilogue() {
     delete singleItemBuffer;
     delete multiItemBuffer;
     delete nonBlockMultiItemBuffer;
 	delete gc;
     free(atom);
 
 }
 void ST_workers_Buffers::test0() {
-// line 72 "ST_workers_Buffer.st"
+// line 37 "ST_workers_Buffer.st"
 verifyPass(nonBlockMultiItemBuffer!=NULL, "nonBlockMultiItemBuffer!=NULL", __FILE__, __LINE__);
 
 }
 void ST_workers_Buffers::test1() {
-// line 75 "ST_workers_Buffer.st"
+// line 40 "ST_workers_Buffer.st"
 verifyPass(nonBlockMultiItemBuffer->isEmpty(), "nonBlockMultiItemBuffer->isEmpty()", __FILE__, __LINE__);
-// line 76 "ST_workers_Buffer.st"
+// line 41 "ST_workers_Buffer.st"
 verifyPass(!nonBlockMultiItemBuffer->isFull(), "!nonBlockMultiItemBuffer->isFull()", __FILE__, __LINE__);
-// line 77 "ST_workers_Buffer.st"
+// line 42 "ST_workers_Buffer.st"
 verifyPass(!nonBlockMultiItemBuffer->get(atom), "!nonBlockMultiItemBuffer->get(atom)", __FILE__, __LINE__);
 
 }
 void ST_workers_Buffers::test2() {
     bool result;
     for (int i=0;i<14;i++) {
         result=nonBlockMultiItemBuffer->put(String::createLatin1(core,"test string")->atom());
-// line 83 "ST_workers_Buffer.st"
+// line 48 "ST_workers_Buffer.st"
 verifyPass(result, "result", __FILE__, __LINE__);
-// line 84 "ST_workers_Buffer.st"
+// line 49 "ST_workers_Buffer.st"
 verifyPass(!nonBlockMultiItemBuffer->isEmpty(), "!nonBlockMultiItemBuffer->isEmpty()", __FILE__, __LINE__);
-// line 85 "ST_workers_Buffer.st"
+// line 50 "ST_workers_Buffer.st"
 verifyPass(!nonBlockMultiItemBuffer->isFull(), "!nonBlockMultiItemBuffer->isFull()", __FILE__, __LINE__);
     }
     result=nonBlockMultiItemBuffer->put(String::createLatin1(core,"test string")->atom());
-// line 88 "ST_workers_Buffer.st"
+// line 53 "ST_workers_Buffer.st"
 verifyPass(result, "result", __FILE__, __LINE__);
-// line 89 "ST_workers_Buffer.st"
+// line 54 "ST_workers_Buffer.st"
 verifyPass(!nonBlockMultiItemBuffer->isEmpty(), "!nonBlockMultiItemBuffer->isEmpty()", __FILE__, __LINE__);
-// line 90 "ST_workers_Buffer.st"
+// line 55 "ST_workers_Buffer.st"
 verifyPass(nonBlockMultiItemBuffer->isFull(), "nonBlockMultiItemBuffer->isFull()", __FILE__, __LINE__);
 
     result=nonBlockMultiItemBuffer->put(String::createLatin1(core,"test string")->atom());
-// line 93 "ST_workers_Buffer.st"
+// line 58 "ST_workers_Buffer.st"
 verifyPass(!result, "!result", __FILE__, __LINE__);
-// line 94 "ST_workers_Buffer.st"
+// line 59 "ST_workers_Buffer.st"
 verifyPass(!nonBlockMultiItemBuffer->isEmpty(), "!nonBlockMultiItemBuffer->isEmpty()", __FILE__, __LINE__);
-// line 95 "ST_workers_Buffer.st"
+// line 60 "ST_workers_Buffer.st"
 verifyPass(nonBlockMultiItemBuffer->isFull(), "nonBlockMultiItemBuffer->isFull()", __FILE__, __LINE__);
 
     for (int i=0;i<14;i++) {
-// line 98 "ST_workers_Buffer.st"
+// line 63 "ST_workers_Buffer.st"
 verifyPass(nonBlockMultiItemBuffer->get(atom), "nonBlockMultiItemBuffer->get(atom)", __FILE__, __LINE__);
-// line 99 "ST_workers_Buffer.st"
+// line 64 "ST_workers_Buffer.st"
 verifyPass(!nonBlockMultiItemBuffer->isEmpty(), "!nonBlockMultiItemBuffer->isEmpty()", __FILE__, __LINE__);
-// line 100 "ST_workers_Buffer.st"
+// line 65 "ST_workers_Buffer.st"
 verifyPass(!nonBlockMultiItemBuffer->isFull(), "!nonBlockMultiItemBuffer->isFull()", __FILE__, __LINE__);
     }
-// line 102 "ST_workers_Buffer.st"
+// line 67 "ST_workers_Buffer.st"
 verifyPass(nonBlockMultiItemBuffer->get(atom), "nonBlockMultiItemBuffer->get(atom)", __FILE__, __LINE__);
-// line 103 "ST_workers_Buffer.st"
+// line 68 "ST_workers_Buffer.st"
 verifyPass(nonBlockMultiItemBuffer->isEmpty(), "nonBlockMultiItemBuffer->isEmpty()", __FILE__, __LINE__);
-// line 104 "ST_workers_Buffer.st"
+// line 69 "ST_workers_Buffer.st"
 verifyPass(!nonBlockMultiItemBuffer->isFull(), "!nonBlockMultiItemBuffer->isFull()", __FILE__, __LINE__);
 
-// line 106 "ST_workers_Buffer.st"
+// line 71 "ST_workers_Buffer.st"
 verifyPass(!nonBlockMultiItemBuffer->get(atom), "!nonBlockMultiItemBuffer->get(atom)", __FILE__, __LINE__);
-// line 107 "ST_workers_Buffer.st"
+// line 72 "ST_workers_Buffer.st"
 verifyPass(nonBlockMultiItemBuffer->isEmpty(), "nonBlockMultiItemBuffer->isEmpty()", __FILE__, __LINE__);
-// line 108 "ST_workers_Buffer.st"
+// line 73 "ST_workers_Buffer.st"
 verifyPass(!nonBlockMultiItemBuffer->isFull(), "!nonBlockMultiItemBuffer->isFull()", __FILE__, __LINE__);
 
 }
 void ST_workers_Buffers::test3() {
-// line 111 "ST_workers_Buffer.st"
+// line 76 "ST_workers_Buffer.st"
 verifyPass(singleItemBuffer!=NULL, "singleItemBuffer!=NULL", __FILE__, __LINE__);
 
 }
 void ST_workers_Buffers::test4() {
-// line 114 "ST_workers_Buffer.st"
+// line 79 "ST_workers_Buffer.st"
 verifyPass(singleItemBuffer->isEmpty(), "singleItemBuffer->isEmpty()", __FILE__, __LINE__);
-// line 115 "ST_workers_Buffer.st"
+// line 80 "ST_workers_Buffer.st"
 verifyPass(!singleItemBuffer->isFull(), "!singleItemBuffer->isFull()", __FILE__, __LINE__);
-// line 116 "ST_workers_Buffer.st"
+// line 81 "ST_workers_Buffer.st"
 verifyPass(!singleItemBuffer->get(atom), "!singleItemBuffer->get(atom)", __FILE__, __LINE__);
 
 }
 void ST_workers_Buffers::test5() {
     bool result;
     result=singleItemBuffer->put(String::createLatin1(core,"test string")->atom());
-// line 121 "ST_workers_Buffer.st"
+// line 86 "ST_workers_Buffer.st"
 verifyPass(result, "result", __FILE__, __LINE__);
-// line 122 "ST_workers_Buffer.st"
+// line 87 "ST_workers_Buffer.st"
 verifyPass(!singleItemBuffer->isEmpty(), "!singleItemBuffer->isEmpty()", __FILE__, __LINE__);
-// line 123 "ST_workers_Buffer.st"
+// line 88 "ST_workers_Buffer.st"
 verifyPass(singleItemBuffer->isFull(), "singleItemBuffer->isFull()", __FILE__, __LINE__);
     result=singleItemBuffer->put(String::createLatin1(core,"test string")->atom());
-// line 125 "ST_workers_Buffer.st"
+// line 90 "ST_workers_Buffer.st"
 verifyPass(!result, "!result", __FILE__, __LINE__);
-// line 126 "ST_workers_Buffer.st"
+// line 91 "ST_workers_Buffer.st"
 verifyPass(singleItemBuffer->get(atom), "singleItemBuffer->get(atom)", __FILE__, __LINE__);
-// line 127 "ST_workers_Buffer.st"
+// line 92 "ST_workers_Buffer.st"
 verifyPass(singleItemBuffer->isEmpty(), "singleItemBuffer->isEmpty()", __FILE__, __LINE__);
-// line 128 "ST_workers_Buffer.st"
+// line 93 "ST_workers_Buffer.st"
 verifyPass(!singleItemBuffer->isFull(), "!singleItemBuffer->isFull()", __FILE__, __LINE__);
 
 }
 void ST_workers_Buffers::test6() {
-// line 131 "ST_workers_Buffer.st"
+// line 96 "ST_workers_Buffer.st"
 verifyPass(multiItemBuffer!=NULL, "multiItemBuffer!=NULL", __FILE__, __LINE__);
 
 }
 void ST_workers_Buffers::test7() {
-// line 134 "ST_workers_Buffer.st"
+// line 99 "ST_workers_Buffer.st"
 verifyPass(singleItemBuffer->isEmpty(), "singleItemBuffer->isEmpty()", __FILE__, __LINE__);
-// line 135 "ST_workers_Buffer.st"
+// line 100 "ST_workers_Buffer.st"
 verifyPass(!singleItemBuffer->isFull(), "!singleItemBuffer->isFull()", __FILE__, __LINE__);
-// line 136 "ST_workers_Buffer.st"
+// line 101 "ST_workers_Buffer.st"
 verifyPass(!singleItemBuffer->get(atom), "!singleItemBuffer->get(atom)", __FILE__, __LINE__);
 
 // Bugzilla: https://bugzilla.mozilla.org/show_bug.cgi?id=758260
 //%%test MultiFullBuffer
 //    bool result;
 //    for (int i=0;i<15;i++) {
 //        ChannelItem item;
 //        item.tag = kDoubleType;
@@ -5660,22 +5666,21 @@ verifyPass(!singleItemBuffer->get(atom),
 }
 void create_workers_Buffers(AvmCore* core) { new ST_workers_Buffers(core); }
 }
 }
 #endif
 #endif
 
 // Generated from ST_workers_NoSyncSingleItemBuffer.st
-// -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
-// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
-//
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
+// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5)
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 #include "avmshell.h"
 #ifdef VMCFG_SELFTEST
 #if !defined DEBUGGER
 namespace avmplus {
 namespace ST_workers_NoSyncSingleItemBuffer {
 class ST_workers_NoSyncSingleItemBuffer : public Selftest {
 public:
@@ -5716,64 +5721,63 @@ void ST_workers_NoSyncSingleItemBuffer::
 }
 void ST_workers_NoSyncSingleItemBuffer::epilogue() {
 	delete buffer;
     free(atom);
 	
 }
 
 void ST_workers_NoSyncSingleItemBuffer::test0() {
-// line 64 "ST_workers_NoSyncSingleItemBuffer.st"
+// line 30 "ST_workers_NoSyncSingleItemBuffer.st"
 verifyPass(buffer!=NULL, "buffer!=NULL", __FILE__, __LINE__);
 	
 }
 void ST_workers_NoSyncSingleItemBuffer::test1() {
-// line 67 "ST_workers_NoSyncSingleItemBuffer.st"
+// line 33 "ST_workers_NoSyncSingleItemBuffer.st"
 verifyPass(buffer->isEmpty(), "buffer->isEmpty()", __FILE__, __LINE__);
-// line 68 "ST_workers_NoSyncSingleItemBuffer.st"
+// line 34 "ST_workers_NoSyncSingleItemBuffer.st"
 verifyPass(!buffer->isFull(), "!buffer->isFull()", __FILE__, __LINE__);
-// line 69 "ST_workers_NoSyncSingleItemBuffer.st"
+// line 35 "ST_workers_NoSyncSingleItemBuffer.st"
 verifyPass(!buffer->get(atom), "!buffer->get(atom)", __FILE__, __LINE__);
 	
 }
 void ST_workers_NoSyncSingleItemBuffer::test2() {
     buffer->put(String::createLatin1(core,"test string")->atom());
-// line 73 "ST_workers_NoSyncSingleItemBuffer.st"
+// line 39 "ST_workers_NoSyncSingleItemBuffer.st"
 verifyPass(!buffer->isEmpty(), "!buffer->isEmpty()", __FILE__, __LINE__);
-// line 74 "ST_workers_NoSyncSingleItemBuffer.st"
+// line 40 "ST_workers_NoSyncSingleItemBuffer.st"
 verifyPass(buffer->isFull(), "buffer->isFull()", __FILE__, __LINE__);
-// line 75 "ST_workers_NoSyncSingleItemBuffer.st"
+// line 41 "ST_workers_NoSyncSingleItemBuffer.st"
 verifyPass(buffer->get(atom), "buffer->get(atom)", __FILE__, __LINE__);
-// line 76 "ST_workers_NoSyncSingleItemBuffer.st"
+// line 42 "ST_workers_NoSyncSingleItemBuffer.st"
 verifyPass(buffer->isEmpty(), "buffer->isEmpty()", __FILE__, __LINE__);
-// line 77 "ST_workers_NoSyncSingleItemBuffer.st"
+// line 43 "ST_workers_NoSyncSingleItemBuffer.st"
 verifyPass(!buffer->isFull(), "!buffer->isFull()", __FILE__, __LINE__);
 	
 }
 void ST_workers_NoSyncSingleItemBuffer::test3() {
     buffer->unregisterRoot();
-// line 81 "ST_workers_NoSyncSingleItemBuffer.st"
+// line 47 "ST_workers_NoSyncSingleItemBuffer.st"
 verifyPass(true, "true", __FILE__, __LINE__);
 
 	
 
 }
 void create_workers_NoSyncSingleItemBuffer(AvmCore* core) { new ST_workers_NoSyncSingleItemBuffer(core); }
 }
 }
 #endif
 #endif
 
 // Generated from ST_workers_Promise.st
-// -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
-// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
-//
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+// -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
+// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5)
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 #include "avmshell.h"
 #ifdef VMCFG_SELFTEST
 namespace avmplus {
 namespace ST_workers_Promise {
 class ST_workers_Promise : public Selftest {
 public:
 ST_workers_Promise(AvmCore* core);
@@ -5798,26 +5802,26 @@ case 0: test0(); return;
 }
 void ST_workers_Promise::prologue() {
     main=core->getIsolate();
 
 
 }
 void ST_workers_Promise::test0() {
     // verify the main worker can be retrieved from AvmCore
-// line 53 "ST_workers_Promise.st"
+// line 19 "ST_workers_Promise.st"
 verifyPass(main!=NULL, "main!=NULL", __FILE__, __LINE__);
     uint32_t state=main->getAggregate()->queryState(main);
     // verify state == RUNNING
-// line 56 "ST_workers_Promise.st"
+// line 22 "ST_workers_Promise.st"
 verifyPass(state==3, "state==3", __FILE__, __LINE__);
 
-// line 58 "ST_workers_Promise.st"
-// verifyPass(main->targetCore() == core, "main->targetCore() == core", __FILE__, __LINE__);
-// line 59 "ST_workers_Promise.st"
+// line 24 "ST_workers_Promise.st"
+verifyPass(main->getAvmCore() == core, "main->getAvmCore() == core", __FILE__, __LINE__);
+// line 25 "ST_workers_Promise.st"
 verifyPass(main->isParentOf(main) == false, "main->isParentOf(main) == false", __FILE__, __LINE__);
 
 
 }
 void create_workers_Promise(AvmCore* core) { new ST_workers_Promise(core); }
 }
 }
 #endif