fix GC-related crash in codegen (microsoft#10944)

* set refMask when building object/array literals

* limit size of ldlit sections

---------

Co-authored-by: Abhijith Chatra <abchatra@microsoft.com>

Author: mmoskal

pxtcompiler/emitter/emitter.ts

@@ -1839,9 +1839,12 @@ ${lbl}: .short 0xffff
             let eltT = arrayElementType(typeOf(node))
             let coll = ir.shared(ir.rtcall("Array_::mk", []))
             for (let elt of node.elements) {
-                let mask = isRefCountedExpr(elt) ? 2 : 0
+                let mask = isRefCountedExpr(elt) ? (1 << 1) : 0
                 proc.emitExpr(ir.rtcall("Array_::push", [coll, emitExpr(elt)], mask))
             }
+            if (node.elements.length > 0)
+                // Make sure there is at least one use of the array, so it doesn't get GC-ed away in the last push.
+                proc.emitExpr(ir.rtcall("langsupp::ignore", [coll], 1))
             return coll
         }
         function emitObjectLiteral(node: ObjectLiteralExpression) {
@@ -1851,6 +1854,7 @@ ${lbl}: .short 0xffff
 
                 let keyName: string
                 let init: ir.Expr
+                let mask = 0
                 if (p.kind == SK.ShorthandPropertyAssignment) {
                     const sp = p as ShorthandPropertyAssignment
                     assert(!sp.equalsToken && !sp.objectAssignmentInitializer) // disallowed by TS grammar checker
@@ -1874,6 +1878,8 @@ ${lbl}: .short 0xffff
                     keyName = p.name.kind == SK.StringLiteral ?
                         (p.name as StringLiteral).text : p.name.getText();
                     init = emitExpr(p.initializer)
+                    if (isRefCountedExpr(p.initializer))
+                        mask |= 1 << 2
                 }
                 const fieldId = target.isNative
                     ? ir.numlit(getIfaceMemberId(keyName))
@@ -1883,8 +1889,11 @@ ${lbl}: .short 0xffff
                     fieldId,
                     init
                 ];
-                proc.emitExpr(ir.rtcall(target.isNative ? "pxtrt::mapSet" : "pxtrt::mapSetByString", args))
+                proc.emitExpr(ir.rtcall(target.isNative ? "pxtrt::mapSet" : "pxtrt::mapSetByString", args, mask))
             })
+            // Make sure there is at least one use of the map, so it doesn't get GC-ed away in the last mapSet.
+            if (node.properties.length > 0)
+                proc.emitExpr(ir.rtcall("langsupp::ignore", [expr], 1))
             return expr
         }
         function emitPropertyAssignment(node: PropertyDeclaration) {
@@ -3359,7 +3368,7 @@ ${lbl}: .short 0xffff
                 } else if (decl && (decl.kind == SK.PropertySignature || decl.kind == SK.PropertyAssignment || isSlowField(decl))) {
                     proc.emitExpr(emitCallCore(trg, trg, [src], null, decl as FunctionLikeDeclaration))
                 } else {
-                    for (;;) {
+                    for (; ;) {
                         if (trg.kind === SK.PropertyAccessExpression) {
                             const idx = fieldIndex(trg as PropertyAccessExpression)
                             const fld = getFieldInfo(idx.classInfo, idx.name)

pxtcompiler/emitter/thumb.ts

@@ -261,16 +261,27 @@ namespace ts.pxtc.thumb {
             let values: pxt.Map<string> = {}
             let seq = 1
 
+            const isLdLit = (line: assembler.Line) =>
+                line.type == "instruction" && line.instruction && line.instruction.name == "ldlit";
+
             for (let i = 0; i < f.lines.length; ++i) {
                 let line = f.lines[i]
                 outlines.push(line)
-                if (line.type == "instruction" && line.instruction && line.instruction.name == "ldlit") {
+                if (isLdLit(line)) {
                     if (!nextGoodSpot) {
                         let limit = line.location + 900 // leave some space - real limit is 1020
                         let j = i + 1
+                        let numLdLits = 0;
                         for (; j < f.lines.length; ++j) {
                             if (f.lines[j].location > limit)
                                 break
+                            if (isLdLit(f.lines[j])) {
+                                numLdLits++;
+                                // Short branches have 256 bytes range. We don't want to move code by anywhere
+                                // close to that. Each ldlit is 4 bytes.
+                                if (numLdLits >= 160 / 4)
+                                    break;
+                            }
                             let op = f.lines[j].getOp()
                             if (op == "b" || op == "bb" || (op == "pop" && f.lines[j].words[2] == "pc"))
                                 nextGoodSpot = f.lines[j]