Bug 1464321 - Changed return type of two methods in JSScript with relative format string change. r=arai
authormaharsh312 <maharsh312@gmail.com>
Sun, 27 May 2018 04:00:06 +0530
changeset 420055 2e7a4d376aff00ae43f8051aa53af8be65a112a3
parent 420054 77556644313634eb856cd67c93e7c5993d6e574c
child 420056 2263ea88eb0622434836392f3a922b172a66b2d9
push id103693
push usernbeleuzu@mozilla.com
push dateSun, 27 May 2018 07:25:29 +0000
treeherdermozilla-inbound@2e7a4d376aff [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersarai
bugs1464321
milestone62.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1464321 - Changed return type of two methods in JSScript with relative format string change. r=arai
js/src/gc/Tracer.cpp
js/src/jit/BaselineBailouts.cpp
js/src/jit/BaselineCompiler.cpp
js/src/jit/BaselineDebugModeOSR.cpp
js/src/jit/BaselineIC.cpp
js/src/jit/C1Spewer.cpp
js/src/jit/CodeGenerator.cpp
js/src/jit/Ion.cpp
js/src/jit/IonBuilder.cpp
js/src/jit/IonIC.cpp
js/src/jit/JSJitFrameIter.cpp
js/src/jit/JSONSpewer.cpp
js/src/jit/JitFrames.cpp
js/src/jit/JitcodeMap.cpp
js/src/jit/MIR.cpp
js/src/jit/RematerializedFrame.cpp
js/src/jit/SharedIC.cpp
js/src/jit/shared/CodeGenerator-shared.cpp
js/src/shell/js.cpp
js/src/vm/BytecodeUtil.cpp
js/src/vm/CodeCoverage.cpp
js/src/vm/Debugger.cpp
js/src/vm/EnvironmentObject.cpp
js/src/vm/JSObject.cpp
js/src/vm/JSScript.h
js/src/vm/TypeInference.cpp
js/src/vtune/VTuneWrapper.cpp
--- a/js/src/gc/Tracer.cpp
+++ b/js/src/gc/Tracer.cpp
@@ -436,17 +436,17 @@ JS_GetTraceThingInfo(char* buf, size_t b
                 snprintf(buf, bufsize, " <no private>");
             }
             break;
           }
 
           case JS::TraceKind::Script:
           {
             JSScript* script = static_cast<JSScript*>(thing);
-            snprintf(buf, bufsize, " %s:%zu", script->filename(), script->lineno());
+            snprintf(buf, bufsize, " %s:%u", script->filename(), script->lineno());
             break;
           }
 
           case JS::TraceKind::String:
           {
             *buf++ = ' ';
             bufsize--;
             JSString* str = (JSString*)thing;
--- a/js/src/jit/BaselineBailouts.cpp
+++ b/js/src/jit/BaselineBailouts.cpp
@@ -673,17 +673,17 @@ InitFromBailout(JSContext* cx, size_t fr
     // +---------------+
     // |    StackS     |
     // +---------------+  --- IF NOT LAST INLINE FRAME,
     // |  Descr(BLJS)  |  --- CALLING INFO STARTS HERE
     // +---------------+
     // |  ReturnAddr   | <-- return into main jitcode after IC
     // +===============+
 
-    JitSpew(JitSpew_BaselineBailouts, "      Unpacking %s:%zu", script->filename(), script->lineno());
+    JitSpew(JitSpew_BaselineBailouts, "      Unpacking %s:%u", script->filename(), script->lineno());
     JitSpew(JitSpew_BaselineBailouts, "      [BASELINE-JS FRAME]");
 
     // Calculate and write the previous frame pointer value.
     // Record the virtual stack offset at this location.  Later on, if we end up
     // writing out a BaselineStub frame for the next callee, we'll need to save the
     // address.
     void* prevFramePtr = builder.calculatePrevFramePtr();
     if (!builder.writePtr(prevFramePtr, "PrevFramePtr"))
@@ -1060,17 +1060,17 @@ InitFromBailout(JSContext* cx, size_t fr
                 // arguments in the slots and not be 4.
                 MOZ_ASSERT(exprStackSlots == expectedDepth);
             }
         }
     }
 #endif
 
 #ifdef JS_JITSPEW
-    JitSpew(JitSpew_BaselineBailouts, "      Resuming %s pc offset %d (op %s) (line %d) of %s:%zu",
+    JitSpew(JitSpew_BaselineBailouts, "      Resuming %s pc offset %d (op %s) (line %d) of %s:%u",
                 resumeAfter ? "after" : "at", (int) pcOff, CodeName[op],
                 PCToLineNumber(script, pc), script->filename(), script->lineno());
     JitSpew(JitSpew_BaselineBailouts, "      Bailout kind: %s",
             BailoutKindString(bailoutKind));
 #endif
 
     bool pushedNewTarget = IsConstructorCallPC(pc);
 
@@ -1236,17 +1236,17 @@ InitFromBailout(JSContext* cx, size_t fr
             if (filename == nullptr)
                 filename = "<unknown>";
             unsigned len = strlen(filename) + 200;
             char* buf = js_pod_malloc<char>(len);
             if (buf == nullptr) {
                 ReportOutOfMemory(cx);
                 return false;
             }
-            snprintf(buf, len, "%s %s %s on line %u of %s:%zu",
+            snprintf(buf, len, "%s %s %s on line %u of %s:%u",
                      BailoutKindString(bailoutKind),
                      resumeAfter ? "after" : "at",
                      CodeName[op],
                      PCToLineNumber(script, pc),
                      filename,
                      script->lineno());
             cx->runtime()->geckoProfiler().markEvent(buf);
             js_free(buf);
@@ -1560,17 +1560,17 @@ jit::BailoutIonToBaseline(JSContext* cx,
     //      +---------------+
     //      |  ReturnAddr   |
     //      +---------------+
     //      |    |||||      | <---- Overwrite starting here.
     //      |    |||||      |
     //      |    |||||      |
     //      +---------------+
 
-    JitSpew(JitSpew_BaselineBailouts, "Bailing to baseline %s:%zu (IonScript=%p) (FrameType=%d)",
+    JitSpew(JitSpew_BaselineBailouts, "Bailing to baseline %s:%u (IonScript=%p) (FrameType=%d)",
             iter.script()->filename(), iter.script()->lineno(), (void*) iter.ionScript(),
             (int) prevFrameType);
 
     bool catchingException;
     bool propagatingExceptionForDebugMode;
     if (excInfo) {
         catchingException = excInfo->catchingException();
         propagatingExceptionForDebugMode = excInfo->propagatingIonExceptionForDebugMode();
@@ -1608,17 +1608,17 @@ jit::BailoutIonToBaseline(JSContext* cx,
 
 #ifdef TRACK_SNAPSHOTS
     snapIter.spewBailingFrom();
 #endif
 
     RootedFunction callee(cx, iter.maybeCallee());
     RootedScript scr(cx, iter.script());
     if (callee) {
-        JitSpew(JitSpew_BaselineBailouts, "  Callee function (%s:%zu)",
+        JitSpew(JitSpew_BaselineBailouts, "  Callee function (%s:%u)",
                 scr->filename(), scr->lineno());
     } else {
         JitSpew(JitSpew_BaselineBailouts, "  No callee!");
     }
 
     if (iter.isConstructing())
         JitSpew(JitSpew_BaselineBailouts, "  Constructing!");
     else
@@ -1734,57 +1734,57 @@ InvalidateAfterBailout(JSContext* cx, Ha
 
     JitSpew(JitSpew_BaselineBailouts, "Invalidating due to %s", reason);
     Invalidate(cx, outerScript);
 }
 
 static void
 HandleBoundsCheckFailure(JSContext* cx, HandleScript outerScript, HandleScript innerScript)
 {
-    JitSpew(JitSpew_IonBailouts, "Bounds check failure %s:%zu, inlined into %s:%zu",
+    JitSpew(JitSpew_IonBailouts, "Bounds check failure %s:%u, inlined into %s:%u",
             innerScript->filename(), innerScript->lineno(),
             outerScript->filename(), outerScript->lineno());
 
     if (!innerScript->failedBoundsCheck())
         innerScript->setFailedBoundsCheck();
 
     InvalidateAfterBailout(cx, outerScript, "bounds check failure");
     if (innerScript->hasIonScript())
         Invalidate(cx, innerScript);
 }
 
 static void
 HandleShapeGuardFailure(JSContext* cx, HandleScript outerScript, HandleScript innerScript)
 {
-    JitSpew(JitSpew_IonBailouts, "Shape guard failure %s:%zu, inlined into %s:%zu",
+    JitSpew(JitSpew_IonBailouts, "Shape guard failure %s:%u, inlined into %s:%u",
             innerScript->filename(), innerScript->lineno(),
             outerScript->filename(), outerScript->lineno());
 
     // TODO: Currently this mimic's Ion's handling of this case.  Investigate setting
     // the flag on innerScript as opposed to outerScript, and maybe invalidating both
     // inner and outer scripts, instead of just the outer one.
     outerScript->setFailedShapeGuard();
 
     InvalidateAfterBailout(cx, outerScript, "shape guard failure");
 }
 
 static void
 HandleBaselineInfoBailout(JSContext* cx, HandleScript outerScript, HandleScript innerScript)
 {
-    JitSpew(JitSpew_IonBailouts, "Baseline info failure %s:%zu, inlined into %s:%zu",
+    JitSpew(JitSpew_IonBailouts, "Baseline info failure %s:%u, inlined into %s:%u",
             innerScript->filename(), innerScript->lineno(),
             outerScript->filename(), outerScript->lineno());
 
     InvalidateAfterBailout(cx, outerScript, "invalid baseline info");
 }
 
 static void
 HandleLexicalCheckFailure(JSContext* cx, HandleScript outerScript, HandleScript innerScript)
 {
-    JitSpew(JitSpew_IonBailouts, "Lexical check failure %s:%zu, inlined into %s:%zu",
+    JitSpew(JitSpew_IonBailouts, "Lexical check failure %s:%u, inlined into %s:%u",
             innerScript->filename(), innerScript->lineno(),
             outerScript->filename(), outerScript->lineno());
 
     if (!innerScript->failedLexicalCheck())
         innerScript->setFailedLexicalCheck();
 
     InvalidateAfterBailout(cx, outerScript, "lexical check failure");
     if (innerScript->hasIonScript())
@@ -1977,17 +1977,17 @@ jit::FinishBailoutToBaseline(BaselineBai
     // If we are catching an exception, we need to unwind scopes.
     // See |SettleOnTryNote|
     if (cx->isExceptionPending() && faultPC) {
         EnvironmentIter ei(cx, topFrame, faultPC);
         UnwindEnvironment(cx, ei, tryPC);
     }
 
     JitSpew(JitSpew_BaselineBailouts,
-            "  Restored outerScript=(%s:%zu,%u) innerScript=(%s:%zu,%u) (bailoutKind=%u)",
+            "  Restored outerScript=(%s:%u,%u) innerScript=(%s:%u,%u) (bailoutKind=%u)",
             outerScript->filename(), outerScript->lineno(), outerScript->getWarmUpCount(),
             innerScript->filename(), innerScript->lineno(), innerScript->getWarmUpCount(),
             (unsigned) bailoutKind);
 
     switch (bailoutKind) {
       // Normal bailouts.
       case Bailout_Inevitable:
       case Bailout_DuringVMCall:
--- a/js/src/jit/BaselineCompiler.cpp
+++ b/js/src/jit/BaselineCompiler.cpp
@@ -81,20 +81,20 @@ BaselineCompiler::addPCMappingEntry(bool
     entry.addIndexEntry = addIndexEntry;
 
     return pcMappingEntries_.append(entry);
 }
 
 MethodStatus
 BaselineCompiler::compile()
 {
-    JitSpew(JitSpew_BaselineScripts, "Baseline compiling script %s:%zu (%p)",
+    JitSpew(JitSpew_BaselineScripts, "Baseline compiling script %s:%u (%p)",
             script->filename(), script->lineno(), script);
 
-    JitSpew(JitSpew_Codegen, "# Emitting baseline code for script %s:%zu",
+    JitSpew(JitSpew_Codegen, "# Emitting baseline code for script %s:%u",
             script->filename(), script->lineno());
 
     TraceLoggerThread* logger = TraceLoggerForCurrentThread(cx);
     TraceLoggerEvent scriptEvent(TraceLogger_AnnotateScripts, script);
     AutoTraceLog logScript(logger, scriptEvent);
     AutoTraceLog logCompile(logger, TraceLogger_BaselineCompilation);
 
     AutoKeepTypeScripts keepTypes(cx);
@@ -217,17 +217,17 @@ BaselineCompiler::compile()
     if (!baselineScript) {
         ReportOutOfMemory(cx);
         return Method_Error;
     }
 
     baselineScript->setMethod(code);
     baselineScript->setTemplateEnvironment(templateEnv);
 
-    JitSpew(JitSpew_BaselineScripts, "Created BaselineScript %p (raw %p) for %s:%zu",
+    JitSpew(JitSpew_BaselineScripts, "Created BaselineScript %p (raw %p) for %s:%u",
             (void*) baselineScript.get(), (void*) code->raw(),
             script->filename(), script->lineno());
 
     MOZ_ASSERT(pcMappingIndexEntries.length() > 0);
     baselineScript->copyPCMappingIndexEntries(&pcMappingIndexEntries[0]);
 
     MOZ_ASSERT(pcEntries.length() > 0);
     baselineScript->copyPCMappingEntries(pcEntries);
@@ -273,17 +273,17 @@ BaselineCompiler::compile()
     baselineScript->copyYieldAndAwaitEntries(script, yieldAndAwaitOffsets_);
 
     if (compileDebugInstrumentation_)
         baselineScript->setHasDebugInstrumentation();
 
     // Always register a native => bytecode mapping entry, since profiler can be
     // turned on with baseline jitcode on stack, and baseline jitcode cannot be invalidated.
     {
-        JitSpew(JitSpew_Profiling, "Added JitcodeGlobalEntry for baseline script %s:%zu (%p)",
+        JitSpew(JitSpew_Profiling, "Added JitcodeGlobalEntry for baseline script %s:%u (%p)",
                     script->filename(), script->lineno(), baselineScript.get());
 
         // Generate profiling string.
         char* str = JitcodeGlobalEntry::createScriptString(cx, script);
         if (!str)
             return Method_Error;
 
         JitcodeGlobalEntry::BaselineEntry entry;
--- a/js/src/jit/BaselineDebugModeOSR.cpp
+++ b/js/src/jit/BaselineDebugModeOSR.cpp
@@ -315,27 +315,27 @@ ICEntryKindToString(ICEntry::Kind kind)
 }
 #endif // JS_JITSPEW
 
 static void
 SpewPatchBaselineFrame(uint8_t* oldReturnAddress, uint8_t* newReturnAddress,
                        JSScript* script, ICEntry::Kind frameKind, jsbytecode* pc)
 {
     JitSpew(JitSpew_BaselineDebugModeOSR,
-            "Patch return %p -> %p on BaselineJS frame (%s:%zu) from %s at %s",
+            "Patch return %p -> %p on BaselineJS frame (%s:%u) from %s at %s",
             oldReturnAddress, newReturnAddress, script->filename(), script->lineno(),
             ICEntryKindToString(frameKind), CodeName[(JSOp)*pc]);
 }
 
 static void
 SpewPatchBaselineFrameFromExceptionHandler(uint8_t* oldReturnAddress, uint8_t* newReturnAddress,
                                            JSScript* script, jsbytecode* pc)
 {
     JitSpew(JitSpew_BaselineDebugModeOSR,
-            "Patch return %p -> %p on BaselineJS frame (%s:%zu) from exception handler at %s",
+            "Patch return %p -> %p on BaselineJS frame (%s:%u) from exception handler at %s",
             oldReturnAddress, newReturnAddress, script->filename(), script->lineno(),
             CodeName[(JSOp)*pc]);
 }
 
 static void
 SpewPatchStubFrame(ICStub* oldStub, ICStub* newStub)
 {
     JitSpew(JitSpew_BaselineDebugModeOSR,
@@ -662,17 +662,17 @@ RecompileBaselineScriptForDebugMode(JSCo
 {
     BaselineScript* oldBaselineScript = script->baselineScript();
 
     // If a script is on the stack multiple times, it may have already
     // been recompiled.
     if (oldBaselineScript->hasDebugInstrumentation() == observing)
         return true;
 
-    JitSpew(JitSpew_BaselineDebugModeOSR, "Recompiling (%s:%zu) for %s",
+    JitSpew(JitSpew_BaselineDebugModeOSR, "Recompiling (%s:%u) for %s",
             script->filename(), script->lineno(), observing ? "DEBUGGING" : "NORMAL EXECUTION");
 
     AutoKeepTypeScripts keepTypes(cx);
     script->setBaselineScript(cx->runtime(), nullptr);
 
     MethodStatus status = BaselineCompile(cx, script, /* forceDebugMode = */ observing);
     if (status != Method_Compiled) {
         // We will only fail to recompile for debug mode due to OOM. Restore
--- a/js/src/jit/BaselineIC.cpp
+++ b/js/src/jit/BaselineIC.cpp
@@ -2100,17 +2100,17 @@ TryAttachCallStub(JSContext* cx, ICCall_
         }
 
         if (nativeWithJitEntry) {
             JitSpew(JitSpew_BaselineIC,
                     "  Generating Call_Scripted stub (native=%p with jit entry, cons=%s, spread=%s)",
                     fun->native(), constructing ? "yes" : "no", isSpread ? "yes" : "no");
         } else {
             JitSpew(JitSpew_BaselineIC,
-                    "  Generating Call_Scripted stub (fun=%p, %s:%zu, cons=%s, spread=%s)",
+                    "  Generating Call_Scripted stub (fun=%p, %s:%u, cons=%s, spread=%s)",
                     fun.get(), fun->nonLazyScript()->filename(), fun->nonLazyScript()->lineno(),
                     constructing ? "yes" : "no", isSpread ? "yes" : "no");
         }
 
         ICCallScriptedCompiler compiler(cx, typeMonitorFallback->firstMonitorStub(),
                                         fun, templateObject,
                                         constructing, isSpread, script->pcToOffset(pc));
         ICStub* newStub = compiler.getStub(compiler.getStubSpace(script));
--- a/js/src/jit/C1Spewer.cpp
+++ b/js/src/jit/C1Spewer.cpp
@@ -22,18 +22,18 @@ using namespace js::jit;
 
 void
 C1Spewer::beginFunction(MIRGraph* graph, JSScript* script)
 {
     this->graph  = graph;
 
     out_.printf("begin_compilation\n");
     if (script) {
-        out_.printf("  name \"%s:%zu\"\n", script->filename(), script->lineno());
-        out_.printf("  method \"%s:%zu\"\n", script->filename(), script->lineno());
+        out_.printf("  name \"%s:%u\"\n", script->filename(), script->lineno());
+        out_.printf("  method \"%s:%u\"\n", script->filename(), script->lineno());
     } else {
         out_.printf("  name \"wasm compilation\"\n");
         out_.printf("  method \"wasm compilation\"\n");
     }
     out_.printf("  date %d\n", (int)time(nullptr));
     out_.printf("end_compilation\n");
 }
 
--- a/js/src/jit/CodeGenerator.cpp
+++ b/js/src/jit/CodeGenerator.cpp
@@ -5352,17 +5352,17 @@ CodeGenerator::maybeCreateScriptCounts()
                 resume = resume->caller();
             offset = script->pcToOffset(resume->pc());
 
             if (block->entryResumePoint()->caller()) {
                 // Get the filename and line number of the inner script.
                 JSScript* innerScript = block->info().script();
                 description = (char*) js_calloc(200);
                 if (description) {
-                    snprintf(description, 200, "%s:%zu",
+                    snprintf(description, 200, "%s:%u",
                              innerScript->filename(), innerScript->lineno());
                 }
             }
         }
 
         if (!counts->block(i).init(block->id(), offset, description, block->numSuccessors()))
             return nullptr;
 
@@ -10140,17 +10140,17 @@ CodeGenerator::generateWasm(wasm::SigIdD
     MOZ_ASSERT(safepoints_.size() == 0);
     MOZ_ASSERT(!scriptCounts_);
     return true;
 }
 
 bool
 CodeGenerator::generate()
 {
-    JitSpew(JitSpew_Codegen, "# Emitting code for script %s:%zu",
+    JitSpew(JitSpew_Codegen, "# Emitting code for script %s:%u",
             gen->info().script()->filename(),
             gen->info().script()->lineno());
 
     // Initialize native code table with an entry to the start of
     // top-level script.
     InlineScriptTree* tree = gen->info().inlineScriptTree();
     jsbytecode* startPC = tree->script()->code();
     BytecodeSite* startSite = new(gen->alloc()) BytecodeSite(tree, startPC);
--- a/js/src/jit/Ion.cpp
+++ b/js/src/jit/Ion.cpp
@@ -2154,17 +2154,17 @@ IonCompile(JSContext* cx, JSScript* scri
 
         return reason;
     }
 
     AssertBasicGraphCoherency(builder->graph());
 
     // If possible, compile the script off thread.
     if (options.offThreadCompilationAvailable()) {
-        JitSpew(JitSpew_IonSyncLogs, "Can't log script %s:%zu"
+        JitSpew(JitSpew_IonSyncLogs, "Can't log script %s:%u"
                 ". (Compiled on background thread.)",
                 builderScript->filename(), builderScript->lineno());
 
         if (!CreateMIRRootList(*builder))
             return AbortReason::Alloc;
 
         AutoLockHelperThreadState lock;
         if (!StartOffThreadIonCompile(builder, lock)) {
@@ -2350,17 +2350,17 @@ Compile(JSContext* cx, HandleScript scri
         return Method_Skipped;
 
     if (script->isDebuggee() || (osrFrame && osrFrame->isDebuggee())) {
         TrackAndSpewIonAbort(cx, script, "debugging");
         return Method_Skipped;
     }
 
     if (!CanIonCompileScript(cx, script)) {
-        JitSpew(JitSpew_IonAbort, "Aborted compilation of %s:%zu", script->filename(), script->lineno());
+        JitSpew(JitSpew_IonAbort, "Aborted compilation of %s:%u", script->filename(), script->lineno());
         return Method_CantCompile;
     }
 
     bool recompile = false;
     OptimizationLevel optimizationLevel = GetOptimizationLevel(script, osrPc);
     if (optimizationLevel == OptimizationLevel::DontCompile)
         return Method_Skipped;
 
@@ -2620,17 +2620,17 @@ jit::IonCompileScriptForBaseline(JSConte
         // TODO: ASSERT that a ion-script-already-exists checker stub doesn't exist.
         // TODO: Clear all optimized stubs.
         // TODO: Add a ion-script-already-exists checker stub.
         return true;
     }
 
     // Ensure that Ion-compiled code is available.
     JitSpew(JitSpew_BaselineOSR,
-            "WarmUpCounter for %s:%zu reached %d at pc %p, trying to switch to Ion!",
+            "WarmUpCounter for %s:%u reached %d at pc %p, trying to switch to Ion!",
             script->filename(), script->lineno(), (int) script->getWarmUpCount(), (void*) pc);
 
     MethodStatus stat;
     if (isLoopEntry) {
         MOZ_ASSERT(LoopEntryCanIonOsr(pc));
         JitSpew(JitSpew_BaselineOSR, "  Compile at loop entry!");
         stat = BaselineCanEnterAtBranch(cx, script, frame, pc);
     } else if (frame->isFunctionFrame()) {
@@ -2724,17 +2724,17 @@ InvalidateActivation(FreeOp* fop, const 
             const char* type = "Unknown";
             if (frame.isIonJS())
                 type = "Optimized";
             else if (frame.isBaselineJS())
                 type = "Baseline";
             else if (frame.isBailoutJS())
                 type = "Bailing";
             JitSpew(JitSpew_IonInvalidate,
-                    "#%zu %s JS frame @ %p, %s:%zu (fun: %p, script: %p, pc %p)",
+                    "#%zu %s JS frame @ %p, %s:%u (fun: %p, script: %p, pc %p)",
                     frameno, type, frame.fp(), frame.script()->maybeForwardedFilename(),
                     frame.script()->lineno(), frame.maybeCallee(), (JSScript*)frame.script(),
                     frame.returnAddressToFp());
             break;
           }
           case JitFrame_BaselineStub:
             JitSpew(JitSpew_IonInvalidate, "#%zu baseline stub frame @ %p", frameno, frame.fp());
             break;
@@ -2882,17 +2882,17 @@ jit::Invalidate(TypeZone& types, FreeOp*
     for (const RecompileInfo& info : invalid) {
         if (cancelOffThread)
             CancelOffThreadIonCompile(info.script());
 
         IonScript* ionScript = info.maybeIonScriptToInvalidate(types);
         if (!ionScript)
             continue;
 
-        JitSpew(JitSpew_IonInvalidate, " Invalidate %s:%zu, IonScript %p",
+        JitSpew(JitSpew_IonInvalidate, " Invalidate %s:%u, IonScript %p",
                 info.script()->filename(), info.script()->lineno(), ionScript);
 
         // Keep the ion script alive during the invalidation and flag this
         // ionScript as being invalidated.  This increment is removed by the
         // loop after the calls to InvalidateActivation.
         ionScript->incrementInvalidationCount();
         numInvalidations++;
     }
@@ -2974,17 +2974,17 @@ jit::Invalidate(JSContext* cx, JSScript*
         //      "<filename>:<lineno>"
 
         // Get the script filename, if any, and its length.
         const char* filename = script->filename();
         if (filename == nullptr)
             filename = "<unknown>";
 
         // Construct the descriptive string.
-        UniqueChars buf = JS_smprintf("Invalidate %s:%zu", filename, script->lineno());
+        UniqueChars buf = JS_smprintf("Invalidate %s:%u", filename, script->lineno());
 
         // Ignore the event on allocation failure.
         if (buf) {
             cx->runtime()->geckoProfiler().markEvent(buf.get());
         }
     }
 
     // RecompileInfoVector has inline space for at least one element.
@@ -3010,17 +3010,17 @@ jit::FinishInvalidation(FreeOp* fop, JSS
     // true. In this case we have to wait until destroying it.
     if (!ion->invalidated())
         jit::IonScript::Destroy(fop, ion);
 }
 
 void
 jit::ForbidCompilation(JSContext* cx, JSScript* script)
 {
-    JitSpew(JitSpew_IonAbort, "Disabling Ion compilation of script %s:%zu",
+    JitSpew(JitSpew_IonAbort, "Disabling Ion compilation of script %s:%u",
             script->filename(), script->lineno());
 
     CancelOffThreadIonCompile(script);
 
     if (script->hasIonScript())
         Invalidate(cx, script, false);
 
     script->setIonScript(cx->runtime(), ION_DISABLED_SCRIPT);
--- a/js/src/jit/IonBuilder.cpp
+++ b/js/src/jit/IonBuilder.cpp
@@ -320,17 +320,17 @@ IonBuilder::getPolyCallTargets(Temporary
 
     return Ok();
 }
 
 IonBuilder::InliningDecision
 IonBuilder::DontInline(JSScript* targetScript, const char* reason)
 {
     if (targetScript) {
-        JitSpew(JitSpew_Inlining, "Cannot inline %s:%zu: %s",
+        JitSpew(JitSpew_Inlining, "Cannot inline %s:%u: %s",
                 targetScript->filename(), targetScript->lineno(), reason);
     } else {
         JitSpew(JitSpew_Inlining, "Cannot inline: %s", reason);
     }
 
     return InliningDecision_DontInline;
 }
 
@@ -746,21 +746,21 @@ IonBuilder::build()
         script()->baselineScript()->resetMaxInliningDepth();
 
     MBasicBlock* entry;
     MOZ_TRY_VAR(entry, newBlock(info().firstStackSlot(), pc));
     MOZ_TRY(setCurrentAndSpecializePhis(entry));
 
 #ifdef JS_JITSPEW
     if (info().isAnalysis()) {
-        JitSpew(JitSpew_IonScripts, "Analyzing script %s:%zu (%p) %s",
+        JitSpew(JitSpew_IonScripts, "Analyzing script %s:%u (%p) %s",
                 script()->filename(), script()->lineno(), (void*)script(),
                 AnalysisModeString(info().analysisMode()));
     } else {
-        JitSpew(JitSpew_IonScripts, "%sompiling script %s:%zu (%p) (warmup-counter=%" PRIu32 ", level=%s)",
+        JitSpew(JitSpew_IonScripts, "%sompiling script %s:%u (%p) (warmup-counter=%" PRIu32 ", level=%s)",
                 (script()->hasIonScript() ? "Rec" : "C"),
                 script()->filename(), script()->lineno(), (void*)script(),
                 script()->getWarmUpCount(), OptimizationLevelString(optimizationInfo().level()));
     }
 #endif
 
     MOZ_TRY(initParameters());
     initLocals();
@@ -920,17 +920,17 @@ IonBuilder::processIterators()
 AbortReasonOr<Ok>
 IonBuilder::buildInline(IonBuilder* callerBuilder, MResumePoint* callerResumePoint,
                         CallInfo& callInfo)
 {
     inlineCallInfo_ = &callInfo;
 
     MOZ_TRY(init());
 
-    JitSpew(JitSpew_IonScripts, "Inlining script %s:%zu (%p)",
+    JitSpew(JitSpew_IonScripts, "Inlining script %s:%u (%p)",
             script()->filename(), script()->lineno(), (void*)script());
 
     callerBuilder_ = callerBuilder;
     callerResumePoint_ = callerResumePoint;
 
     if (callerBuilder->failedBoundsCheck_)
         failedBoundsCheck_ = true;
 
@@ -1209,17 +1209,17 @@ IonBuilder::initEnvironmentChain(MDefini
     // See: |InitFromBailout|
     current->setEnvironmentChain(env);
     return Ok();
 }
 
 void
 IonBuilder::initArgumentsObject()
 {
-    JitSpew(JitSpew_IonMIR, "%s:%zu - Emitting code to initialize arguments object! block=%p",
+    JitSpew(JitSpew_IonMIR, "%s:%u - Emitting code to initialize arguments object! block=%p",
             script()->filename(), script()->lineno(), current);
     MOZ_ASSERT(info().needsArgsObj());
 
     bool mapped = script()->hasMappedArgsObj();
     ArgumentsObject* templateObj = script()->realm()->maybeArgumentsTemplateObject(mapped);
 
     MCreateArgumentsObject* argsObj =
         MCreateArgumentsObject::New(alloc(), current->environmentChain(), templateObj);
@@ -1421,17 +1421,17 @@ GetOrCreateControlFlowGraph(TempAllocato
         return CFGState::Alloc;
 
     if (script->hasBaselineScript()) {
         MOZ_ASSERT(!script->baselineScript()->controlFlowGraph());
         script->baselineScript()->setControlFlowGraph(cfg);
     }
 
     if (JitSpewEnabled(JitSpew_CFG)) {
-        JitSpew(JitSpew_CFG, "Generating graph for %s:%zu",
+        JitSpew(JitSpew_CFG, "Generating graph for %s:%u",
                              script->filename(), script->lineno());
         Fprinter& print = JitSpewPrinter();
         cfg->dump(print, script);
     }
 
     *cfgOut = cfg;
     return CFGState::Success;
 }
@@ -4023,17 +4023,17 @@ IonBuilder::makeInliningDecision(JSObjec
     // Callee must have been called a few times to have somewhat stable
     // type information, except for definite properties analysis,
     // as the caller has not run yet.
     if (targetScript->getWarmUpCount() < optimizationInfo().inliningWarmUpThreshold() &&
         !targetScript->baselineScript()->ionCompiledOrInlined() &&
         info().analysisMode() != Analysis_DefiniteProperties)
     {
         trackOptimizationOutcome(TrackedOutcome::CantInlineNotHot);
-        JitSpew(JitSpew_Inlining, "Cannot inline %s:%zu: callee is insufficiently hot.",
+        JitSpew(JitSpew_Inlining, "Cannot inline %s:%u: callee is insufficiently hot.",
                 targetScript->filename(), targetScript->lineno());
         return InliningDecision_WarmUpCountTooLow;
     }
 
     // Don't inline if the callee is known to inline a lot of code, to avoid
     // huge MIR graphs.
     uint32_t inlinedBytecodeLength = targetScript->baselineScript()->inlinedBytecodeLength();
     if (inlinedBytecodeLength > optimizationInfo().inlineMaxCalleeInlinedBytecodeLength()) {
--- a/js/src/jit/IonIC.cpp
+++ b/js/src/jit/IonIC.cpp
@@ -153,17 +153,17 @@ IonGetPropertyIC::update(JSContext* cx, 
 
     if (!attached && ic->idempotent()) {
         // Invalidate the cache if the property was not found, or was found on
         // a non-native object. This ensures:
         // 1) The property read has no observable side-effects.
         // 2) There's no need to dynamically monitor the return type. This would
         //    be complicated since (due to GVN) there can be multiple pc's
         //    associated with a single idempotent cache.
-        JitSpew(JitSpew_IonIC, "Invalidating from idempotent cache %s:%zu",
+        JitSpew(JitSpew_IonIC, "Invalidating from idempotent cache %s:%u",
                 outerScript->filename(), outerScript->lineno());
 
         outerScript->setInvalidatedIdempotentCache();
 
         // Do not re-invalidate if the lookup already caused invalidation.
         if (outerScript->hasIonScript())
             Invalidate(cx, outerScript);
 
--- a/js/src/jit/JSJitFrameIter.cpp
+++ b/js/src/jit/JSJitFrameIter.cpp
@@ -309,17 +309,17 @@ JSJitFrameIter::dumpBaseline() const
         DumpObject(callee());
 #else
         fprintf(stderr, "?\n");
 #endif
     } else {
         fprintf(stderr, "  global frame, no callee\n");
     }
 
-    fprintf(stderr, "  file %s line %zu\n",
+    fprintf(stderr, "  file %s line %u\n",
             script()->filename(), script()->lineno());
 
     JSContext* cx = TlsContext.get();
     RootedScript script(cx);
     jsbytecode* pc;
     baselineScriptAndPc(script.address(), &pc);
 
     fprintf(stderr, "  script = %p, pc = %p (offset %u)\n", (void*)script, pc, uint32_t(script->pcToOffset(pc)));
@@ -426,30 +426,30 @@ JSJitFrameIter::verifyReturnAddressUsing
     uint32_t depth = UINT32_MAX;
     if (!entry->callStackAtAddr(rt, returnAddressToFp_, location, &depth))
         return false;
     MOZ_ASSERT(depth > 0 && depth != UINT32_MAX);
     MOZ_ASSERT(location.length() == depth);
 
     JitSpew(JitSpew_Profiling, "Found bytecode location of depth %d:", depth);
     for (size_t i = 0; i < location.length(); i++) {
-        JitSpew(JitSpew_Profiling, "   %s:%zu - %zu",
+        JitSpew(JitSpew_Profiling, "   %s:%u - %zu",
                 location[i].script->filename(), location[i].script->lineno(),
                 size_t(location[i].pc - location[i].script->code()));
     }
 
     if (type_ == JitFrame_IonJS) {
         // Create an InlineFrameIterator here and verify the mapped info against the iterator info.
         InlineFrameIterator inlineFrames(TlsContext.get(), this);
         for (size_t idx = 0; idx < location.length(); idx++) {
             MOZ_ASSERT(idx < location.length());
             MOZ_ASSERT_IF(idx < location.length() - 1, inlineFrames.more());
 
             JitSpew(JitSpew_Profiling,
-                    "Match %d: ION %s:%zu(%zu) vs N2B %s:%zu(%zu)",
+                    "Match %d: ION %s:%u(%zu) vs N2B %s:%u(%zu)",
                     (int)idx,
                     inlineFrames.script()->filename(),
                     inlineFrames.script()->lineno(),
                     size_t(inlineFrames.pc() - inlineFrames.script()->code()),
                     location[idx].script->filename(),
                     location[idx].script->lineno(),
                     size_t(location[idx].pc - location[idx].script->code()));
 
--- a/js/src/jit/JSONSpewer.cpp
+++ b/js/src/jit/JSONSpewer.cpp
@@ -20,17 +20,17 @@
 using namespace js;
 using namespace js::jit;
 
 void
 JSONSpewer::beginFunction(JSScript* script)
 {
     beginObject();
     if (script)
-        formatProperty("name", "%s:%zu", script->filename(), script->lineno());
+        formatProperty("name", "%s:%u", script->filename(), script->lineno());
     else
         property("name", "wasm compilation");
     beginListProperty("passes");
 }
 
 void
 JSONSpewer::beginPass(const char* pass)
 {
--- a/js/src/jit/JitFrames.cpp
+++ b/js/src/jit/JitFrames.cpp
@@ -2349,17 +2349,17 @@ InlineFrameIterator::dump() const
         DumpObject(callee(fallback));
 #else
         fprintf(stderr, "?\n");
 #endif
     } else {
         fprintf(stderr, "  global frame, no callee\n");
     }
 
-    fprintf(stderr, "  file %s line %zu\n",
+    fprintf(stderr, "  file %s line %u\n",
             script()->filename(), script()->lineno());
 
     fprintf(stderr, "  script = %p, pc = %p\n", (void*) script(), pc());
     fprintf(stderr, "  current op: %s\n", CodeName[*pc()]);
 
     if (!more()) {
         numActualArgs();
     }
--- a/js/src/jit/JitcodeMap.cpp
+++ b/js/src/jit/JitcodeMap.cpp
@@ -323,17 +323,17 @@ JitcodeGlobalEntry::createScriptString(J
     const char* filenameStr = script->filename() ? script->filename() : "(null)";
     size_t filenameLength = strlen(filenameStr);
 
     // Calculate lineno length
     bool hasLineno = false;
     size_t linenoLength = 0;
     char linenoStr[15];
     if (hasName || (script->functionNonDelazifying() || script->isForEval())) {
-        linenoLength = SprintfLiteral(linenoStr, "%zu", script->lineno());
+        linenoLength = SprintfLiteral(linenoStr, "%u", script->lineno());
         hasLineno = true;
     }
 
     // Full profile string for scripts with functions is:
     //      FuncName (FileName:Lineno)
     // Full profile string for scripts without functions is:
     //      FileName:Lineno
     // Full profile string for scripts without functions and without linenos is:
@@ -1542,23 +1542,23 @@ JitcodeIonTable::WriteIonTable(CompactBu
                                const CodeGeneratorShared::NativeToBytecode* end,
                                uint32_t* tableOffsetOut, uint32_t* numRegionsOut)
 {
     MOZ_ASSERT(tableOffsetOut != nullptr);
     MOZ_ASSERT(numRegionsOut != nullptr);
     MOZ_ASSERT(writer.length() == 0);
     MOZ_ASSERT(scriptListSize > 0);
 
-    JitSpew(JitSpew_Profiling, "Writing native to bytecode map for %s:%zu (%zu entries)",
+    JitSpew(JitSpew_Profiling, "Writing native to bytecode map for %s:%u (%zu entries)",
             scriptList[0]->filename(), scriptList[0]->lineno(),
             mozilla::PointerRangeSize(start, end));
 
     JitSpew(JitSpew_Profiling, "  ScriptList of size %d", int(scriptListSize));
     for (uint32_t i = 0; i < scriptListSize; i++) {
-        JitSpew(JitSpew_Profiling, "  Script %d - %s:%zu",
+        JitSpew(JitSpew_Profiling, "  Script %d - %s:%u",
                 int(i), scriptList[i]->filename(), scriptList[i]->lineno());
     }
 
     // Write out runs first.  Keep a vector tracking the positive offsets from payload
     // start to the run.
     const CodeGeneratorShared::NativeToBytecode* curEntry = start;
     js::Vector<uint32_t, 32, SystemAllocPolicy> runOffsets;
 
--- a/js/src/jit/MIR.cpp
+++ b/js/src/jit/MIR.cpp
@@ -1161,17 +1161,17 @@ MConstant::printOpcode(GenericPrinter& o
             if (fun->displayAtom()) {
                 out.put("function ");
                 EscapedStringPrinter(out, fun->displayAtom(), 0);
             } else {
                 out.put("unnamed function");
             }
             if (fun->hasScript()) {
                 JSScript* script = fun->nonLazyScript();
-                out.printf(" (%s:%zu)",
+                out.printf(" (%s:%u)",
                         script->filename() ? script->filename() : "", script->lineno());
             }
             out.printf(" at %p", (void*) fun);
             break;
         }
         out.printf("object %p (%s)", (void*)&toObject(), toObject().getClass()->name);
         break;
       case MIRType::Symbol:
--- a/js/src/jit/RematerializedFrame.cpp
+++ b/js/src/jit/RematerializedFrame.cpp
@@ -167,17 +167,17 @@ RematerializedFrame::dump()
         DumpValue(ObjectValue(*callee()));
 #else
         fprintf(stderr, "?\n");
 #endif
     } else {
         fprintf(stderr, "  global frame, no callee\n");
     }
 
-    fprintf(stderr, "  file %s line %zu offset %zu\n",
+    fprintf(stderr, "  file %s line %u offset %zu\n",
             script()->filename(), script()->lineno(),
             script()->pcToOffset(pc()));
 
     fprintf(stderr, "  script = %p\n", (void*) script());
 
     if (isFunctionFrame()) {
         fprintf(stderr, "  env chain: ");
 #ifdef DEBUG
--- a/js/src/jit/SharedIC.cpp
+++ b/js/src/jit/SharedIC.cpp
@@ -46,17 +46,17 @@ FallbackICSpew(JSContext* cx, ICFallback
 
         char fmtbuf[100];
         va_list args;
         va_start(args, fmt);
         (void) VsprintfLiteral(fmtbuf, fmt, args);
         va_end(args);
 
         JitSpew(JitSpew_BaselineICFallback,
-                "Fallback hit for (%s:%zu) (pc=%zu,line=%d,uses=%d,stubs=%zu): %s",
+                "Fallback hit for (%s:%u) (pc=%zu,line=%d,uses=%d,stubs=%zu): %s",
                 script->filename(),
                 script->lineno(),
                 script->pcToOffset(pc),
                 PCToLineNumber(script, pc),
                 script->getWarmUpCount(),
                 stub->numOptimizedStubs(),
                 fmtbuf);
     }
@@ -71,17 +71,17 @@ TypeFallbackICSpew(JSContext* cx, ICType
 
         char fmtbuf[100];
         va_list args;
         va_start(args, fmt);
         (void) VsprintfLiteral(fmtbuf, fmt, args);
         va_end(args);
 
         JitSpew(JitSpew_BaselineICFallback,
-                "Type monitor fallback hit for (%s:%zu) (pc=%zu,line=%d,uses=%d,stubs=%d): %s",
+                "Type monitor fallback hit for (%s:%u) (pc=%zu,line=%d,uses=%d,stubs=%d): %s",
                 script->filename(),
                 script->lineno(),
                 script->pcToOffset(pc),
                 PCToLineNumber(script, pc),
                 script->getWarmUpCount(),
                 (int) stub->numOptimizedMonitorStubs(),
                 fmtbuf);
     }
--- a/js/src/jit/shared/CodeGenerator-shared.cpp
+++ b/js/src/jit/shared/CodeGenerator-shared.cpp
@@ -279,17 +279,17 @@ CodeGeneratorShared::addNativeToBytecode
     return true;
 }
 
 void
 CodeGeneratorShared::dumpNativeToBytecodeEntries()
 {
 #ifdef JS_JITSPEW
     InlineScriptTree* topTree = gen->info().inlineScriptTree();
-    JitSpewStart(JitSpew_Profiling, "Native To Bytecode Entries for %s:%zu\n",
+    JitSpewStart(JitSpew_Profiling, "Native To Bytecode Entries for %s:%u\n",
                  topTree->script()->filename(), topTree->script()->lineno());
     for (unsigned i = 0; i < nativeToBytecodeList_.length(); i++)
         dumpNativeToBytecodeEntry(i);
 #endif
 }
 
 void
 CodeGeneratorShared::dumpNativeToBytecodeEntry(uint32_t idx)
@@ -302,26 +302,26 @@ CodeGeneratorShared::dumpNativeToBytecod
     unsigned nativeDelta = 0;
     unsigned pcDelta = 0;
     if (idx + 1 < nativeToBytecodeList_.length()) {
         NativeToBytecode* nextRef = &ref + 1;
         nativeDelta = nextRef->nativeOffset.offset() - nativeOffset;
         if (nextRef->tree == ref.tree)
             pcDelta = nextRef->pc - ref.pc;
     }
-    JitSpewStart(JitSpew_Profiling, "    %08zx [+%-6d] => %-6ld [%-4d] {%-10s} (%s:%zu",
+    JitSpewStart(JitSpew_Profiling, "    %08zx [+%-6d] => %-6ld [%-4d] {%-10s} (%s:%u",
                  ref.nativeOffset.offset(),
                  nativeDelta,
                  (long) (ref.pc - script->code()),
                  pcDelta,
                  CodeName[JSOp(*ref.pc)],
                  script->filename(), script->lineno());
 
     for (tree = tree->caller(); tree; tree = tree->caller()) {
-        JitSpewCont(JitSpew_Profiling, " <= %s:%zu", tree->script()->filename(),
+        JitSpewCont(JitSpew_Profiling, " <= %s:%u", tree->script()->filename(),
                                                     tree->script()->lineno());
     }
     JitSpewCont(JitSpew_Profiling, ")");
     JitSpewFin(JitSpew_Profiling);
 #endif
 }
 
 bool
--- a/js/src/shell/js.cpp
+++ b/js/src/shell/js.cpp
@@ -6172,17 +6172,17 @@ ReflectTrackedOptimizations(JSContext* c
             // Use endOffset, as startOffset may be associated with a
             // previous, adjacent region ending exactly at startOffset. That
             // is, suppose we have two regions [0, startOffset], [startOffset,
             // endOffset]. Since we are not querying a return address, we want
             // the second region and not the first.
             uint8_t* addr = ion->method()->raw() + endOffset;
             entry.youngestFrameLocationAtAddr(rt, addr, &script, &pc);
 
-            if (!sp.jsprintf("{\"location\":\"%s:%zu\",\"offset\":%zu,\"index\":%u}%s",
+            if (!sp.jsprintf("{\"location\":\"%s:%u\",\"offset\":%zu,\"index\":%u}%s",
                              script->filename(), script->lineno(), script->pcToOffset(pc), index,
                              iter.more() ? "," : ""))
             {
                 return false;
             }
         }
     }
 
--- a/js/src/vm/BytecodeUtil.cpp
+++ b/js/src/vm/BytecodeUtil.cpp
@@ -204,21 +204,21 @@ js::DumpCompartmentPCCounts(JSContext* c
     }
 
     for (uint32_t i = 0; i < scripts.length(); i++) {
         HandleScript script = scripts[i];
         Sprinter sprinter(cx);
         if (!sprinter.init())
             return false;
 
-        fprintf(stdout, "--- SCRIPT %s:%zu ---\n", script->filename(), script->lineno());
+        fprintf(stdout, "--- SCRIPT %s:%u ---\n", script->filename(), script->lineno());
         if (!DumpPCCounts(cx, script, &sprinter))
             return false;
         fputs(sprinter.string(), stdout);
-        fprintf(stdout, "--- END SCRIPT %s:%zu ---\n", script->filename(), script->lineno());
+        fprintf(stdout, "--- END SCRIPT %s:%u ---\n", script->filename(), script->lineno());
     }
 
     return true;
 }
 
 /////////////////////////////////////////////////////////////////////
 // Bytecode Parser
 /////////////////////////////////////////////////////////////////////
--- a/js/src/vm/CodeCoverage.cpp
+++ b/js/src/vm/CodeCoverage.cpp
@@ -145,17 +145,17 @@ LCovSource::writeScriptName(LSprinter& o
 
 bool
 LCovSource::writeScript(JSScript* script)
 {
     if (!linesHit_.initialized() && !linesHit_.init())
         return false;
 
     numFunctionsFound_++;
-    outFN_.printf("FN:%zu,", script->lineno());
+    outFN_.printf("FN:%u,", script->lineno());
     if (!writeScriptName(outFN_, script))
         return false;
     outFN_.put("\n", 1);
 
     uint64_t hits = 0;
     ScriptCounts* sc = nullptr;
     if (script->hasScriptCounts()) {
         sc = &script->getScriptCounts();
--- a/js/src/vm/Debugger.cpp
+++ b/js/src/vm/Debugger.cpp
@@ -370,17 +370,17 @@ class MOZ_RAII js::EnterDebuggeeNoExecut
                 AutoRealm ar(cx, nx->debugger().toJSObject());
                 nx->reported_ = true;
                 if (cx->options().dumpStackOnDebuggeeWouldRun()) {
                     fprintf(stdout, "Dumping stack for DebuggeeWouldRun:\n");
                     DumpBacktrace(cx);
                 }
                 const char* filename = script->filename() ? script->filename() : "(none)";
                 char linenoStr[15];
-                SprintfLiteral(linenoStr, "%zu", script->lineno());
+                SprintfLiteral(linenoStr, "%u", script->lineno());
                 unsigned flags = warning ? JSREPORT_WARNING : JSREPORT_ERROR;
                 // FIXME: filename should be UTF-8 (bug 987069).
                 return JS_ReportErrorFlagsAndNumberLatin1(cx, flags, GetErrorMessage, nullptr,
                                                           JSMSG_DEBUGGEE_WOULD_RUN,
                                                           filename, linenoStr);
             }
         }
         return true;
@@ -5411,17 +5411,17 @@ DebuggerScript_getUrl(JSContext* cx, uns
     return true;
 }
 
 struct DebuggerScriptGetStartLineMatcher
 {
     using ReturnType = uint32_t;
 
     ReturnType match(HandleScript script) {
-        return uint32_t(script->lineno());
+        return script->lineno();
     }
     ReturnType match(Handle<WasmInstanceObject*> wasmInstance) {
         return 1;
     }
 };
 
 static bool
 DebuggerScript_getStartLine(JSContext* cx, unsigned argc, Value* vp)
--- a/js/src/vm/EnvironmentObject.cpp
+++ b/js/src/vm/EnvironmentObject.cpp
@@ -3707,24 +3707,24 @@ AnalyzeEntrainedVariablesInScript(JSCont
 
         buf.printf("Script ");
 
         if (JSAtom* name = script->functionNonDelazifying()->displayAtom()) {
             buf.putString(name);
             buf.printf(" ");
         }
 
-        buf.printf("(%s:%zu) has variables entrained by ", script->filename(), script->lineno());
+        buf.printf("(%s:%u) has variables entrained by ", script->filename(), script->lineno());
 
         if (JSAtom* name = innerScript->functionNonDelazifying()->displayAtom()) {
             buf.putString(name);
             buf.printf(" ");
         }
 
-        buf.printf("(%s:%zu) ::", innerScript->filename(), innerScript->lineno());
+        buf.printf("(%s:%u) ::", innerScript->filename(), innerScript->lineno());
 
         for (PropertyNameSet::Range r = remainingNames.all(); !r.empty(); r.popFront()) {
             buf.printf(" ");
             buf.putString(r.front());
         }
 
         printf("%s\n", buf.string());
     }
--- a/js/src/vm/JSObject.cpp
+++ b/js/src/vm/JSObject.cpp
@@ -3432,17 +3432,17 @@ dumpValue(const Value& v, js::GenericPri
         if (fun->displayAtom()) {
             out.put("<function ");
             EscapedStringPrinter(out, fun->displayAtom(), 0);
         } else {
             out.put("<unnamed function");
         }
         if (fun->hasScript()) {
             JSScript* script = fun->nonLazyScript();
-            out.printf(" (%s:%zu)",
+            out.printf(" (%s:%u)",
                     script->filename() ? script->filename() : "", script->lineno());
         }
         out.printf(" at %p>", (void*) fun);
     } else if (v.isObject()) {
         JSObject* obj = &v.toObject();
         const Class* clasp = obj->getClass();
         out.printf("<%s%s at %p>",
                 clasp->name,
@@ -3712,17 +3712,17 @@ js::DumpInterpreterFrame(JSContext* cx, 
             JSObject* fun = i.callee(cx);
             v.setObject(*fun);
             dumpValue(v, out);
         } else {
             out.put("global or eval frame, no callee");
         }
         out.putChar('\n');
 
-        out.printf("file %s line %zu\n",
+        out.printf("file %s line %u\n",
                 i.script()->filename(), i.script()->lineno());
 
         if (jsbytecode* pc = i.pc()) {
             out.printf("  pc = %p\n", pc);
             out.printf("  current op: %s\n", CodeName[*pc]);
             MaybeDumpScope(i.script()->lookupScope(pc), out);
         }
         if (i.isFunctionFrame())
--- a/js/src/vm/JSScript.h
+++ b/js/src/vm/JSScript.h
@@ -1290,21 +1290,21 @@ class JSScript : public js::gc::TenuredC
         MOZ_ASSERT(offset < length());
         return code() + offset;
     }
 
     size_t mainOffset() const {
         return mainOffset_;
     }
 
-    size_t lineno() const {
+    uint32_t lineno() const {
         return lineno_;
     }
 
-    size_t column() const {
+    uint32_t column() const {
         return column_;
     }
 
     void setColumn(size_t column) { column_ = column; }
 
     // The fixed part of a stack frame is comprised of vars (in function and
     // module code) and block-scoped locals (in all kinds of code).
     size_t nfixed() const {
--- a/js/src/vm/TypeInference.cpp
+++ b/js/src/vm/TypeInference.cpp
@@ -2569,17 +2569,17 @@ TypeZone::processPendingRecompiles(FreeO
     jit::Invalidate(*this, fop, pending);
 
     MOZ_ASSERT(recompiles.empty());
 }
 
 void
 TypeZone::addPendingRecompile(JSContext* cx, const RecompileInfo& info)
 {
-    InferSpew(ISpewOps, "addPendingRecompile: %p:%s:%zu",
+    InferSpew(ISpewOps, "addPendingRecompile: %p:%s:%u",
               info.script(), info.script()->filename(), info.script()->lineno());
 
     AutoEnterOOMUnsafeRegion oomUnsafe;
     if (!cx->zone()->types.activeAnalysis->pendingRecompiles.append(info))
         oomUnsafe.crash("Could not update pendingRecompiles");
 }
 
 void
@@ -4695,17 +4695,17 @@ TypeScript::printTypes(JSContext* cx, Ha
     Fprinter out(stderr);
 
     if (script->functionNonDelazifying())
         fprintf(stderr, "Function");
     else if (script->isForEval())
         fprintf(stderr, "Eval");
     else
         fprintf(stderr, "Main");
-    fprintf(stderr, " %#" PRIxPTR " %s:%zu ",
+    fprintf(stderr, " %#" PRIxPTR " %s:%u ",
             uintptr_t(script.get()), script->filename(), script->lineno());
 
     if (script->functionNonDelazifying()) {
         if (JSAtom* name = script->functionNonDelazifying()->explicitName())
             name->dumpCharsNoNewline(out);
     }
 
     fprintf(stderr, "\n    this:");
--- a/js/src/vtune/VTuneWrapper.cpp
+++ b/js/src/vtune/VTuneWrapper.cpp
@@ -128,17 +128,17 @@ MarkScript(const js::jit::JitCode* code,
     method.method_id = script->vtuneMethodID();
     method.method_load_address = code->raw();
     method.method_size = code->instructionsSize();
     method.module_name = const_cast<char*>(module);
 
     // Line numbers begin at 1, but columns begin at 0.
     // Text editors start at 1,1 so fixup is performed to match.
     char namebuf[512];
-    SprintfLiteral(namebuf, "%s:%zu:%zu",
+    SprintfLiteral(namebuf, "%s:%u:%u",
                    script->filename(), script->lineno(), script->column() + 1);
 
     method.method_name = &namebuf[0];
 
     int ok = SafeNotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED_V2, (void*)&method);
     if (ok != 1)
         printf("[!] VTune Integration: Failed to load method.\n");
 }