--- a/js/src/ion/AliasAnalysis.cpp
+++ b/js/src/ion/AliasAnalysis.cpp
@@ -16,17 +16,17 @@
 
 using namespace js;
 using namespace js::ion;
 
 // Iterates over the flags in an AliasSet.
 class AliasSetIterator
 {
   private:
-    uint32 flags;
+    uint32_t flags;
     unsigned pos;
 
   public:
     AliasSetIterator(AliasSet set)
       : flags(set.flags()), pos(0)
     {
         while (flags && (flags & 1) == 0) {
             flags >>= 1;
@@ -79,17 +79,17 @@ AliasAnalysis::analyze()
     for (unsigned i=0; i < NUM_ALIAS_SETS; i++) {
         if (!stores.append(firstIns))
             return false;
     }
 
     // Type analysis may have inserted new instructions. Since this pass depends
     // on the instruction number ordering, all instructions are renumbered.
     // We start with 1 because some passes use 0 to denote failure.
-    uint32 newId = 1;
+    uint32_t newId = 1;
 
     for (ReversePostorderIterator block(graph_.rpoBegin()); block != graph_.rpoEnd(); block++) {
         if (mir->shouldCancel("Alias Analysis (main loop)"))
             return false;
 
         if (block->isLoopHeader()) {
             IonSpew(IonSpew_Alias, "Processing loop header %d", block->id());
             loop_ = new LoopAliasInfo(loop_, *block);

--- a/js/src/ion/Bailouts.cpp
+++ b/js/src/ion/Bailouts.cpp
@@ -94,17 +94,17 @@ GetBailedJSScript(JSContext *cx)
         return NULL;
     }
 }
 
 void
 StackFrame::initFromBailout(JSContext *cx, SnapshotIterator &iter)
 {
     AutoAssertNoGC nogc;
-    uint32 exprStackSlots = iter.slots() - script()->nfixed;
+    uint32_t exprStackSlots = iter.slots() - script()->nfixed;
 
 #ifdef TRACK_SNAPSHOTS
     iter.spewBailingFrom();
 #endif
     IonSpew(IonSpew_Bailouts, " expr stack slots %u, is function frame %u",
             exprStackSlots, isFunctionFrame());
 
     if (iter.bailoutKind() == Bailout_ArgumentCheck) {
@@ -139,31 +139,31 @@ StackFrame::initFromBailout(JSContext *c
         // constructor running.
         if (isConstructing())
             JS_ASSERT(!thisv.isPrimitive());
 
         JS_ASSERT(iter.slots() >= CountArgSlots(fun()));
         IonSpew(IonSpew_Bailouts, " frame slots %u, nargs %u, nfixed %u",
                 iter.slots(), fun()->nargs, script()->nfixed);
 
-        for (uint32 i = 0; i < fun()->nargs; i++) {
+        for (uint32_t i = 0; i < fun()->nargs; i++) {
             Value arg = iter.read();
             formals()[i] = arg;
         }
     }
     exprStackSlots -= CountArgSlots(maybeFun());
 
-    for (uint32 i = 0; i < script()->nfixed; i++) {
+    for (uint32_t i = 0; i < script()->nfixed; i++) {
         Value slot = iter.read();
         slots()[i] = slot;
     }
 
     IonSpew(IonSpew_Bailouts, " pushing %u expression stack slots", exprStackSlots);
     FrameRegs &regs = cx->regs();
-    for (uint32 i = 0; i < exprStackSlots; i++) {
+    for (uint32_t i = 0; i < exprStackSlots; i++) {
         Value v;
 
         // If coming from an invalidation bailout, and this is the topmost
         // value, and a value override has been specified, don't read from the
         // iterator. Otherwise, we risk using a garbage value.
         if (!iter.moreFrames() && i == exprStackSlots - 1 && cx->runtime->hasIonReturnOverride())
             v = iter.skip();
         else
@@ -215,17 +215,17 @@ PushInlinedFrame(JSContext *cx, StackFra
     JS_ASSERT(fp == regs.fp());
     JS_ASSERT(fp->prev() == callerFrame);
 
     fp->formals()[-2].setObject(*fun);
 
     return fp;
 }
 
-static uint32
+static uint32_t
 ConvertFrames(JSContext *cx, IonActivation *activation, IonBailoutIterator &it)
 {
     AssertCanGC();
     IonSpew(IonSpew_Bailouts, "Bailing out %s:%u, IonScript %p",
             it.script()->filename, it.script()->lineno, (void *) it.ionScript());
     IonSpew(IonSpew_Bailouts, " reading from snapshot offset %u size %u",
             it.snapshotOffset(), it.ionScript()->snapshotsSize());
 #ifdef DEBUG
@@ -349,40 +349,40 @@ EnsureExitFrame(IonCommonFrameLayout *fr
         frame->changePrevType(IonFrame_Bailed_Rectifier);
         return;
     }
 
     JS_ASSERT(frame->prevType() == IonFrame_OptimizedJS);
     frame->changePrevType(IonFrame_Bailed_JS);
 }
 
-uint32
+uint32_t
 ion::Bailout(BailoutStack *sp)
 {
     AssertCanGC();
     JSContext *cx = GetIonContext()->cx;
     // We don't have an exit frame.
     cx->runtime->ionTop = NULL;
     IonActivationIterator ionActivations(cx);
     IonBailoutIterator iter(ionActivations, sp);
     IonActivation *activation = ionActivations.activation();
 
     // IonCompartment *ioncompartment = cx->compartment->ionCompartment();
     // IonActivation *activation = cx->runtime->ionActivation;
     // FrameRecovery in = FrameRecoveryFromBailout(ioncompartment, sp);
 
     IonSpew(IonSpew_Bailouts, "Took bailout! Snapshot offset: %d", iter.snapshotOffset());
 
-    uint32 retval = ConvertFrames(cx, activation, iter);
+    uint32_t retval = ConvertFrames(cx, activation, iter);
 
     EnsureExitFrame(iter.jsFrame());
     return retval;
 }
 
-uint32
+uint32_t
 ion::InvalidationBailout(InvalidationBailoutStack *sp, size_t *frameSizeOut)
 {
     AssertCanGC();
     sp->checkInvariants();
 
     JSContext *cx = GetIonContext()->cx;
 
     // We don't have an exit frame.
@@ -391,17 +391,17 @@ ion::InvalidationBailout(InvalidationBai
     IonBailoutIterator iter(ionActivations, sp);
     IonActivation *activation = ionActivations.activation();
 
     IonSpew(IonSpew_Bailouts, "Took invalidation bailout! Snapshot offset: %d", iter.snapshotOffset());
 
     // Note: the frame size must be computed before we return from this function.
     *frameSizeOut = iter.topFrameSize();
 
-    uint32 retval = ConvertFrames(cx, activation, iter);
+    uint32_t retval = ConvertFrames(cx, activation, iter);
 
     {
         IonJSFrameLayout *frame = iter.jsFrame();
         IonSpew(IonSpew_Invalidate, "converting to exit frame");
         IonSpew(IonSpew_Invalidate, "   orig calleeToken %p", (void *) frame->calleeToken());
         IonSpew(IonSpew_Invalidate, "   orig frameSize %u", unsigned(frame->prevFrameLocalSize()));
         IonSpew(IonSpew_Invalidate, "   orig ra %p", (void *) frame->returnAddress());
 
@@ -459,18 +459,18 @@ ReflowArgTypes(JSContext *cx)
     types::AutoEnterTypeInference enter(cx);
 
     if (!fp->isConstructing())
         types::TypeScript::SetThis(cx, script, fp->thisValue());
     for (unsigned i = 0; i < nargs; ++i)
         types::TypeScript::SetArgument(cx, script, i, fp->unaliasedFormal(i, DONT_CHECK_ALIASING));
 }
 
-uint32
-ion::ReflowTypeInfo(uint32 bailoutResult)
+uint32_t
+ion::ReflowTypeInfo(uint32_t bailoutResult)
 {
     JSContext *cx = GetIonContext()->cx;
     IonActivation *activation = cx->runtime->ionActivation;
 
     IonSpew(IonSpew_Bailouts, "reflowing type info");
 
     if (bailoutResult == BAILOUT_RETURN_ARGUMENT_CHECK) {
         IonSpew(IonSpew_Bailouts, "reflowing type info at argument-checked entry");
@@ -494,17 +494,17 @@ ion::ReflowTypeInfo(uint32 bailoutResult
 
     // When a type barrier fails, the bad value is at the top of the stack.
     Value &result = cx->regs().sp[-1];
     types::TypeScript::Monitor(cx, script, pc, result);
 
     return true;
 }
 
-uint32
+uint32_t
 ion::RecompileForInlining()
 {
     JSContext *cx = GetIonContext()->cx;
     RawScript script = cx->fp()->script().unsafeGet();
 
     IonSpew(IonSpew_Inlining, "Recompiling script to inline calls %s:%d", script->filename,
             script->lineno);
 
@@ -525,17 +525,17 @@ ion::EnsureHasCallObject(JSContext *cx, 
         fp->fun()->isHeavyweight() &&
         !fp->hasCallObj())
     {
         return fp->initCallObject(cx);
     }
     return true;
 }
 
-uint32
+uint32_t
 ion::BoundsCheckFailure()
 {
     JSContext *cx = GetIonContext()->cx;
     JSScript *script = GetBailedJSScript(cx);
 
     IonSpew(IonSpew_Bailouts, "Bounds check failure %s:%d", script->filename,
             script->lineno);
 
@@ -546,33 +546,33 @@ ion::BoundsCheckFailure()
         IonSpew(IonSpew_Invalidate, "Invalidating due to bounds check failure");
 
         return Invalidate(cx, script);
     }
 
     return true;
 }
 
-uint32
+uint32_t
 ion::ShapeGuardFailure()
 {
     JSContext *cx = GetIonContext()->cx;
     JSScript *script = GetBailedJSScript(cx);
 
     JS_ASSERT(script->hasIonScript());
     JS_ASSERT(!script->ion->invalidated());
 
     script->failedShapeGuard = true;
 
     IonSpew(IonSpew_Invalidate, "Invalidating due to shape guard failure");
 
     return Invalidate(cx, script);
 }
 
-uint32
+uint32_t
 ion::CachedShapeGuardFailure()
 {
     JSContext *cx = GetIonContext()->cx;
     JSScript *script = GetBailedJSScript(cx);
 
     JS_ASSERT(script->hasIonScript());
     JS_ASSERT(!script->ion->invalidated());
 
@@ -583,17 +583,17 @@ ion::CachedShapeGuardFailure()
     for (size_t i = 0; i < script->ion->scriptEntries(); i++)
         mjit::PurgeCaches(script->ion->getScript(i));
 
     IonSpew(IonSpew_Invalidate, "Invalidating due to shape guard failure");
 
     return Invalidate(cx, script);
 }
 
-uint32
+uint32_t
 ion::ThunkToInterpreter(Value *vp)
 {
     JSContext *cx = GetIonContext()->cx;
     IonActivation *activation = cx->runtime->ionActivation;
     BailoutClosure *br = activation->takeBailout();
 
     if (!EnsureHasCallObject(cx, cx->fp()))
         return Interpret_Error;

--- a/js/src/ion/Bailouts.h
+++ b/js/src/ion/Bailouts.h
@@ -86,34 +86,34 @@ namespace ion {
 // pointers. To account for this we segregate frames into a limited set of
 // "frame sizes", and create a table for each frame size. We also have the
 // option of not using bailout tables, for platforms or situations where the
 // 10 byte cost is more optimal than a bailout table. See IonFrames.h for more
 // detail.
 
 static const BailoutId INVALID_BAILOUT_ID = BailoutId(-1);
 
-static const uint32 BAILOUT_KIND_BITS = 3;
-static const uint32 BAILOUT_RESUME_BITS = 1;
+static const uint32_t BAILOUT_KIND_BITS = 3;
+static const uint32_t BAILOUT_RESUME_BITS = 1;
 
 // Keep this arbitrarily small for now, for testing.
-static const uint32 BAILOUT_TABLE_SIZE = 16;
+static const uint32_t BAILOUT_TABLE_SIZE = 16;
 
 // Bailout return codes.
 // N.B. the relative order of these values is hard-coded into ::GenerateBailoutThunk.
-static const uint32 BAILOUT_RETURN_OK = 0;
-static const uint32 BAILOUT_RETURN_FATAL_ERROR = 1;
-static const uint32 BAILOUT_RETURN_ARGUMENT_CHECK = 2;
-static const uint32 BAILOUT_RETURN_TYPE_BARRIER = 3;
-static const uint32 BAILOUT_RETURN_MONITOR = 4;
-static const uint32 BAILOUT_RETURN_RECOMPILE_CHECK = 5;
-static const uint32 BAILOUT_RETURN_BOUNDS_CHECK = 6;
-static const uint32 BAILOUT_RETURN_SHAPE_GUARD = 7;
-static const uint32 BAILOUT_RETURN_OVERRECURSED = 8;
-static const uint32 BAILOUT_RETURN_CACHED_SHAPE_GUARD = 9;
+static const uint32_t BAILOUT_RETURN_OK = 0;
+static const uint32_t BAILOUT_RETURN_FATAL_ERROR = 1;
+static const uint32_t BAILOUT_RETURN_ARGUMENT_CHECK = 2;
+static const uint32_t BAILOUT_RETURN_TYPE_BARRIER = 3;
+static const uint32_t BAILOUT_RETURN_MONITOR = 4;
+static const uint32_t BAILOUT_RETURN_RECOMPILE_CHECK = 5;
+static const uint32_t BAILOUT_RETURN_BOUNDS_CHECK = 6;
+static const uint32_t BAILOUT_RETURN_SHAPE_GUARD = 7;
+static const uint32_t BAILOUT_RETURN_OVERRECURSED = 8;
+static const uint32_t BAILOUT_RETURN_CACHED_SHAPE_GUARD = 9;
 
 // Attached to the compartment for easy passing through from ::Bailout to
 // ::ThunkToInterpreter.
 class BailoutClosure
 {
     // These class are used to control the stack usage and the order of
     // declaration is used by the destructor to restore the stack in the
     // expected order when classes are created. This class is only created
@@ -171,17 +171,17 @@ class InvalidationBailoutStack;
 // Must be implemented by each architecture.
 
 // This iterator is constructed at a time where there is no exit frame at the
 // moment. They must be initialized to the first JS frame instead of the exit
 // frame as usually done with IonFrameIterator.
 class IonBailoutIterator : public IonFrameIterator
 {
     MachineState machine_;
-    uint32 snapshotOffset_;
+    uint32_t snapshotOffset_;
     size_t topFrameSize_;
     IonScript *topIonScript_;
 
   public:
     IonBailoutIterator(const IonActivationIterator &activations, BailoutStack *sp);
     IonBailoutIterator(const IonActivationIterator &activations, InvalidationBailoutStack *sp);
 
     SnapshotOffset snapshotOffset() const {
@@ -202,32 +202,32 @@ class IonBailoutIterator : public IonFra
     }
 
     void dump() const;
 };
 
 bool EnsureHasCallObject(JSContext *cx, StackFrame *fp);
 
 // Called from a bailout thunk. Returns a BAILOUT_* error code.
-uint32 Bailout(BailoutStack *sp);
+uint32_t Bailout(BailoutStack *sp);
 
 // Called from the invalidation thunk. Returns a BAILOUT_* error code.
-uint32 InvalidationBailout(InvalidationBailoutStack *sp, size_t *frameSizeOut);
+uint32_t InvalidationBailout(InvalidationBailoutStack *sp, size_t *frameSizeOut);
 
 // Called from a bailout thunk. Interprets the frame(s) that have been bailed
 // out.
-uint32 ThunkToInterpreter(Value *vp);
+uint32_t ThunkToInterpreter(Value *vp);
 
-uint32 ReflowTypeInfo(uint32 bailoutResult);
+uint32_t ReflowTypeInfo(uint32_t bailoutResult);
 
-uint32 RecompileForInlining();
+uint32_t RecompileForInlining();
 
-uint32 BoundsCheckFailure();
+uint32_t BoundsCheckFailure();
 
-uint32 ShapeGuardFailure();
+uint32_t ShapeGuardFailure();
 
-uint32 CachedShapeGuardFailure();
+uint32_t CachedShapeGuardFailure();
 
 } // namespace ion
 } // namespace js
 
 #endif // jsion_bailouts_h__
 

--- a/js/src/ion/BitSet.cpp
+++ b/js/src/ion/BitSet.cpp
@@ -21,17 +21,17 @@ BitSet::New(unsigned int max)
 }
 
 bool
 BitSet::init()
 {
     size_t sizeRequired = numWords() * sizeof(*bits_);
 
     TempAllocator *alloc = GetIonContext()->temp;
-    bits_ = (uint32 *)alloc->allocate(sizeRequired);
+    bits_ = (uint32_t *)alloc->allocate(sizeRequired);
     if (!bits_)
         return false;
 
     memset(bits_, 0, sizeRequired);
 
     return true;
 }
 
@@ -85,17 +85,17 @@ BitSet::fixedPointIntersect(const BitSet
 {
     JS_ASSERT(bits_);
     JS_ASSERT(other->max_ == max_);
     JS_ASSERT(other->bits_);
 
     bool changed = false;
 
     for (unsigned int i = 0; i < numWords(); i++) {
-        uint32 old = bits_[i];
+        uint32_t old = bits_[i];
         bits_[i] &= other->bits_[i];
 
         if (!changed && old != bits_[i])
             changed = true;
     }
     return changed;
 }
 

--- a/js/src/ion/BitSet.h
+++ b/js/src/ion/BitSet.h
@@ -15,33 +15,33 @@ namespace ion {
 
 // Provides constant time set insertion and removal, and fast linear
 // set operations such as intersection, difference, and union.
 // N.B. All set operations must be performed on sets with the same maximum.
 class BitSet : private TempObject
 {
   public:
     static size_t RawLengthForBits(size_t bits) {
-        return 1 + bits / (8 * sizeof(uint32));
+        return 1 + bits / (8 * sizeof(uint32_t));
     }
 
   private:
     BitSet(unsigned int max) :
         max_(max),
         bits_(NULL) {};
 
     unsigned int max_;
-    uint32 *bits_;
+    uint32_t *bits_;
 
-    static inline uint32 bitForValue(unsigned int value) {
-        return 1l << (uint32)(value % (8 * sizeof(uint32)));
+    static inline uint32_t bitForValue(unsigned int value) {
+        return 1l << (uint32_t)(value % (8 * sizeof(uint32_t)));
     }
 
     static inline unsigned int wordForValue(unsigned int value) {
-        return value / (8 * sizeof(uint32));
+        return value / (8 * sizeof(uint32_t));
     }
 
     inline unsigned int numWords() const {
         return RawLengthForBits(max_);
     }
 
     bool init();
 
@@ -95,31 +95,31 @@ class BitSet : private TempObject
     bool fixedPointIntersect(const BitSet *other);
 
     // O(max): Does inplace complement of the set.
     void complement();
 
     // O(max): Clear this set.
     void clear();
 
-    uint32 *raw() const {
+    uint32_t *raw() const {
         return bits_;
     }
     size_t rawLength() const {
         return numWords();
     }
 };
 
 class BitSet::Iterator
 {
   private:
     BitSet &set_;
     unsigned index_;
     unsigned word_;
-    uint32 value_;
+    uint32_t value_;
 
   public:
     Iterator(BitSet &set) :
       set_(set),
       index_(0),
       word_(0),
       value_(set.bits_[0])
     {

--- a/js/src/ion/C1Spewer.cpp
+++ b/js/src/ion/C1Spewer.cpp
@@ -112,17 +112,17 @@ void
 C1Spewer::spewIntervals(FILE *fp, LinearScanAllocator *regalloc, LInstruction *ins, size_t &nextId)
 {
     for (size_t k = 0; k < ins->numDefs(); k++) {
         VirtualRegister *vreg = &regalloc->vregs[ins->getDef(k)->virtualRegister()];
 
         for (size_t i = 0; i < vreg->numIntervals(); i++) {
             LiveInterval *live = vreg->getInterval(i);
             if (live->numRanges()) {
-                fprintf(fp, "%d object \"", (i == 0) ? vreg->id() : int32(nextId++));
+                fprintf(fp, "%d object \"", (i == 0) ? vreg->id() : int32_t(nextId++));
                 LAllocation::PrintAllocation(fp, live->getAllocation());
                 fprintf(fp, "\" %d -1", vreg->id());
                 for (size_t j = 0; j < live->numRanges(); j++) {
                     fprintf(fp, " [%d, %d[", live->getRange(j)->from.pos(),
                             live->getRange(j)->to.pos());
                 }
                 for (UsePositionIterator usePos(live->usesBegin()); usePos != live->usesEnd(); usePos++)
                     fprintf(fp, " %d M", usePos->pos.pos());
@@ -150,24 +150,24 @@ void
 C1Spewer::spewPass(FILE *fp, MBasicBlock *block)
 {
     fprintf(fp, "  begin_block\n");
     fprintf(fp, "    name \"B%d\"\n", block->id());
     fprintf(fp, "    from_bci -1\n");
     fprintf(fp, "    to_bci -1\n");
 
     fprintf(fp, "    predecessors");
-    for (uint32 i = 0; i < block->numPredecessors(); i++) {
+    for (uint32_t i = 0; i < block->numPredecessors(); i++) {
         MBasicBlock *pred = block->getPredecessor(i);
         fprintf(fp, " \"B%d\"", pred->id());
     }
     fprintf(fp, "\n");
 
     fprintf(fp, "    successors");
-    for (uint32 i = 0; i < block->numSuccessors(); i++) {
+    for (uint32_t i = 0; i < block->numSuccessors(); i++) {
         MBasicBlock *successor = block->getSuccessor(i);
         fprintf(fp, " \"B%d\"", successor->id());
     }
     fprintf(fp, "\n");
 
     fprintf(fp, "    xhandlers\n");
     fprintf(fp, "    flags\n");
 
@@ -176,17 +176,17 @@ C1Spewer::spewPass(FILE *fp, MBasicBlock
         fprintf(fp, "    last_lir_id %d\n", block->lir()->lastId());
     }
 
     fprintf(fp, "    begin_states\n");
 
     fprintf(fp, "      begin_locals\n");
     fprintf(fp, "        size %d\n", (int)block->numEntrySlots());
     fprintf(fp, "        method \"None\"\n");
-    for (uint32 i = 0; i < block->numEntrySlots(); i++) {
+    for (uint32_t i = 0; i < block->numEntrySlots(); i++) {
         MDefinition *ins = block->getEntrySlot(i);
         fprintf(fp, "        ");
         fprintf(fp, "%d ", i);
         if (ins->isUnused())
             fprintf(fp, "unused");
         else
             ins->printName(fp);
         fprintf(fp, "\n");

--- a/js/src/ion/CodeGenerator.cpp
+++ b/js/src/ion/CodeGenerator.cpp
@@ -336,17 +336,17 @@ CodeGenerator::visitNop(LNop *lir)
 bool
 CodeGenerator::visitOsiPoint(LOsiPoint *lir)
 {
     // Note: markOsiPoint ensures enough space exists between the last
     // LOsiPoint and this one to patch adjacent call instructions.
 
     JS_ASSERT(masm.framePushed() == frameSize());
 
-    uint32 osiCallPointOffset;
+    uint32_t osiCallPointOffset;
     if (!markOsiPoint(lir, &osiCallPointOffset))
         return false;
 
     LSafepoint *safepoint = lir->associatedSafepoint();
     JS_ASSERT(!safepoint->osiCallPointOffset());
     safepoint->setOsiCallPointOffset(osiCallPointOffset);
     return true;
 }
@@ -472,37 +472,37 @@ CodeGenerator::visitOsrScopeChain(LOsrSc
     return true;
 }
 
 bool
 CodeGenerator::visitStackArgT(LStackArgT *lir)
 {
     const LAllocation *arg = lir->getArgument();
     MIRType argType = lir->mir()->getArgument()->type();
-    uint32 argslot = lir->argslot();
-
-    int32 stack_offset = StackOffsetOfPassedArg(argslot);
+    uint32_t argslot = lir->argslot();
+
+    int32_t stack_offset = StackOffsetOfPassedArg(argslot);
     Address dest(StackPointer, stack_offset);
 
     if (arg->isFloatReg())
         masm.storeDouble(ToFloatRegister(arg), dest);
     else if (arg->isRegister())
         masm.storeValue(ValueTypeFromMIRType(argType), ToRegister(arg), dest);
     else
         masm.storeValue(*(arg->toConstant()), dest);
 
     return pushedArgumentSlots_.append(StackOffsetToSlot(stack_offset));
 }
 
 bool
 CodeGenerator::visitStackArgV(LStackArgV *lir)
 {
     ValueOperand val = ToValue(lir, 0);
-    uint32 argslot = lir->argslot();
-    int32 stack_offset = StackOffsetOfPassedArg(argslot);
+    uint32_t argslot = lir->argslot();
+    int32_t stack_offset = StackOffsetOfPassedArg(argslot);
 
     masm.storeValue(val, Address(StackPointer, stack_offset));
     return pushedArgumentSlots_.append(StackOffsetToSlot(stack_offset));
 }
 
 bool
 CodeGenerator::visitInteger(LInteger *lir)
 {
@@ -527,17 +527,17 @@ CodeGenerator::visitSlots(LSlots *lir)
     masm.loadPtr(slots, ToRegister(lir->output()));
     return true;
 }
 
 bool
 CodeGenerator::visitStoreSlotV(LStoreSlotV *store)
 {
     Register base = ToRegister(store->slots());
-    int32 offset  = store->mir()->slot() * sizeof(Value);
+    int32_t offset = store->mir()->slot() * sizeof(Value);
 
     const ValueOperand value = ToValue(store, LStoreSlotV::Value);
 
     if (store->mir()->needsBarrier())
        emitPreBarrier(Address(base, offset), MIRType_Value);
 
     masm.storeValue(value, Address(base, offset));
     return true;
@@ -598,17 +598,17 @@ CodeGenerator::visitCallNative(LCallNati
     // Registers used for callWithABI() argument-passing.
     const Register argJSContextReg = ToRegister(call->getArgJSContextReg());
     const Register argUintNReg     = ToRegister(call->getArgUintNReg());
     const Register argVpReg        = ToRegister(call->getArgVpReg());
 
     // Misc. temporary registers.
     const Register tempReg = ToRegister(call->getTempReg());
 
-    DebugOnly<uint32> initialStack = masm.framePushed();
+    DebugOnly<uint32_t> initialStack = masm.framePushed();
 
     masm.checkStackAlignment();
 
     // Native functions have the signature:
     //  bool (*)(JSContext *, unsigned, Value *vp)
     // Where vp[0] is space for an outparam, vp[1] is |this|, and vp[2] onward
     // are the function arguments.
 
@@ -622,17 +622,17 @@ CodeGenerator::visitCallNative(LCallNati
     // Preload arguments into registers.
     masm.loadJSContext(argJSContextReg);
     masm.move32(Imm32(call->numStackArgs()), argUintNReg);
     masm.movePtr(StackPointer, argVpReg);
 
     masm.Push(argUintNReg);
 
     // Construct native exit frame.
-    uint32 safepointOffset;
+    uint32_t safepointOffset;
     if (!masm.buildFakeExitFrame(tempReg, &safepointOffset))
         return false;
     masm.enterFakeExitFrame();
 
     if (!markSafepointAt(safepointOffset, call))
         return false;
 
     // Construct and execute call.
@@ -682,17 +682,17 @@ CodeGenerator::visitCallDOMNative(LCallD
 
     // Registers used for callWithABI() argument-passing.
     const Register argJSContext = ToRegister(call->getArgJSContext());
     const Register argObj       = ToRegister(call->getArgObj());
     const Register argPrivate   = ToRegister(call->getArgPrivate());
     const Register argArgc      = ToRegister(call->getArgArgc());
     const Register argVp        = ToRegister(call->getArgVp());
 
-    DebugOnly<uint32> initialStack = masm.framePushed();
+    DebugOnly<uint32_t> initialStack = masm.framePushed();
 
     masm.checkStackAlignment();
 
     // DOM methods have the signature:
     //  bool (*)(JSContext *, HandleObject, void *private, unsigned argc, Value *vp)
     // Where vp[0] is space for an outparam and the callee, vp[1] is |this|, and vp[2] onward
     // are the function arguments.
 
@@ -718,17 +718,17 @@ CodeGenerator::visitCallDOMNative(LCallD
 
     // Push |this| object for passing HandleObject. We push after argc to
     // maintain the same sp-relative location of the object pointer with other
     // DOMExitFrames.
     masm.Push(argObj);
     masm.movePtr(StackPointer, argObj);
 
     // Construct native exit frame.
-    uint32 safepointOffset;
+    uint32_t safepointOffset;
     if (!masm.buildFakeExitFrame(argJSContext, &safepointOffset))
         return false;
     masm.enterFakeExitFrame(ION_FRAME_DOMMETHOD);
 
     if (!markSafepointAt(safepointOffset, call))
         return false;
 
     // Construct and execute call.
@@ -781,22 +781,22 @@ static const VMFunction GetIntrinsicValu
 
 bool
 CodeGenerator::visitCallGetIntrinsicValue(LCallGetIntrinsicValue *lir)
 {
     pushArg(ImmGCPtr(lir->mir()->name()));
     return callVM(GetIntrinsicValueInfo, lir);
 }
 
-typedef bool (*InvokeFunctionFn)(JSContext *, JSFunction *, uint32, Value *, Value *);
+typedef bool (*InvokeFunctionFn)(JSContext *, JSFunction *, uint32_t, Value *, Value *);
 static const VMFunction InvokeFunctionInfo = FunctionInfo<InvokeFunctionFn>(InvokeFunction);
 
 bool
 CodeGenerator::emitCallInvokeFunction(LInstruction *call, Register calleereg,
-                                      uint32 argc, uint32 unusedStack)
+                                      uint32_t argc, uint32_t unusedStack)
 {
     // Nestle %esp up to the argument vector.
     // Each path must account for framePushed_ separately, for callVM to be valid.
     masm.freeStack(unusedStack);
 
     pushArg(StackPointer); // argv.
     pushArg(Imm32(argc));  // argc.
     pushArg(calleereg);    // JSFunction *.
@@ -821,17 +821,17 @@ static inline int32_t ionOffset(Executio
 }
 
 bool
 CodeGenerator::visitCallGeneric(LCallGeneric *call)
 {
     Register calleereg = ToRegister(call->getFunction());
     Register objreg    = ToRegister(call->getTempObject());
     Register nargsreg  = ToRegister(call->getNargsReg());
-    uint32 unusedStack = StackOffsetOfPassedArg(call->argslot());
+    uint32_t unusedStack = StackOffsetOfPassedArg(call->argslot());
     Label invoke, thunk, makeCall, end;
 
     // Known-target case is handled by LCallKnown.
     JS_ASSERT(!call->hasSingleTarget());
     // Unknown constructor case is handled by LCallConstructor.
     JS_ASSERT(!call->mir()->isConstructing());
 
     // Generate an ArgumentsRectifier.
@@ -856,17 +856,17 @@ CodeGenerator::visitCallGeneric(LCallGen
 
     // Guard that the IonScript has been compiled.
     masm.branchPtr(Assembler::BelowOrEqual, objreg, ImmWord(ION_COMPILING_SCRIPT), &invoke);
 
     // Nestle the StackPointer up to the argument vector.
     masm.freeStack(unusedStack);
 
     // Construct the IonFramePrefix.
-    uint32 descriptor = MakeFrameDescriptor(masm.framePushed(), IonFrame_OptimizedJS);
+    uint32_t descriptor = MakeFrameDescriptor(masm.framePushed(), IonFrame_OptimizedJS);
     masm.Push(Imm32(call->numActualArgs()));
     masm.Push(calleereg);
     masm.Push(Imm32(descriptor));
 
     // Check whether the provided arguments satisfy target argc.
     masm.load16ZeroExtend(Address(calleereg, offsetof(JSFunction, nargs)), nargsreg);
     masm.cmp32(nargsreg, Imm32(call->numStackArgs()));
     masm.j(Assembler::Above, &thunk);
@@ -882,17 +882,17 @@ CodeGenerator::visitCallGeneric(LCallGen
         JS_ASSERT(ArgumentsRectifierReg != objreg);
         masm.movePtr(ImmGCPtr(argumentsRectifier), objreg); // Necessary for GC marking.
         masm.loadPtr(Address(objreg, IonCode::offsetOfCode()), objreg);
         masm.move32(Imm32(call->numStackArgs()), ArgumentsRectifierReg);
     }
 
     // Finally call the function in objreg.
     masm.bind(&makeCall);
-    uint32 callOffset = masm.callIon(objreg);
+    uint32_t callOffset = masm.callIon(objreg);
     if (!markSafepointAt(callOffset, call))
         return false;
 
     // Increment to remove IonFramePrefix; decrement to fill FrameSizeClass.
     // The return address has already been removed from the Ion frame.
     int prefixGarbage = sizeof(IonJSFrameLayout) - sizeof(void *);
     masm.adjustStack(prefixGarbage - unusedStack);
     masm.jump(&end);
@@ -908,17 +908,17 @@ CodeGenerator::visitCallGeneric(LCallGen
 }
 
 bool
 CodeGenerator::visitCallKnown(LCallKnown *call)
 {
     JSContext *cx = GetIonContext()->cx;
     Register calleereg = ToRegister(call->getFunction());
     Register objreg    = ToRegister(call->getTempObject());
-    uint32 unusedStack = StackOffsetOfPassedArg(call->argslot());
+    uint32_t unusedStack = StackOffsetOfPassedArg(call->argslot());
     JSFunction *target = call->getSingleTarget();
     Label end, invoke;
 
     // Native single targets are handled by LCallNative.
     JS_ASSERT(!target->isNative());
     // Missing arguments must have been explicitly appended by the IonBuilder.
     JS_ASSERT(target->nargs <= call->numStackArgs());
 
@@ -952,23 +952,23 @@ CodeGenerator::visitCallKnown(LCallKnown
     // Load the start of the target IonCode.
     masm.loadPtr(Address(objreg, IonScript::offsetOfMethod()), objreg);
     masm.loadPtr(Address(objreg, IonCode::offsetOfCode()), objreg);
 
     // Nestle the StackPointer up to the argument vector.
     masm.freeStack(unusedStack);
 
     // Construct the IonFramePrefix.
-    uint32 descriptor = MakeFrameDescriptor(masm.framePushed(), IonFrame_OptimizedJS);
+    uint32_t descriptor = MakeFrameDescriptor(masm.framePushed(), IonFrame_OptimizedJS);
     masm.Push(Imm32(call->numActualArgs()));
     masm.Push(calleereg);
     masm.Push(Imm32(descriptor));
 
     // Finally call the function in objreg.
-    uint32 callOffset = masm.callIon(objreg);
+    uint32_t callOffset = masm.callIon(objreg);
     if (!markSafepointAt(callOffset, call))
         return false;
 
     // Increment to remove IonFramePrefix; decrement to fill FrameSizeClass.
     // The return address has already been removed from the Ion frame.
     int prefixGarbage = sizeof(IonJSFrameLayout) - sizeof(void *);
     masm.adjustStack(prefixGarbage - unusedStack);
     masm.jump(&end);
@@ -988,31 +988,31 @@ CodeGenerator::visitCallKnown(LCallKnown
         masm.loadValue(Address(StackPointer, unusedStack), JSReturnOperand);
         masm.bind(&notPrimitive);
     }
 
     dropArguments(call->numStackArgs() + 1);
     return true;
 }
 
-typedef bool (*InvokeConstructorFn)(JSContext *, JSObject *, uint32, Value *, Value *);
+typedef bool (*InvokeConstructorFn)(JSContext *, JSObject *, uint32_t, Value *, Value *);
 static const VMFunction InvokeConstructorInfo =
     FunctionInfo<InvokeConstructorFn>(ion::InvokeConstructor);
 
 bool
 CodeGenerator::visitCallConstructor(LCallConstructor *call)
 {
     JS_ASSERT(call->mir()->isConstructing());
 
     // Holds the function object.
     const LAllocation *callee = call->getFunction();
     Register calleereg = ToRegister(callee);
 
-    uint32 callargslot = call->argslot();
-    uint32 unusedStack = StackOffsetOfPassedArg(callargslot);
+    uint32_t callargslot = call->argslot();
+    uint32_t unusedStack = StackOffsetOfPassedArg(callargslot);
 
     // Nestle %esp up to the argument vector.
     masm.freeStack(unusedStack);
 
     pushArg(StackPointer);                  // argv.
     pushArg(Imm32(call->numActualArgs()));  // argc.
     pushArg(calleereg);                     // JSFunction *.
 
@@ -1209,17 +1209,17 @@ CodeGenerator::visitApplyArgsGeneric(LAp
             masm.movePtr(ImmGCPtr(argumentsRectifier), objreg); // Necessary for GC marking.
             masm.loadPtr(Address(objreg, IonCode::offsetOfCode()), objreg);
             masm.movePtr(argcreg, ArgumentsRectifierReg);
         }
 
         masm.bind(&rejoin);
 
         // Finally call the function in objreg, as assigned by one of the paths above.
-        uint32 callOffset = masm.callIon(objreg);
+        uint32_t callOffset = masm.callIon(objreg);
         if (!markSafepointAt(callOffset, apply))
             return false;
 
         // Recover the number of arguments from the frame descriptor.
         masm.loadPtr(Address(StackPointer, 0), copyreg);
         masm.rshiftPtr(Imm32(FRAMESIZE_SHIFT), copyreg);
         masm.subPtr(Imm32(pushed), copyreg);
 
@@ -1240,17 +1240,17 @@ CodeGenerator::visitApplyArgsGeneric(LAp
     // Pop arguments and continue.
     masm.bind(&end);
     emitPopArguments(apply, copyreg);
 
     return true;
 }
 
 // Registers safe for use before generatePrologue().
-static const uint32 EntryTempMask = Registers::TempMask & ~(1 << OsrFrameReg.code());
+static const uint32_t EntryTempMask = Registers::TempMask & ~(1 << OsrFrameReg.code());
 
 bool
 CodeGenerator::generateArgumentsChecks()
 {
     MIRGraph &mir = gen->graph();
     MResumePoint *rp = mir.entryResumePoint();
 
     // Reserve the amount of stack the actual frame will use. We have to undo
@@ -1260,29 +1260,29 @@ CodeGenerator::generateArgumentsChecks()
 
     // No registers are allocated yet, so it's safe to grab anything.
     Register temp = GeneralRegisterSet(EntryTempMask).getAny();
 
     CompileInfo &info = gen->info();
 
     // Indexes need to be shifted by one, to skip the scope chain slot.
     JS_ASSERT(info.scopeChainSlot() == 0);
-    static const uint32 START_SLOT = 1;
+    static const uint32_t START_SLOT = 1;
 
     Label mismatched;
-    for (uint32 i = START_SLOT; i < CountArgSlots(info.fun()); i++) {
+    for (uint32_t i = START_SLOT; i < CountArgSlots(info.fun()); i++) {
         // All initial parameters are guaranteed to be MParameters.
         MParameter *param = rp->getOperand(i)->toParameter();
         const types::TypeSet *types = param->typeSet();
         if (!types || types->unknown())
             continue;
 
         // Use ReturnReg as a scratch register here, since not all platforms
         // have an actual ScratchReg.
-        int32 offset = ArgToStackOffset((i - START_SLOT) * sizeof(Value));
+        int32_t offset = ArgToStackOffset((i - START_SLOT) * sizeof(Value));
         masm.guardTypeSet(Address(StackPointer, offset), types, temp, &mismatched);
     }
 
     if (mismatched.used() && !bailoutFrom(&mismatched, graph.entrySnapshot()))
         return false;
 
     masm.freeStack(frameSize());
 
@@ -1418,17 +1418,17 @@ CodeGenerator::maybeCreateScriptCounts()
         MBasicBlock *block = graph.getBlock(i)->mir();
 
         // Find a PC offset in the outermost script to use. If this block is
         // from an inlined script, find a location in the outer script to
         // associate information about the inling with.
         MResumePoint *resume = block->entryResumePoint();
         while (resume->caller())
             resume = resume->caller();
-        uint32 offset = resume->pc() - script->code;
+        uint32_t offset = resume->pc() - script->code;
         JS_ASSERT(offset < script->length);
 
         if (!counts->block(i).init(block->id(), offset, block->numSuccessors()))
             return NULL;
         for (size_t j = 0; j < block->numSuccessors(); j++)
             counts->block(i).setSuccessor(j, block->getSuccessor(j)->id());
     }
 
@@ -1438,23 +1438,23 @@ CodeGenerator::maybeCreateScriptCounts()
 // Structure for managing the state tracked for a block by script counters.
 struct ScriptCountBlockState
 {
     IonBlockCounts &block;
     MacroAssembler &masm;
 
     Sprinter printer;
 
-    uint32 instructionBytes;
-    uint32 spillBytes;
+    uint32_t instructionBytes;
+    uint32_t spillBytes;
 
     // Pointer to instructionBytes, spillBytes, or NULL, depending on the last
     // instruction processed.
-    uint32 *last;
-    uint32 lastLength;
+    uint32_t *last;
+    uint32_t lastLength;
 
   public:
     ScriptCountBlockState(IonBlockCounts *block, MacroAssembler *masm)
       : block(*block), masm(*masm),
         printer(GetIonContext()->cx),
         instructionBytes(0), spillBytes(0), last(NULL), lastLength(0)
     {
     }
@@ -1558,17 +1558,17 @@ class OutOfLineNewArray : public OutOfLi
         return codegen->visitOutOfLineNewArray(this);
     }
 
     LNewArray *lir() const {
         return lir_;
     }
 };
 
-typedef JSObject *(*NewInitArrayFn)(JSContext *, uint32, types::TypeObject *);
+typedef JSObject *(*NewInitArrayFn)(JSContext *, uint32_t, types::TypeObject *);
 static const VMFunction NewInitArrayInfo =
     FunctionInfo<NewInitArrayFn>(NewInitArray);
 
 bool
 CodeGenerator::visitNewArrayCallVM(LNewArray *lir)
 {
     Register objReg = ToRegister(lir->output());
 
@@ -1615,17 +1615,17 @@ CodeGenerator::visitNewSlots(LNewSlots *
     return true;
 }
 
 bool
 CodeGenerator::visitNewArray(LNewArray *lir)
 {
     Register objReg = ToRegister(lir->output());
     JSObject *templateObject = lir->mir()->templateObject();
-    uint32 count = lir->mir()->count();
+    uint32_t count = lir->mir()->count();
 
     JS_ASSERT(count < JSObject::NELEMENTS_LIMIT);
 
     size_t maxArraySlots =
         gc::GetGCKindSlots(gc::FINALIZE_OBJECT_LAST) - ObjectElements::VALUES_PER_HEADER;
 
     // Allocate space using the VMCall
     // when mir hints it needs to get allocated immediatly,
@@ -2415,17 +2415,17 @@ CodeGenerator::visitNotV(LNotV *lir)
     masm.bind(&join);
     return true;
 }
 
 bool
 CodeGenerator::visitBoundsCheck(LBoundsCheck *lir)
 {
     if (lir->index()->isConstant()) {
-        // Use uint32_t so that the comparison is unsigned.
+        // Use uint32 so that the comparison is unsigned.
         uint32_t index = ToInt32(lir->index());
         if (lir->length()->isConstant()) {
             uint32_t length = ToInt32(lir->length());
             if (index < length)
                 return true;
             return bailout(lir->snapshot());
         }
         masm.cmp32(ToOperand(lir->length()), Imm32(index));
@@ -2437,24 +2437,24 @@ CodeGenerator::visitBoundsCheck(LBoundsC
     }
     masm.cmp32(ToOperand(lir->length()), ToRegister(lir->index()));
     return bailoutIf(Assembler::BelowOrEqual, lir->snapshot());
 }
 
 bool
 CodeGenerator::visitBoundsCheckRange(LBoundsCheckRange *lir)
 {
-    int32 min = lir->mir()->minimum();
-    int32 max = lir->mir()->maximum();
+    int32_t min = lir->mir()->minimum();
+    int32_t max = lir->mir()->maximum();
     JS_ASSERT(max >= min);
 
     Register temp = ToRegister(lir->getTemp(0));
     if (lir->index()->isConstant()) {
-        int32 nmin, nmax;
-        int32 index = ToInt32(lir->index());
+        int32_t nmin, nmax;
+        int32_t index = ToInt32(lir->index());
         if (SafeAdd(index, min, &nmin) && SafeAdd(index, max, &nmax) && nmin >= 0) {
             masm.cmp32(ToOperand(lir->length()), Imm32(nmax));
             return bailoutIf(Assembler::BelowOrEqual, lir->snapshot());
         }
         masm.mov(Imm32(index), temp);
     } else {
         masm.mov(ToRegister(lir->index()), temp);
     }
@@ -2462,17 +2462,17 @@ CodeGenerator::visitBoundsCheckRange(LBo
     // If the minimum and maximum differ then do an underflow check first.
     // If the two are the same then doing an unsigned comparison on the
     // length will also catch a negative index.
     if (min != max) {
         if (min != 0) {
             masm.add32(Imm32(min), temp);
             if (!bailoutIf(Assembler::Overflow, lir->snapshot()))
                 return false;
-            int32 diff;
+            int32_t diff;
             if (SafeSub(max, min, &diff))
                 max = diff;
             else
                 masm.sub32(Imm32(min), temp);
         }
 
         masm.cmp32(temp, Imm32(0));
         if (!bailoutIf(Assembler::LessThan, lir->snapshot()))
@@ -2492,17 +2492,17 @@ CodeGenerator::visitBoundsCheckRange(LBo
 
     masm.cmp32(ToOperand(lir->length()), temp);
     return bailoutIf(Assembler::BelowOrEqual, lir->snapshot());
 }
 
 bool
 CodeGenerator::visitBoundsCheckLower(LBoundsCheckLower *lir)
 {
-    int32 min = lir->mir()->minimum();
+    int32_t min = lir->mir()->minimum();
     masm.cmp32(ToRegister(lir->index()), Imm32(min));
     return bailoutIf(Assembler::LessThan, lir->snapshot());
 }
 
 class OutOfLineStoreElementHole : public OutOfLineCodeBase<CodeGenerator>
 {
     LInstruction *ins_;
     Label rejoinStore_;
@@ -3101,17 +3101,17 @@ CodeGenerator::visitArgumentsLength(LArg
 bool
 CodeGenerator::visitGetArgument(LGetArgument *lir)
 {
     ValueOperand result = GetValueOutput(lir);
     const LAllocation *index = lir->index();
     size_t argvOffset = frameSize() + IonJSFrameLayout::offsetOfActualArgs();
 
     if (index->isConstant()) {
-        int32 i = index->toConstant()->toInt32();
+        int32_t i = index->toConstant()->toInt32();
         Address argPtr(StackPointer, sizeof(Value) * i + argvOffset);
         masm.loadValue(argPtr, result);
     } else {
         Register i = ToRegister(index);
         BaseIndex argPtr(StackPointer, i, ScaleFromShift(sizeof(Value)), argvOffset);
         masm.loadValue(argPtr, result);
     }
     return true;
@@ -3162,17 +3162,17 @@ CodeGenerator::link()
 
     // We encode safepoints after the OSI-point offsets have been determined.
     encodeSafepoints();
 
     RootedScript script(cx, gen->info().script());
     ExecutionMode executionMode = gen->info().executionMode();
     JS_ASSERT(!HasIonScript(script, executionMode));
 
-    uint32 scriptFrameSize = frameClass_ == FrameSizeClass::None()
+    uint32_t scriptFrameSize = frameClass_ == FrameSizeClass::None()
                            ? frameDepth_
                            : FrameSizeClass::FromDepth(frameDepth_).frameSize();
 
     // Check to make sure we didn't have a mid-build invalidation. If so, we
     // will trickle to ion::Compile() and return Method_Skipped.
     if (cx->compartment->types.compiledInfo.compilerOutput(cx)->isInvalidated())
         return true;
 
@@ -4339,33 +4339,33 @@ CodeGenerator::visitCallInstanceOf(LCall
 bool
 CodeGenerator::visitGetDOMProperty(LGetDOMProperty *ins)
 {
     const Register JSContextReg = ToRegister(ins->getJSContextReg());
     const Register ObjectReg = ToRegister(ins->getObjectReg());
     const Register PrivateReg = ToRegister(ins->getPrivReg());
     const Register ValueReg = ToRegister(ins->getValueReg());
 
-    DebugOnly<uint32> initialStack = masm.framePushed();
+    DebugOnly<uint32_t> initialStack = masm.framePushed();
 
     masm.checkStackAlignment();
 
     /* Make Space for the outparam */
     masm.adjustStack(-int32_t(sizeof(Value)));
     masm.movePtr(StackPointer, ValueReg);
 
     masm.Push(ObjectReg);
 
     // GetReservedSlot(obj, DOM_PROTO_INSTANCE_CLASS_SLOT).toPrivate()
     masm.loadPrivate(Address(ObjectReg, JSObject::getFixedSlotOffset(0)), PrivateReg);
 
     // Rooting will happen at GC time.
     masm.movePtr(StackPointer, ObjectReg);
 
-    uint32 safepointOffset;
+    uint32_t safepointOffset;
     if (!masm.buildFakeExitFrame(JSContextReg, &safepointOffset))
         return false;
     masm.enterFakeExitFrame(ION_FRAME_DOMGETTER);
 
     if (!markSafepointAt(safepointOffset, ins))
         return false;
 
     masm.setupUnalignedABICall(4, JSContextReg);
@@ -4404,34 +4404,34 @@ CodeGenerator::visitGetDOMProperty(LGetD
 bool
 CodeGenerator::visitSetDOMProperty(LSetDOMProperty *ins)
 {
     const Register JSContextReg = ToRegister(ins->getJSContextReg());
     const Register ObjectReg = ToRegister(ins->getObjectReg());
     const Register PrivateReg = ToRegister(ins->getPrivReg());
     const Register ValueReg = ToRegister(ins->getValueReg());
 
-    DebugOnly<uint32> initialStack = masm.framePushed();
+    DebugOnly<uint32_t> initialStack = masm.framePushed();
 
     masm.checkStackAlignment();
 
     // Push thei argument. Rooting will happen at GC time.
     ValueOperand argVal = ToValue(ins, LSetDOMProperty::Value);
     masm.Push(argVal);
     masm.movePtr(StackPointer, ValueReg);
 
     masm.Push(ObjectReg);
 
     // GetReservedSlot(obj, DOM_PROTO_INSTANCE_CLASS_SLOT).toPrivate()
     masm.loadPrivate(Address(ObjectReg, JSObject::getFixedSlotOffset(0)), PrivateReg);
 
     // Rooting will happen at GC time.
     masm.movePtr(StackPointer, ObjectReg);
 
-    uint32 safepointOffset;
+    uint32_t safepointOffset;
     if (!masm.buildFakeExitFrame(JSContextReg, &safepointOffset))
         return false;
     masm.enterFakeExitFrame(ION_FRAME_DOMSETTER);
 
     if (!markSafepointAt(safepointOffset, ins))
         return false;
 
     masm.setupUnalignedABICall(4, JSContextReg);

--- a/js/src/ion/CodeGenerator.h
+++ b/js/src/ion/CodeGenerator.h
@@ -71,17 +71,17 @@ class CodeGenerator : public CodeGenerat
     bool visitPointer(LPointer *lir);
     bool visitSlots(LSlots *lir);
     bool visitStoreSlotV(LStoreSlotV *store);
     bool visitElements(LElements *lir);
     bool visitTypeBarrier(LTypeBarrier *lir);
     bool visitMonitorTypes(LMonitorTypes *lir);
     bool visitCallNative(LCallNative *call);
     bool emitCallInvokeFunction(LInstruction *call, Register callereg,
-                                uint32 argc, uint32 unusedStack);
+                                uint32_t argc, uint32_t unusedStack);
     bool visitCallGeneric(LCallGeneric *call);
     bool visitCallKnown(LCallKnown *call);
     bool visitCallConstructor(LCallConstructor *call);
     bool emitCallInvokeFunction(LApplyArgsGeneric *apply, Register extraStackSize);
     void emitPushArguments(LApplyArgsGeneric *apply, Register extraStackSpace);
     void emitPopArguments(LApplyArgsGeneric *apply, Register extraStackSize);
     bool visitApplyArgsGeneric(LApplyArgsGeneric *apply);
     bool visitDoubleToInt32(LDoubleToInt32 *lir);

--- a/js/src/ion/CompactBuffer.h
+++ b/js/src/ion/CompactBuffer.h
@@ -23,130 +23,130 @@ class CompactBufferWriter;
 // containing 7 bits of the integer and a bit which specifies whether the next
 // byte is also part of the integer.
 //
 // Fixed-width integers are also available, in case the actual value will not
 // be known until later.
 
 class CompactBufferReader
 {
-    const uint8 *buffer_;
-    const uint8 *end_;
+    const uint8_t *buffer_;
+    const uint8_t *end_;
 
-    uint32 readVariableLength() {
-        uint32 val = 0;
-        uint32 shift = 0;
-        uint8 byte;
+    uint32_t readVariableLength() {
+        uint32_t val = 0;
+        uint32_t shift = 0;
+        uint8_t byte;
         while (true) {
             JS_ASSERT(shift < 32);
             byte = readByte();
-            val |= (uint32(byte) >> 1) << shift;
+            val |= (uint32_t(byte) >> 1) << shift;
             shift += 7;
             if (!(byte & 1))
                 return val;
         }
         JS_NOT_REACHED("unreachable");
         return 0;
     }
 
   public:
-    CompactBufferReader(const uint8 *start, const uint8 *end)
+    CompactBufferReader(const uint8_t *start, const uint8_t *end)
       : buffer_(start),
         end_(end)
     { }
     inline CompactBufferReader(const CompactBufferWriter &writer);
-    uint8 readByte() {
+    uint8_t readByte() {
         JS_ASSERT(buffer_ < end_);
         return *buffer_++;
     }
-    uint32 readFixedUint32() {
-        uint32 b0 = readByte();
-        uint32 b1 = readByte();
-        uint32 b2 = readByte();
-        uint32 b3 = readByte();
+    uint32_t readFixedUint32_t() {
+        uint32_t b0 = readByte();
+        uint32_t b1 = readByte();
+        uint32_t b2 = readByte();
+        uint32_t b3 = readByte();
         return b0 | (b1 << 8) | (b2 << 16) | (b3 << 24);
     }
-    uint16 readFixedUint16() {
-        uint32 b0 = readByte();
-        uint32 b1 = readByte();
+    uint16_t readFixedUint16_t() {
+        uint32_t b0 = readByte();
+        uint32_t b1 = readByte();
         return b0 | (b1 << 8);
     }
-    uint32 readUnsigned() {
+    uint32_t readUnsigned() {
         return readVariableLength();
     }
-    int32 readSigned() {
-        uint8 b = readByte();
+    int32_t readSigned() {
+        uint8_t b = readByte();
         bool isNegative = !!(b & (1 << 0));
         bool more = !!(b & (1 << 1));
-        int32 result = b >> 2;
+        int32_t result = b >> 2;
         if (more)
             result |= readUnsigned() << 6;
         if (isNegative)
             return -result;
         return result;
     }
 
     bool more() const {
         JS_ASSERT(buffer_ <= end_);
         return buffer_ < end_;
     }
 };
 
 class CompactBufferWriter
 {
-    js::Vector<uint8, 32, SystemAllocPolicy> buffer_;
+    js::Vector<uint8_t, 32, SystemAllocPolicy> buffer_;
     bool enoughMemory_;
 
   public:
     CompactBufferWriter()
       : enoughMemory_(true)
     { }
 
     // Note: writeByte() takes uint32 to catch implicit casts with a runtime
     // assert.
-    void writeByte(uint32 byte) {
+    void writeByte(uint32_t byte) {
         JS_ASSERT(byte <= 0xFF);
         enoughMemory_ &= buffer_.append(byte);
     }
-    void writeUnsigned(uint32 value) {
+    void writeUnsigned(uint32_t value) {
         do {
-            uint8 byte = ((value & 0x7F) << 1) | (value > 0x7F);
+            uint8_t byte = ((value & 0x7F) << 1) | (value > 0x7F);
             writeByte(byte);
             value >>= 7;
         } while (value);
     }
-    void writeSigned(int32 v) {
+    void writeSigned(int32_t v) {
         bool isNegative = v < 0;
-        uint32 value = isNegative ? -v : v;
-        uint8 byte = ((value & 0x3F) << 2) | ((value > 0x3F) << 1) | uint32(isNegative);
+        uint32_t value = isNegative ? -v : v;
+        uint8_t byte = ((value & 0x3F) << 2) | ((value > 0x3F) << 1) | uint32_t(isNegative);
         writeByte(byte);
 
         // Write out the rest of the bytes, if needed.
         value >>= 6;
         if (value == 0)
             return;
         writeUnsigned(value);
     }
-    void writeFixedUint32(uint32 value) {
+    void writeFixedUint32_t(uint32_t value) {
         writeByte(value & 0xFF);
         writeByte((value >> 8) & 0xFF);
         writeByte((value >> 16) & 0xFF);
         writeByte((value >> 24) & 0xFF);
     }
-    void writeFixedUint16(uint16 value) {
+    void writeFixedUint16_t(uint16_t value) {
         writeByte(value & 0xFF);
         writeByte(value >> 8);
     }
     size_t length() const {
         return buffer_.length();
     }
-    uint8 *buffer() {
+    uint8_t *buffer() {
         return &buffer_[0];
     }
-    const uint8 *buffer() const {
+    const uint8_t *buffer() const {
         return &buffer_[0];
     }
     bool oom() const {
         return !enoughMemory_;
     }
 };
 
 CompactBufferReader::CompactBufferReader(const CompactBufferWriter &writer)

--- a/js/src/ion/CompileInfo.h
+++ b/js/src/ion/CompileInfo.h
@@ -108,40 +108,40 @@ class CompileInfo
     }
     unsigned nlocals() const {
         return script()->nfixed;
     }
     unsigned ninvoke() const {
         return nlocals() + CountArgSlots(fun());
     }
 
-    uint32 scopeChainSlot() const {
+    uint32_t scopeChainSlot() const {
         return 0;
     }
-    uint32 thisSlot() const {
+    uint32_t thisSlot() const {
         JS_ASSERT(fun());
         return 1;
     }
-    uint32 firstArgSlot() const {
+    uint32_t firstArgSlot() const {
         JS_ASSERT(fun());
         return 2;
     }
-    uint32 argSlot(uint32 i) const {
+    uint32_t argSlot(uint32_t i) const {
         return firstArgSlot() + i;
     }
-    uint32 firstLocalSlot() const {
+    uint32_t firstLocalSlot() const {
         return CountArgSlots(fun());
     }
-    uint32 localSlot(uint32 i) const {
+    uint32_t localSlot(uint32_t i) const {
         return firstLocalSlot() + i;
     }
-    uint32 firstStackSlot() const {
+    uint32_t firstStackSlot() const {
         return firstLocalSlot() + nlocals();
     }
-    uint32 stackSlot(uint32 i) const {
+    uint32_t stackSlot(uint32_t i) const {
         return firstStackSlot() + i;
     }
 
     bool hasArguments() {
         return script()->argumentsHasVarBinding();
     }
 
     ExecutionMode executionMode() const {

--- a/js/src/ion/EdgeCaseAnalysis.cpp
+++ b/js/src/ion/EdgeCaseAnalysis.cpp
@@ -21,17 +21,17 @@ EdgeCaseAnalysis::EdgeCaseAnalysis(MIRGe
   : mir(mir), graph(graph)
 {
 }
 
 bool
 EdgeCaseAnalysis::analyzeLate()
 {
     // Renumber definitions for NeedNegativeZeroCheck under analyzeEdgeCasesBackward.
-    uint32 nextId = 1;
+    uint32_t nextId = 1;
 
     for (ReversePostorderIterator block(graph.rpoBegin()); block != graph.rpoEnd(); block++) {
         if (mir->shouldCancel("Analyze Late (first loop)"))
             return false;
         for (MDefinitionIterator iter(*block); iter; iter++) {
             iter->setId(nextId++);
             iter->analyzeEdgeCasesForward();
         }

--- a/js/src/ion/Ion.cpp
+++ b/js/src/ion/Ion.cpp
@@ -156,17 +156,17 @@ IonRuntime::initialize(JSContext *cx)
 
     functionWrappers_ = cx->new_<VMWrapperMap>(cx);
     if (!functionWrappers_ || !functionWrappers_->init())
         return false;
 
     if (!bailoutTables_.reserve(FrameSizeClass::ClassLimit().classId()))
         return false;
 
-    for (uint32 id = 0;; id++) {
+    for (uint32_t id = 0;; id++) {
         FrameSizeClass class_ = FrameSizeClass::FromClass(id);
         if (class_ == FrameSizeClass::ClassLimit())
             break;
         bailoutTables_.infallibleAppend(NULL);
         bailoutTables_[id] = generateBailoutTable(cx, id);
         if (!bailoutTables_[id])
             return false;
     }
@@ -312,17 +312,17 @@ IonActivation::~IonActivation()
     if (entryfp_)
         entryfp_->clearRunningInIon();
     cx_->runtime->ionActivation = prev();
     cx_->runtime->ionTop = prevIonTop_;
     cx_->runtime->ionJSContext = prevIonJSContext_;
 }
 
 IonCode *
-IonCode::New(JSContext *cx, uint8 *code, uint32 bufferSize, JSC::ExecutablePool *pool)
+IonCode::New(JSContext *cx, uint8_t *code, uint32_t bufferSize, JSC::ExecutablePool *pool)
 {
     AssertCanGC();
 
     IonCode *codeObj = gc::NewGCThing<IonCode>(cx, gc::FINALIZE_IONCODE, sizeof(IonCode));
     if (!codeObj) {
         pool->release();
         return NULL;
     }
@@ -355,22 +355,22 @@ void
 IonCode::trace(JSTracer *trc)
 {
     // Note that we cannot mark invalidated scripts, since we've basically
     // corrupted the code stream by injecting bailouts.
     if (invalidated())
         return;
 
     if (jumpRelocTableBytes_) {
-        uint8 *start = code_ + jumpRelocTableOffset();
+        uint8_t *start = code_ + jumpRelocTableOffset();
         CompactBufferReader reader(start, start + jumpRelocTableBytes_);
         MacroAssembler::TraceJumpRelocations(trc, this, reader);
     }
     if (dataRelocTableBytes_) {
-        uint8 *start = code_ + dataRelocTableOffset();
+        uint8_t *start = code_ + dataRelocTableOffset();
         CompactBufferReader reader(start, start + dataRelocTableBytes_);
         MacroAssembler::TraceDataRelocations(trc, this, reader);
     }
 }
 
 void
 IonCode::finalize(FreeOp *fop)
 {
@@ -449,33 +449,33 @@ IonScript::IonScript()
     recompileInfo_(),
     slowCallCount(0)
 {
 }
 
 static const int DataAlignment = 4;
 
 IonScript *
-IonScript::New(JSContext *cx, uint32 frameSlots, uint32 frameSize, size_t snapshotsSize,
+IonScript::New(JSContext *cx, uint32_t frameSlots, uint32_t frameSize, size_t snapshotsSize,
                size_t bailoutEntries, size_t constants, size_t safepointIndices,
                size_t osiIndices, size_t cacheEntries, size_t prebarrierEntries,
                size_t safepointsSize, size_t scriptEntries)
 {
     if (snapshotsSize >= MAX_BUFFER_SIZE ||
-        (bailoutEntries >= MAX_BUFFER_SIZE / sizeof(uint32)))
+        (bailoutEntries >= MAX_BUFFER_SIZE / sizeof(uint32_t)))
     {
         js_ReportOutOfMemory(cx);
         return NULL;
     }
 
     // This should not overflow on x86, because the memory is already allocated
     // *somewhere* and if their total overflowed there would be no memory left
     // at all.
     size_t paddedSnapshotsSize = AlignBytes(snapshotsSize, DataAlignment);
-    size_t paddedBailoutSize = AlignBytes(bailoutEntries * sizeof(uint32), DataAlignment);
+    size_t paddedBailoutSize = AlignBytes(bailoutEntries * sizeof(uint32_t), DataAlignment);
     size_t paddedConstantsSize = AlignBytes(constants * sizeof(Value), DataAlignment);
     size_t paddedSafepointIndicesSize = AlignBytes(safepointIndices * sizeof(SafepointIndex), DataAlignment);
     size_t paddedOsiIndicesSize = AlignBytes(osiIndices * sizeof(OsiIndex), DataAlignment);
     size_t paddedCacheEntriesSize = AlignBytes(cacheEntries * sizeof(IonCache), DataAlignment);
     size_t paddedPrebarrierEntriesSize =
         AlignBytes(prebarrierEntries * sizeof(CodeOffsetLabel), DataAlignment);
     size_t paddedSafepointSize = AlignBytes(safepointsSize, DataAlignment);
     size_t paddedScriptSize = AlignBytes(scriptEntries * sizeof(JSScript *), DataAlignment);
@@ -483,24 +483,24 @@ IonScript::New(JSContext *cx, uint32 fra
                    paddedBailoutSize +
                    paddedConstantsSize +
                    paddedSafepointIndicesSize+
                    paddedOsiIndicesSize +
                    paddedCacheEntriesSize +
                    paddedPrebarrierEntriesSize +
                    paddedSafepointSize +
                    paddedScriptSize;
-    uint8 *buffer = (uint8 *)cx->malloc_(sizeof(IonScript) + bytes);
+    uint8_t *buffer = (uint8_t *)cx->malloc_(sizeof(IonScript) + bytes);
     if (!buffer)
         return NULL;
 
     IonScript *script = reinterpret_cast<IonScript *>(buffer);
     new (script) IonScript();
 
-    uint32 offsetCursor = sizeof(IonScript);
+    uint32_t offsetCursor = sizeof(IonScript);
 
     script->snapshots_ = offsetCursor;
     script->snapshotsSize_ = snapshotsSize;
     offsetCursor += paddedSnapshotsSize;
 
     script->bailoutTable_ = offsetCursor;
     script->bailoutEntries_ = bailoutEntries;
     offsetCursor += paddedBailoutSize;
@@ -553,30 +553,30 @@ IonScript::trace(JSTracer *trc)
     for (size_t i = 0; i < numConstants(); i++)
         gc::MarkValue(trc, &getConstant(i), "constant");
 }
 
 void
 IonScript::copySnapshots(const SnapshotWriter *writer)
 {
     JS_ASSERT(writer->size() == snapshotsSize_);
-    memcpy((uint8 *)this + snapshots_, writer->buffer(), snapshotsSize_);
+    memcpy((uint8_t *)this + snapshots_, writer->buffer(), snapshotsSize_);
 }
 
 void
 IonScript::copySafepoints(const SafepointWriter *writer)
 {
     JS_ASSERT(writer->size() == safepointsSize_);
-    memcpy((uint8 *)this + safepointsStart_, writer->buffer(), safepointsSize_);
+    memcpy((uint8_t *)this + safepointsStart_, writer->buffer(), safepointsSize_);
 }
 
 void
 IonScript::copyBailoutTable(const SnapshotOffset *table)
 {
-    memcpy(bailoutTable(), table, bailoutEntries_ * sizeof(uint32));
+    memcpy(bailoutTable(), table, bailoutEntries_ * sizeof(uint32_t));
 }
 
 void
 IonScript::copyConstants(const HeapValue *vp)
 {
     for (size_t i = 0; i < constantEntries_; i++)
         constants()[i].init(vp[i]);
 }
@@ -637,37 +637,37 @@ IonScript::copyPrebarrierEntries(const C
     memcpy(prebarrierList(), barriers, numPrebarriers() * sizeof(CodeOffsetLabel));
 
     // On ARM, the saved offset may be wrong due to shuffling code buffers. Correct it.
     for (size_t i = 0; i < numPrebarriers(); i++)
         getPrebarrier(i).fixup(&masm);
 }
 
 const SafepointIndex *
-IonScript::getSafepointIndex(uint32 disp) const
+IonScript::getSafepointIndex(uint32_t disp) const
 {
     JS_ASSERT(safepointIndexEntries_ > 0);
 
     const SafepointIndex *table = safepointIndices();
     if (safepointIndexEntries_ == 1) {
         JS_ASSERT(disp == table[0].displacement());
         return &table[0];
     }
 
     size_t minEntry = 0;
     size_t maxEntry = safepointIndexEntries_ - 1;
-    uint32 min = table[minEntry].displacement();
-    uint32 max = table[maxEntry].displacement();
+    uint32_t min = table[minEntry].displacement();
+    uint32_t max = table[maxEntry].displacement();
 
     // Raise if the element is not in the list.
     JS_ASSERT(min <= disp && disp <= max);
 
     // Approximate the location of the FrameInfo.
     size_t guess = (disp - min) * (maxEntry - minEntry) / (max - min) + minEntry;
-    uint32 guessDisp = table[guess].displacement();
+    uint32_t guessDisp = table[guess].displacement();
 
     if (table[guess].displacement() == disp)
         return &table[guess];
 
     // Doing a linear scan from the guess should be more efficient in case of
     // small group which are equally distributed on the code.
     //
     // such as:  <...      ...    ...  ...  .   ...    ...>
@@ -687,38 +687,38 @@ IonScript::getSafepointIndex(uint32 disp
         }
     }
 
     JS_NOT_REACHED("displacement not found.");
     return NULL;
 }
 
 const OsiIndex *
-IonScript::getOsiIndex(uint32 disp) const
+IonScript::getOsiIndex(uint32_t disp) const
 {
     for (const OsiIndex *it = osiIndices(), *end = osiIndices() + osiIndexEntries_;
          it != end;
          ++it)
     {
         if (it->returnPointDisplacement() == disp)
             return it;
     }
 
     JS_NOT_REACHED("Failed to find OSI point return address");
     return NULL;
 }
 
 const OsiIndex *
-IonScript::getOsiIndex(uint8 *retAddr) const
+IonScript::getOsiIndex(uint8_t *retAddr) const
 {
     IonSpew(IonSpew_Invalidate, "IonScript %p has method %p raw %p", (void *) this, (void *)
             method(), method()->raw());
 
     JS_ASSERT(containsCodeAddress(retAddr));
-    uint32 disp = retAddr - method()->raw();
+    uint32_t disp = retAddr - method()->raw();
     return getOsiIndex(disp);
 }
 
 void
 IonScript::Trace(JSTracer *trc, IonScript *script)
 {
     if (script != ION_DISABLED_SCRIPT)
         script->trace(trc);
@@ -1668,17 +1668,17 @@ ion::FastInvoke(JSContext *cx, HandleFun
 
     args.rval().set(result);
 
     JS_ASSERT_IF(result.isMagic(), result.isMagic(JS_ION_ERROR));
     return result.isMagic() ? IonExec_Error : IonExec_Ok;
 }
 
 static void
-InvalidateActivation(FreeOp *fop, uint8 *ionTop, bool invalidateAll)
+InvalidateActivation(FreeOp *fop, uint8_t *ionTop, bool invalidateAll)
 {
     AutoAssertNoGC nogc;
     IonSpew(IonSpew_Invalidate, "BEGIN invalidating activation");
 
     size_t frameno = 1;
 
     for (IonFrameIterator it(ionTop); !it.done(); ++it, ++frameno) {
         JS_ASSERT_IF(frameno == 1, it.type() == IonFrame_Exit);

--- a/js/src/ion/Ion.h
+++ b/js/src/ion/Ion.h
@@ -77,90 +77,90 @@ struct IonOptions
     //
     // Default: true iff there are at least two CPUs available
     bool parallelCompilation;
 
     // How many invocations or loop iterations are needed before functions
     // are compiled.
     //
     // Default: 10,240
-    uint32 usesBeforeCompile;
+    uint32_t usesBeforeCompile;
 
     // How many invocations or loop iterations are needed before functions
     // are compiled when JM is disabled.
     //
     // Default: 40
-    uint32 usesBeforeCompileNoJaeger;
+    uint32_t usesBeforeCompileNoJaeger;
 
     // How many invocations or loop iterations are needed before calls
     // are inlined.
     //
     // Default: 10,240
-    uint32 usesBeforeInlining;
+    uint32_t usesBeforeInlining;
 
     // How many actual arguments are accepted on the C stack.
     //
     // Default: 4,096
-    uint32 maxStackArgs;
+    uint32_t maxStackArgs;
 
     // The maximum inlining depth.
     //
     // Default: 3
-    uint32 maxInlineDepth;
+    uint32_t maxInlineDepth;
 
     // The bytecode length limit for small function.
     //
     // The default for this was arrived at empirically via benchmarking.
     // We may want to tune it further after other optimizations have gone
     // in.
     //
     // Default: 100
-    uint32 smallFunctionMaxBytecodeLength;
+    uint32_t smallFunctionMaxBytecodeLength;
 
     // The inlining limit for small functions.
     //
     // This value has been arrived at empirically via benchmarking.
     // We may want to revisit this tuning after other optimizations have
     // gone in.
     //
     // Default: usesBeforeInlining / 4
-    uint32 smallFunctionUsesBeforeInlining;
+    uint32_t smallFunctionUsesBeforeInlining;
 
     // The maximum number of functions to polymorphically inline at a call site.
     //
     // Default: 4
-    uint32 polyInlineMax;
+    uint32_t polyInlineMax;
 
     // The maximum total bytecode size of an inline call site.
     //
     // Default: 800
-    uint32 inlineMaxTotalBytecodeLength;
+    uint32_t inlineMaxTotalBytecodeLength;
 
     // Minimal ratio between the use counts of the caller and the callee to
     // enable inlining of functions.
     //
     // Default: 128
-    uint32 inlineUseCountRatio;
+    uint32_t inlineUseCountRatio;
 
     // Whether functions are compiled immediately.
     //
     // Default: false
     bool eagerCompilation;
 
     // If a function has attempted to make this many calls to
     // functions that are marked "uncompileable", then
     // stop running this function in IonMonkey. (default 512)
-    uint32 slowCallLimit;
+    uint32_t slowCallLimit;
 
     // When caller runs in IM, but callee not, we take a slow path to the interpreter.
     // This has a significant overhead. In order to decrease the number of times this happens,
     // the useCount gets incremented faster to compile this function in IM and use the fastpath.
     //
     // Default: 5
-    uint32 slowCallIncUseCount;
+    uint32_t slowCallIncUseCount;
 
     void setEagerCompilation() {
         eagerCompilation = true;
         usesBeforeCompile = usesBeforeCompileNoJaeger = 0;
 
         // Eagerly inline calls to improve test coverage.
         usesBeforeInlining = 0;
         smallFunctionUsesBeforeInlining = 0;

--- a/js/src/ion/IonAnalysis.cpp
+++ b/js/src/ion/IonAnalysis.cpp
@@ -74,17 +74,17 @@ ion::EliminateDeadResumePointOperands(MI
             if (ins->isUnbox() || ins->isParameter())
                 continue;
 
             // Check if this instruction's result is only used within the
             // current block, and keep track of its last use in a definition
             // (not resume point). This requires the instructions in the block
             // to be numbered, ensured by running this immediately after alias
             // analysis.
-            uint32 maxDefinition = 0;
+            uint32_t maxDefinition = 0;
             for (MUseDefIterator uses(*ins); uses; uses++) {
                 if (uses.def()->block() != *block || uses.def()->isBox() || uses.def()->isPassArg()) {
                     maxDefinition = UINT32_MAX;
                     break;
                 }
                 maxDefinition = Max(maxDefinition, uses.def()->id());
             }
             if (maxDefinition == UINT32_MAX)
@@ -168,25 +168,25 @@ IsPhiObservable(MPhi *phi)
     // which we don't count as actual uses. If the only uses are resume points,
     // then the SSA name is never consumed by the program.
     for (MUseDefIterator iter(phi); iter; iter++) {
         if (!iter.def()->isPhi())
             return true;
     }
 
     // If the Phi is of the |this| value, it must always be observable.
-    uint32 slot = phi->slot();
+    uint32_t slot = phi->slot();
     if (slot == 1)
         return true;
 
     CompileInfo &info = phi->block()->info();
     if (info.fun() && info.hasArguments()) {
         // We do not support arguments object inside inline frames yet.
         JS_ASSERT(!phi->block()->callerResumePoint());
-        uint32 first = info.firstArgSlot();
+        uint32_t first = info.firstArgSlot();
         if (first <= slot && slot - first < info.nargs())
             return true;
     }
     return false;
 }
 
 // Handles cases like:
 //    x is phi(a, x) --> a
@@ -872,35 +872,35 @@ ion::AssertGraphCoherency(MIRGraph &grap
     for (MBasicBlockIterator block(graph.begin()); block != graph.end(); block++) {
         for (size_t i = 0; i < block->numSuccessors(); i++)
             JS_ASSERT(CheckSuccessorImpliesPredecessor(*block, block->getSuccessor(i)));
 
         for (size_t i = 0; i < block->numPredecessors(); i++)
             JS_ASSERT(CheckPredecessorImpliesSuccessor(*block, block->getPredecessor(i)));
 
         for (MInstructionIterator ins = block->begin(); ins != block->end(); ins++) {
-            for (uint32 i = 0; i < ins->numOperands(); i++)
+            for (uint32_t i = 0; i < ins->numOperands(); i++)
                 JS_ASSERT(CheckMarkedAsUse(*ins, ins->getOperand(i)));
         }
     }
 
     AssertReversePostOrder(graph);
 #endif
 }
 
 
 struct BoundsCheckInfo
 {
     MBoundsCheck *check;
-    uint32 validUntil;
+    uint32_t validUntil;
 };
 
-typedef HashMap<uint32,
+typedef HashMap<uint32_t,
                 BoundsCheckInfo,
-                DefaultHasher<uint32>,
+                DefaultHasher<uint32_t>,
                 IonAllocPolicy> BoundsCheckMap;
 
 // Compute a hash for bounds checks which ignores constant offsets in the index.
 static HashNumber
 BoundsCheckHashIgnoreOffset(MBoundsCheck *check)
 {
     SimpleLinearSum indexSum = ExtractLinearSum(check->index());
     uintptr_t index = indexSum.term ? uintptr_t(indexSum.term) : 0;
@@ -950,22 +950,22 @@ ion::ExtractLinearSum(MDefinition *ins)
             SimpleLinearSum lsum = ExtractLinearSum(lhs);
             SimpleLinearSum rsum = ExtractLinearSum(rhs);
 
             if (lsum.term && rsum.term)
                 return SimpleLinearSum(ins, 0);
 
             // Check if this is of the form <SUM> + n, n + <SUM> or <SUM> - n.
             if (ins->isAdd()) {
-                int32 constant;
+                int32_t constant;
                 if (!SafeAdd(lsum.constant, rsum.constant, &constant))
                     return SimpleLinearSum(ins, 0);
                 return SimpleLinearSum(lsum.term ? lsum.term : rsum.term, constant);
             } else if (lsum.term) {
-                int32 constant;
+                int32_t constant;
                 if (!SafeSub(lsum.constant, rsum.constant, &constant))
                     return SimpleLinearSum(ins, 0);
                 return SimpleLinearSum(lsum.term, constant);
             }
         }
     }
 
     return SimpleLinearSum(ins, 0);
@@ -1047,28 +1047,28 @@ TryEliminateBoundsCheck(MBoundsCheck *do
     // Both terms should be NULL or the same definition.
     if (sumA.term != sumB.term)
         return true;
 
     // This bounds check is redundant.
     *eliminated = true;
 
     // Normalize the ranges according to the constant offsets in the two indexes.
-    int32 minimumA, maximumA, minimumB, maximumB;
+    int32_t minimumA, maximumA, minimumB, maximumB;
     if (!SafeAdd(sumA.constant, dominating->minimum(), &minimumA) ||
         !SafeAdd(sumA.constant, dominating->maximum(), &maximumA) ||
         !SafeAdd(sumB.constant, dominated->minimum(), &minimumB) ||
         !SafeAdd(sumB.constant, dominated->maximum(), &maximumB))
     {
         return false;
     }
 
     // Update the dominating check to cover both ranges, denormalizing the
     // result per the constant offset in the index.
-    int32 newMinimum, newMaximum;
+    int32_t newMinimum, newMaximum;
     if (!SafeSub(Min(minimumA, minimumB), sumA.constant, &newMinimum) ||
         !SafeSub(Max(maximumA, maximumB), sumA.constant, &newMaximum))
     {
         return false;
     }
 
     dominating->setMinimum(newMinimum);
     dominating->setMaximum(newMaximum);
@@ -1159,17 +1159,17 @@ ion::EliminateRedundantBoundsChecks(MIRG
         index++;
     }
 
     JS_ASSERT(index == graph.numBlocks());
     return true;
 }
 
 bool
-LinearSum::multiply(int32 scale)
+LinearSum::multiply(int32_t scale)
 {
     for (size_t i = 0; i < terms_.length(); i++) {
         if (!SafeMul(scale, terms_[i].scale, &terms_[i].scale))
             return false;
     }
     return SafeMul(scale, constant_, &constant_);
 }
 
@@ -1179,25 +1179,25 @@ LinearSum::add(const LinearSum &other)
     for (size_t i = 0; i < other.terms_.length(); i++) {
         if (!add(other.terms_[i].term, other.terms_[i].scale))
             return false;
     }
     return add(other.constant_);
 }
 
 bool
-LinearSum::add(MDefinition *term, int32 scale)
+LinearSum::add(MDefinition *term, int32_t scale)
 {
     JS_ASSERT(term);
 
     if (scale == 0)
         return true;
 
     if (term->isConstant()) {
-        int32 constant = term->toConstant()->value().toInt32();
+        int32_t constant = term->toConstant()->value().toInt32();
         if (!SafeMul(constant, scale, &constant))
             return false;
         return add(constant);
     }
 
     for (size_t i = 0; i < terms_.length(); i++) {
         if (term == terms_[i].term) {
             if (!SafeAdd(scale, terms_[i].scale, &terms_[i].scale))
@@ -1210,27 +1210,27 @@ LinearSum::add(MDefinition *term, int32 
         }
     }
 
     terms_.append(LinearTerm(term, scale));
     return true;
 }
 
 bool
-LinearSum::add(int32 constant)
+LinearSum::add(int32_t constant)
 {
     return SafeAdd(constant, constant_, &constant_);
 }
 
 void
 LinearSum::print(Sprinter &sp) const
 {
     for (size_t i = 0; i < terms_.length(); i++) {
-        int32 scale = terms_[i].scale;
-        int32 id = terms_[i].term->id();
+        int32_t scale = terms_[i].scale;
+        int32_t id = terms_[i].term->id();
         JS_ASSERT(scale);
         if (scale > 0) {
             if (i)
                 sp.printf("+");
             if (scale == 1)
                 sp.printf("#%d", id);
             else
                 sp.printf("%d*#%d", scale, id);

--- a/js/src/ion/IonAnalysis.h
+++ b/js/src/ion/IonAnalysis.h
@@ -50,36 +50,36 @@ bool
 EliminateRedundantBoundsChecks(MIRGraph &graph);
 
 class MDefinition;
 
 // Simple linear sum of the form 'n' or 'x + n'.
 struct SimpleLinearSum
 {
     MDefinition *term;
-    int32 constant;
+    int32_t constant;
 
-    SimpleLinearSum(MDefinition *term, int32 constant)
+    SimpleLinearSum(MDefinition *term, int32_t constant)
         : term(term), constant(constant)
     {}
 };
 
 SimpleLinearSum
 ExtractLinearSum(MDefinition *ins);
 
 bool
 ExtractLinearInequality(MTest *test, BranchDirection direction,
                         SimpleLinearSum *plhs, MDefinition **prhs, bool *plessEqual);
 
 struct LinearTerm
 {
     MDefinition *term;
-    int32 scale;
+    int32_t scale;
 
-    LinearTerm(MDefinition *term, int32 scale)
+    LinearTerm(MDefinition *term, int32_t scale)
       : term(term), scale(scale)
     {
     }
 };
 
 // General linear sum of the form 'x1*n1 + x2*n2 + ... + n'
 class LinearSum
 {
@@ -91,29 +91,29 @@ class LinearSum
 
     LinearSum(const LinearSum &other)
       : constant_(other.constant_)
     {
         for (size_t i = 0; i < other.terms_.length(); i++)
             terms_.append(other.terms_[i]);
     }
 
-    bool multiply(int32 scale);
+    bool multiply(int32_t scale);
     bool add(const LinearSum &other);
-    bool add(MDefinition *term, int32 scale);
-    bool add(int32 constant);
+    bool add(MDefinition *term, int32_t scale);
+    bool add(int32_t constant);
 
-    int32 constant() const { return constant_; }
+    int32_t constant() const { return constant_; }
     size_t numTerms() const { return terms_.length(); }
     LinearTerm term(size_t i) const { return terms_[i]; }
 
     void print(Sprinter &sp) const;
 
   private:
     Vector<LinearTerm, 2, IonAllocPolicy> terms_;
-    int32 constant_;
+    int32_t constant_;
 };
 
 } // namespace ion
 } // namespace js
 
 #endif // jsion_ion_analysis_h__
 

--- a/js/src/ion/IonBuilder.cpp
+++ b/js/src/ion/IonBuilder.cpp
@@ -22,17 +22,17 @@
 #endif
 
 using namespace js;
 using namespace js::ion;
 
 using mozilla::DebugOnly;
 
 IonBuilder::IonBuilder(JSContext *cx, TempAllocator *temp, MIRGraph *graph,
-                       TypeOracle *oracle, CompileInfo *info, size_t inliningDepth, uint32 loopDepth)
+                       TypeOracle *oracle, CompileInfo *info, size_t inliningDepth, uint32_t loopDepth)
   : MIRGenerator(cx->compartment, temp, graph, info),
     backgroundCodegen_(NULL),
     recompileInfo(cx->compartment->types.compiledInfo),
     cx(cx),
     loopDepth_(loopDepth),
     callerResumePoint_(NULL),
     callerBuilder_(NULL),
     oracle(oracle),
@@ -70,17 +70,17 @@ void
 IonBuilder::spew(const char *message)
 {
     // Don't call PCToLineNumber in release builds.
 #ifdef DEBUG
     IonSpew(IonSpew_MIR, "%s @ %s:%d", message, script_->filename, PCToLineNumber(script_, pc));
 #endif
 }
 
-static inline int32
+static inline int32_t
 GetJumpOffset(jsbytecode *pc)
 {
     JS_ASSERT(js_CodeSpec[JSOp(*pc)].type() == JOF_JUMP);
     return GET_JUMP_OFFSET(pc);
 }
 
 IonBuilder::CFGState
 IonBuilder::CFGState::If(jsbytecode *join, MBasicBlock *ifFalse)
@@ -143,33 +143,33 @@ IonBuilder::CFGState::LookupSwitch(jsbyt
     state.lookupswitch.breaks = NULL;
     state.lookupswitch.bodies =
         (FixedList<MBasicBlock *> *)GetIonContext()->temp->allocate(sizeof(FixedList<MBasicBlock *>));
     state.lookupswitch.currentBlock = 0;
     return state;
 }
 
 JSFunction *
-IonBuilder::getSingleCallTarget(uint32 argc, jsbytecode *pc)
+IonBuilder::getSingleCallTarget(uint32_t argc, jsbytecode *pc)
 {
     AutoAssertNoGC nogc;
 
     types::StackTypeSet *calleeTypes = oracle->getCallTarget(script().get(nogc), argc, pc);
     if (!calleeTypes)
         return NULL;
 
     RawObject obj = calleeTypes->getSingleton();
     if (!obj || !obj->isFunction())
         return NULL;
 
     return obj->toFunction();
 }
 
 uint32_t
-IonBuilder::getPolyCallTargets(uint32 argc, jsbytecode *pc,
+IonBuilder::getPolyCallTargets(uint32_t argc, jsbytecode *pc,
                                AutoObjectVector &targets, uint32_t maxTargets)
 {
     types::TypeSet *calleeTypes = oracle->getCallTarget(script_, argc, pc);
     if (!calleeTypes)
         return 0;
 
     if (calleeTypes->baseFlags() != 0)
         return 0;
@@ -278,17 +278,17 @@ IonBuilder::build()
 
     if (!graph().addScript(script_))
         return false;
 
     if (!initParameters())
         return false;
 
     // Initialize local variables.
-    for (uint32 i = 0; i < info().nlocals(); i++) {
+    for (uint32_t i = 0; i < info().nlocals(); i++) {
         MConstant *undef = MConstant::New(UndefinedValue());
         current->add(undef);
         current->initSlot(info().localSlot(i), undef);
     }
 
     // Initialize something for the scope chain. We can bail out before the
     // start instruction, but the snapshot is encoded *at* the start
     // instruction, which means generating any code that could load into
@@ -331,17 +331,17 @@ IonBuilder::build()
     //       v1 = MParameter(1)
     //       --   ResumePoint(v2, v3)
     //       v2 = Unbox(v0, INT32)
     //       v3 = Unbox(v1, INT32)
     //
     // So we attach the initial resume point to each parameter, which the type
     // analysis explicitly checks (this is the same mechanism used for
     // effectful operations).
-    for (uint32 i = 0; i < CountArgSlots(info().fun()); i++) {
+    for (uint32_t i = 0; i < CountArgSlots(info().fun()); i++) {
         MInstruction *ins = current->getEntrySlot(i)->toInstruction();
         if (ins->type() == MIRType_Value)
             ins->setResumePoint(current->entryResumePoint());
     }
 
     // Recompile to inline calls if this function is hot.
     insertRecompileCheck();
 
@@ -469,17 +469,17 @@ IonBuilder::buildInline(IonBuilder *call
     for (size_t i = 0; i < nargs; ++i) {
         MDefinition *arg = args.popCopyFront();
         current->initSlot(info().argSlot(i), arg);
     }
 
     IonSpew(IonSpew_Inlining, "Initializing %u local slots", info().nlocals());
 
     // Initialize local variables.
-    for (uint32 i = 0; i < info().nlocals(); i++) {
+    for (uint32_t i = 0; i < info().nlocals(); i++) {
         MConstant *undef = MConstant::New(UndefinedValue());
         current->add(undef);
         current->initSlot(info().localSlot(i), undef);
     }
 
     IonSpew(IonSpew_Inlining, "Inline entry block MResumePoint %p, %u operands",
             (void *) current->entryResumePoint(), current->entryResumePoint()->numOperands());
 
@@ -491,19 +491,19 @@ IonBuilder::buildInline(IonBuilder *call
 
 // Apply Type Inference information to parameters early on, unboxing them if
 // they have a definitive type. The actual guards will be emitted by the code
 // generator, explicitly, as part of the function prologue.
 void
 IonBuilder::rewriteParameters()
 {
     JS_ASSERT(info().scopeChainSlot() == 0);
-    static const uint32 START_SLOT = 1;
-
-    for (uint32 i = START_SLOT; i < CountArgSlots(info().fun()); i++) {
+    static const uint32_t START_SLOT = 1;
+
+    for (uint32_t i = START_SLOT; i < CountArgSlots(info().fun()); i++) {
         MParameter *param = current->getSlot(i)->toParameter();
 
         // Find the original (not cloned) type set for the MParameter, as we
         // will be adding constraints to it.
         types::StackTypeSet *types;
         if (param->index() == MParameter::THIS_SLOT)
             types = oracle->thisTypeSet(script_);
         else
@@ -550,17 +550,17 @@ IonBuilder::initParameters()
     if (!info().fun())
         return true;
 
     MParameter *param = MParameter::New(MParameter::THIS_SLOT,
                                         cloneTypeSet(oracle->thisTypeSet(script_)));
     current->add(param);
     current->initSlot(info().thisSlot(), param);
 
-    for (uint32 i = 0; i < info().nargs(); i++) {
+    for (uint32_t i = 0; i < info().nargs(); i++) {
         param = MParameter::New(i, oracle->parameterTypeSet(script_, i));
         current->add(param);
         current->initSlot(info().argSlot(i), param);
     }
 
     return true;
 }
 
@@ -2208,17 +2208,17 @@ IonBuilder::tableSwitch(JSOp op, jssrcno
             tableswitch->addBlock(caseblock);
 
         pc2 += JUMP_OFFSET_LEN;
     }
 
     // Move defaultcase to the end, to maintain RPO.
     graph().moveBlockToEnd(defaultcase);
 
-    JS_ASSERT(tableswitch->numCases() == (uint32)(high - low + 1));
+    JS_ASSERT(tableswitch->numCases() == (uint32_t)(high - low + 1));
     JS_ASSERT(tableswitch->numSuccessors() > 0);
 
     // Sort the list of blocks that still needs to get processed by pc
     qsort(tableswitch->blocks(), tableswitch->numBlocks(),
           sizeof(MBasicBlock*), CmpSuccessors);
 
     // Create info
     ControlFlowInfo switchinfo(cfgStack_.length(), exitpc);
@@ -2470,18 +2470,18 @@ IonBuilder::jsop_andor(JSOp op)
 
     current = evalRhs;
     return true;
 }
 
 bool
 IonBuilder::jsop_dup2()
 {
-    uint32 lhsSlot = current->stackDepth() - 2;
-    uint32 rhsSlot = current->stackDepth() - 1;
+    uint32_t lhsSlot = current->stackDepth() - 2;
+    uint32_t rhsSlot = current->stackDepth() - 1;
     current->pushSlot(lhsSlot);
     current->pushSlot(rhsSlot);
     return true;
 }
 
 bool
 IonBuilder::jsop_loophead(jsbytecode *pc)
 {
@@ -2813,17 +2813,17 @@ class AutoAccumulateExits
     }
     ~AutoAccumulateExits() {
         graph_.setExitAccumulator(prev_);
     }
 };
 
 
 bool
-IonBuilder::jsop_call_inline(HandleFunction callee, uint32 argc, bool constructing,
+IonBuilder::jsop_call_inline(HandleFunction callee, uint32_t argc, bool constructing,
                              MConstant *constFun, MBasicBlock *bottom,
                              Vector<MDefinition *, 8, IonAllocPolicy> &retvalDefns)
 {
     AssertCanGC();
 
     // Rewrite the stack position containing the function with the constant
     // function definition, before we take the inlineResumePoint
     current->rewriteAtDepth(-((int) argc + 2), constFun);
@@ -2839,17 +2839,17 @@ IonBuilder::jsop_call_inline(HandleFunct
     JS_ASSERT(argc == GET_ARGC(inlineResumePoint->pc()));
 
     // Gather up  the arguments and |this| to the inline function.
     // Note that we leave the callee on the simulated stack for the
     // duration of the call.
     MDefinitionVector argv;
     if (!argv.resizeUninitialized(argc + 1))
         return false;
-    for (int32 i = argc; i >= 0; i--)
+    for (int32_t i = argc; i >= 0; i--)
         argv[i] = current->pop();
 
     // Compilation information is allocated for the duration of the current tempLifoAlloc
     // lifetime.
     RootedScript calleeScript(cx, callee->nonLazyScript());
     CompileInfo *info = cx->tempLifoAlloc().new_<CompileInfo>(calleeScript.get(), callee,
                                                               (jsbytecode *)NULL, constructing,
                                                               SequentialExecution);
@@ -2909,17 +2909,17 @@ IonBuilder::jsop_call_inline(HandleFunct
         if (!bottom->addPredecessorWithoutPhis(exitBlock))
             return false;
     }
     JS_ASSERT(!retvalDefns.empty());
     return true;
 }
 
 bool
-IonBuilder::makeInliningDecision(AutoObjectVector &targets, uint32 argc)
+IonBuilder::makeInliningDecision(AutoObjectVector &targets, uint32_t argc)
 {
     AssertCanGC();
 
     if (inliningDepth >= js_IonOptions.maxInlineDepth)
         return false;
 
     // For "small" functions, we should be more aggressive about inlining.
     // This is based on the following intuition:
@@ -3172,18 +3172,18 @@ IonBuilder::makePolyInlineDispatch(JSCon
     if (!call)
         return NULL;
 
     // Set up the MPrepCall
     MPrepareCall *prepCall = new MPrepareCall;
     fallbackEndBlock->add(prepCall);
 
     // Grab the arguments for the call directly from the current block's stack.
-    for (int32 i = 0; i <= argc; i++) {
-        int32 argno = argc - i;
+    for (int32_t i = 0; i <= argc; i++) {
+        int32_t argno = argc - i;
         MDefinition *argDefn = fallbackEndBlock->pop();
         JS_ASSERT(!argDefn->isPassArg());
         MPassArg *passArg = MPassArg::New(argDefn);
         fallbackEndBlock->add(passArg);
         call->addArg(argno, passArg);
     }
 
     // Insert an MPrepareCall before the first argument.
@@ -3205,32 +3205,32 @@ IonBuilder::makePolyInlineDispatch(JSCon
 
     // Create a new MPolyInlineDispatch containing the getprop and the fallback block
     return MPolyInlineDispatch::New(targetObject, inlinePropTable,
                                     fallbackPrepBlock, fallbackBlock,
                                     fallbackEndBlock);
 }
 
 bool
-IonBuilder::inlineScriptedCall(AutoObjectVector &targets, uint32 argc, bool constructing,
+IonBuilder::inlineScriptedCall(AutoObjectVector &targets, uint32_t argc, bool constructing,
                                types::StackTypeSet *types, types::StackTypeSet *barrier)
 {
 #ifdef DEBUG
-    uint32 origStackDepth = current->stackDepth();
+    uint32_t origStackDepth = current->stackDepth();
 #endif
 
     IonSpew(IonSpew_Inlining, "Inlining %d targets", (int) targets.length());
     JS_ASSERT(targets.length() > 0);
 
     // |top| jumps into the callee subgraph -- save it for later use.
     MBasicBlock *top = current;
 
     // Unwrap all the MPassArgs and replace them with their inputs, and discard the
     // MPassArgs.
-    for (int32 i = argc; i >= 0; i--) {
+    for (int32_t i = argc; i >= 0; i--) {
         // Unwrap each MPassArg, replacing it with its contents.
         int argSlotDepth = -((int) i + 1);
         MPassArg *passArg = top->peek(argSlotDepth)->toPassArg();
         MBasicBlock *block = passArg->block();
         MDefinition *wrapped = passArg->getArgument();
         passArg->replaceAllUsesWith(wrapped);
         top->rewriteAtDepth(argSlotDepth, wrapped);
         block->discard(passArg);
@@ -3616,17 +3616,17 @@ IonBuilder::createThis(HandleFunction ta
     // If the prototype could not be hardcoded, emit a GETPROP.
     if (!createThis)
         createThis = createThisScripted(callee);
 
     return createThis;
 }
 
 bool
-IonBuilder::jsop_funcall(uint32 argc)
+IonBuilder::jsop_funcall(uint32_t argc)
 {
     // Stack for JSOP_FUNCALL:
     // 1:      MPassArg(arg0)
     // ...
     // argc:   MPassArg(argN)
     // argc+1: MPassArg(JSFunction *), the 'f' in |f.call()|, in |this| position.
     // argc+2: The native 'call' function.
 
@@ -3665,17 +3665,17 @@ IonBuilder::jsop_funcall(uint32 argc)
         argc -= 1; 
     }
 
     // Call without inlining.
     return makeCall(target, argc, false);
 }
 
 bool
-IonBuilder::jsop_funapply(uint32 argc)
+IonBuilder::jsop_funapply(uint32_t argc)
 {
     RootedFunction native(cx, getSingleCallTarget(argc, pc));
     if (argc != 2)
         return makeCall(native, argc, false);
 
     // Disable compilation if the second argument to |apply| cannot be guaranteed
     // to be either definitely |arguments| or definitely not |arguments|.
     types::StackTypeSet *argObjTypes = oracle->getCallArg(script_, argc, 2, pc);
@@ -3735,17 +3735,17 @@ IonBuilder::jsop_funapply(uint32 argc)
         return false;
 
     types::StackTypeSet *barrier;
     types::StackTypeSet *types = oracle->returnTypeSet(script_, pc, &barrier);
     return pushTypeBarrier(apply, types, barrier);
 }
 
 bool
-IonBuilder::jsop_call(uint32 argc, bool constructing)
+IonBuilder::jsop_call(uint32_t argc, bool constructing)
 {
     AssertCanGC();
 
     // Acquire known call target if existent.
     AutoObjectVector targets(cx);
     uint32_t numTargets = getPolyCallTargets(argc, pc, targets, 4);
     types::StackTypeSet *barrier;
     types::StackTypeSet *types = oracle->returnTypeSet(script_, pc, &barrier);
@@ -3772,27 +3772,27 @@ IonBuilder::jsop_call(uint32 argc, bool 
     RootedFunction target(cx, NULL);
     if (numTargets == 1)
         target = targets[0]->toFunction();
 
     return makeCallBarrier(target, argc, constructing, types, barrier);
 }
 
 MCall *
-IonBuilder::makeCallHelper(HandleFunction target, uint32 argc, bool constructing)
+IonBuilder::makeCallHelper(HandleFunction target, uint32_t argc, bool constructing)
 {
     // This function may be called with mutated stack.
     // Querying TI for popped types is invalid.
 
-    uint32 targetArgs = argc;
+    uint32_t targetArgs = argc;
 
     // Collect number of missing arguments provided that the target is
     // scripted. Native functions are passed an explicit 'argc' parameter.
     if (target && !target->isNative())
-        targetArgs = Max<uint32>(target->nargs, argc);
+        targetArgs = Max<uint32_t>(target->nargs, argc);
 
     MCall *call = MCall::New(target, targetArgs + 1, argc, constructing);
     if (!call)
         return NULL;
 
     // Explicitly pad any missing arguments with |undefined|.
     // This permits skipping the argumentsRectifier.
     for (int i = targetArgs; i > (int)argc; i--) {
@@ -3801,17 +3801,17 @@ IonBuilder::makeCallHelper(HandleFunctio
         current->add(undef);
         MPassArg *pass = MPassArg::New(undef);
         current->add(pass);
         call->addArg(i, pass);
     }
 
     // Add explicit arguments.
     // Bytecode order: Function, This, Arg0, Arg1, ..., ArgN, Call.
-    for (int32 i = argc; i > 0; i--)
+    for (int32_t i = argc; i > 0; i--)
         call->addArg(i, current->pop()->toPassArg());
 
     // Place an MPrepareCall before the first passed argument, before we
     // potentially perform rearrangement.
     MPrepareCall *start = new MPrepareCall;
     MPassArg *firstArg = current->peek(-1)->toPassArg();
     firstArg->block()->insertBefore(firstArg, start);
     call->initPrepareCall(start);
@@ -3842,34 +3842,34 @@ IonBuilder::makeCallHelper(HandleFunctio
         call->setDOMFunction();
     call->initFunction(fun);
 
     current->add(call);
     return call;
 }
 
 bool
-IonBuilder::makeCallBarrier(HandleFunction target, uint32 argc,
+IonBuilder::makeCallBarrier(HandleFunction target, uint32_t argc,
                             bool constructing,
                             types::StackTypeSet *types,
                             types::StackTypeSet *barrier)
 {
     MCall *call = makeCallHelper(target, argc, constructing);
     if (!call)
         return false;
 
     current->push(call);
     if (!resumeAfter(call))
         return false;
 
     return pushTypeBarrier(call, types, barrier);
 }
 
 bool
-IonBuilder::makeCall(HandleFunction target, uint32 argc, bool constructing)
+IonBuilder::makeCall(HandleFunction target, uint32_t argc, bool constructing)
 {
     types::StackTypeSet *barrier;
     types::StackTypeSet *types = oracle->returnTypeSet(script_, pc, &barrier);
     return makeCallBarrier(target, argc, constructing, types, barrier);
 }
 
 bool
 IonBuilder::jsop_compare(JSOp op)
@@ -3884,17 +3884,17 @@ IonBuilder::jsop_compare(JSOp op)
     ins->infer(cx, oracle->binaryTypes(script_, pc));
 
     if (ins->isEffectful() && !resumeAfter(ins))
         return false;
     return true;
 }
 
 JSObject *
-IonBuilder::getNewArrayTemplateObject(uint32 count)
+IonBuilder::getNewArrayTemplateObject(uint32_t count)
 {
     RootedObject templateObject(cx, NewDenseUnallocatedArray(cx, count));
     if (!templateObject)
         return NULL;
 
     RootedScript script(cx, script_);
     if (types::UseNewTypeForInitializer(cx, script, pc, JSProto_Array)) {
         if (!JSObject::setSingletonType(cx, templateObject))
@@ -3905,17 +3905,17 @@ IonBuilder::getNewArrayTemplateObject(ui
             return NULL;
         templateObject->setType(type);
     }
 
     return templateObject;
 }
 
 bool
-IonBuilder::jsop_newarray(uint32 count)
+IonBuilder::jsop_newarray(uint32_t count)
 {
     JS_ASSERT(script_->compileAndGo);
 
     JSObject *templateObject = getNewArrayTemplateObject(count);
     if (!templateObject)
         return false;
 
     MNewArray *ins = new MNewArray(count, templateObject, MNewArray::NewArray_Allocating);
@@ -4059,27 +4059,27 @@ IonBuilder::jsop_initprop(HandleProperty
 
         current->add(store);
         return resumeAfter(store);
     }
 
     MSlots *slots = MSlots::New(obj);
     current->add(slots);
 
-    uint32 slot = templateObject->dynamicSlotIndex(shape->slot());
+    uint32_t slot = templateObject->dynamicSlotIndex(shape->slot());
     MStoreSlot *store = MStoreSlot::New(slots, slot, value);
     if (needsBarrier)
         store->setNeedsBarrier();
 
     current->add(store);
     return resumeAfter(store);
 }
 
 MBasicBlock *
-IonBuilder::addBlock(MBasicBlock *block, uint32 loopDepth)
+IonBuilder::addBlock(MBasicBlock *block, uint32_t loopDepth)
 {
     if (!block)
         return NULL;
     graph().addBlock(block);
     block->setLoopDepth(loopDepth);
     return block;
 }
 
@@ -4104,17 +4104,17 @@ IonBuilder::newBlockAfter(MBasicBlock *a
     MBasicBlock *block = MBasicBlock::New(graph(), info(), predecessor, pc, MBasicBlock::NORMAL);
     if (!block)
         return NULL;
     graph().insertBlockAfter(at, block);
     return block;
 }
 
 MBasicBlock *
-IonBuilder::newBlock(MBasicBlock *predecessor, jsbytecode *pc, uint32 loopDepth)
+IonBuilder::newBlock(MBasicBlock *predecessor, jsbytecode *pc, uint32_t loopDepth)
 {
     MBasicBlock *block = MBasicBlock::New(graph(), info(), predecessor, pc, MBasicBlock::NORMAL);
     return addBlock(block, loopDepth);
 }
 
 MBasicBlock *
 IonBuilder::newOsrPreheader(MBasicBlock *predecessor, jsbytecode *loopEntry)
 {
@@ -4129,57 +4129,57 @@ IonBuilder::newOsrPreheader(MBasicBlock 
     if (!osrBlock || !preheader)
         return NULL;
 
     MOsrEntry *entry = MOsrEntry::New();
     osrBlock->add(entry);
 
     // Initialize |scopeChain|.
     {
-        uint32 slot = info().scopeChainSlot();
+        uint32_t slot = info().scopeChainSlot();
 
         MOsrScopeChain *scopev = MOsrScopeChain::New(entry);
         osrBlock->add(scopev);
         osrBlock->initSlot(slot, scopev);
     }
 
     if (info().fun()) {
         // Initialize |this| parameter.
-        uint32 slot = info().thisSlot();
+        uint32_t slot = info().thisSlot();
         ptrdiff_t offset = StackFrame::offsetOfThis(info().fun());
 
         MOsrValue *thisv = MOsrValue::New(entry, offset);
         osrBlock->add(thisv);
         osrBlock->initSlot(slot, thisv);
 
         // Initialize arguments.
-        for (uint32 i = 0; i < info().nargs(); i++) {
-            uint32 slot = info().argSlot(i);
+        for (uint32_t i = 0; i < info().nargs(); i++) {
+            uint32_t slot = info().argSlot(i);
             ptrdiff_t offset = StackFrame::offsetOfFormalArg(info().fun(), i);
 
             MOsrValue *osrv = MOsrValue::New(entry, offset);
             osrBlock->add(osrv);
             osrBlock->initSlot(slot, osrv);
         }
     }
 
     // Initialize locals.
-    for (uint32 i = 0; i < info().nlocals(); i++) {
-        uint32 slot = info().localSlot(i);
+    for (uint32_t i = 0; i < info().nlocals(); i++) {
+        uint32_t slot = info().localSlot(i);
         ptrdiff_t offset = StackFrame::offsetOfFixed(i);
 
         MOsrValue *osrv = MOsrValue::New(entry, offset);
         osrBlock->add(osrv);
         osrBlock->initSlot(slot, osrv);
     }
 
     // Initialize stack.
-    uint32 numSlots = preheader->stackDepth() - CountArgSlots(info().fun()) - info().nlocals();
-    for (uint32 i = 0; i < numSlots; i++) {
-        uint32 slot = info().stackSlot(i);
+    uint32_t numSlots = preheader->stackDepth() - CountArgSlots(info().fun()) - info().nlocals();
+    for (uint32_t i = 0; i < numSlots; i++) {
+        uint32_t slot = info().stackSlot(i);
         ptrdiff_t offset = StackFrame::offsetOfFixed(info().nlocals() + i);
 
         MOsrValue *osrv = MOsrValue::New(entry, offset);
         osrBlock->add(osrv);
         osrBlock->initSlot(slot, osrv);
     }
 
     // Create an MStart to hold the first valid MResumePoint.
@@ -4204,24 +4204,24 @@ IonBuilder::newOsrPreheader(MBasicBlock 
     JS_ASSERT(info().scopeChainSlot() == 0);
     JS_ASSERT(osrBlock->scopeChain()->type() == MIRType_Object);
 
     Vector<MIRType> slotTypes(cx);
     if (!slotTypes.growByUninitialized(osrBlock->stackDepth()))
         return NULL;
 
     // Fill slotTypes with the types of the predecessor block.
-    for (uint32 i = 0; i < osrBlock->stackDepth(); i++)
+    for (uint32_t i = 0; i < osrBlock->stackDepth(); i++)
         slotTypes[i] = MIRType_Value;
 
     // Update slotTypes for slots that may have a different type at this join point.
     if (!oracle->getOsrTypes(loopEntry, slotTypes))
         return NULL;
 
-    for (uint32 i = 1; i < osrBlock->stackDepth(); i++) {
+    for (uint32_t i = 1; i < osrBlock->stackDepth(); i++) {
         // Unbox the MOsrValue if it is known to be unboxable.
         switch (slotTypes[i]) {
           case MIRType_Boolean:
           case MIRType_Int32:
           case MIRType_Double:
           case MIRType_String:
           case MIRType_Object:
           {
@@ -6290,32 +6290,32 @@ IonBuilder::jsop_lambda(JSFunction *fun)
     MLambda *ins = MLambda::New(current->scopeChain(), fun);
     current->add(ins);
     current->push(ins);
 
     return resumeAfter(ins);
 }
 
 bool
-IonBuilder::jsop_deflocalfun(uint32 local, JSFunction *fun)
+IonBuilder::jsop_deflocalfun(uint32_t local, JSFunction *fun)
 {
     JS_ASSERT(script_->analysis()->usesScopeChain());
 
     MLambda *ins = MLambda::New(current->scopeChain(), fun);
     current->add(ins);
     current->push(ins);
 
     current->setLocal(local);
     current->pop();
 
     return resumeAfter(ins);
 }
 
 bool
-IonBuilder::jsop_defvar(uint32 index)
+IonBuilder::jsop_defvar(uint32_t index)
 {
     JS_ASSERT(JSOp(*pc) == JSOP_DEFVAR || JSOp(*pc) == JSOP_DEFCONST);
 
     PropertyName *name = script_->getName(index);
 
     // Bake in attrs.
     unsigned attrs = JSPROP_ENUMERATE | JSPROP_PERMANENT;
     if (JSOp(*pc) == JSOP_DEFCONST)
@@ -6383,17 +6383,17 @@ IonBuilder::jsop_toid()
 
     current->add(ins);
     current->push(ins);
 
     return resumeAfter(ins);
 }
 
 bool
-IonBuilder::jsop_iter(uint8 flags)
+IonBuilder::jsop_iter(uint8_t flags)
 {
     MDefinition *obj = current->pop();
     MInstruction *ins = MIteratorStart::New(obj, flags);
 
     if (!iterators_.append(ins))
         return false;
 
     current->add(ins);

--- a/js/src/ion/IonBuilder.h
+++ b/js/src/ion/IonBuilder.h
@@ -36,22 +36,22 @@ class IonBuilder : public MIRGenerator
 
         DeferredEdge(MBasicBlock *block, DeferredEdge *next)
           : block(block), next(next)
         { }
     };
 
     struct ControlFlowInfo {
         // Entry in the cfgStack.
-        uint32 cfgEntry;
+        uint32_t cfgEntry;
 
         // Label that continues go to.
         jsbytecode *continuepc;
 
-        ControlFlowInfo(uint32 cfgEntry, jsbytecode *continuepc)
+        ControlFlowInfo(uint32_t cfgEntry, jsbytecode *continuepc)
           : cfgEntry(cfgEntry),
             continuepc(continuepc)
         { }
     };
 
     // To avoid recursion, the bytecode analyzer uses a stack where each entry
     // is a small state machine. As we encounter branches or jumps in the
     // bytecode, we push information about the edges on the stack so that the
@@ -113,31 +113,31 @@ class IonBuilder : public MIRGenerator
 
                 // Deferred break and continue targets.
                 DeferredEdge *breaks;
 
                 // MIR instruction
                 MTableSwitch *ins;
 
                 // The number of current successor that get mapped into a block. 
-                uint32 currentBlock;
+                uint32_t currentBlock;
 
             } tableswitch;
             struct {
                 // pc immediately after the switch.
                 jsbytecode *exitpc;
 
                 // Deferred break and continue targets.
                 DeferredEdge *breaks;
 
                 // Vector of body blocks to process
                 FixedList<MBasicBlock *> *bodies;
 
                 // The number of current successor that get mapped into a block. 
-                uint32 currentBlock;
+                uint32_t currentBlock;
             } lookupswitch;
         };
 
         inline bool isLoop() const {
             switch (state) {
               case DO_WHILE_LOOP_COND:
               case DO_WHILE_LOOP_BODY:
               case WHILE_LOOP_COND:
@@ -157,39 +157,39 @@ class IonBuilder : public MIRGenerator
         static CFGState TableSwitch(jsbytecode *exitpc, MTableSwitch *ins);
         static CFGState LookupSwitch(jsbytecode *exitpc);
     };
 
     static int CmpSuccessors(const void *a, const void *b);
 
   public:
     IonBuilder(JSContext *cx, TempAllocator *temp, MIRGraph *graph,
-               TypeOracle *oracle, CompileInfo *info, size_t inliningDepth = 0, uint32 loopDepth = 0);
+               TypeOracle *oracle, CompileInfo *info, size_t inliningDepth = 0, uint32_t loopDepth = 0);
 
     bool build();
     bool buildInline(IonBuilder *callerBuilder, MResumePoint *callerResumePoint,
                      MDefinition *thisDefn, MDefinitionVector &args);
 
   private:
     bool traverseBytecode();
     ControlStatus snoopControlFlow(JSOp op);
     void markPhiBytecodeUses(jsbytecode *pc);
     bool processIterators();
     bool inspectOpcode(JSOp op);
-    uint32 readIndex(jsbytecode *pc);
+    uint32_t readIndex(jsbytecode *pc);
     JSAtom *readAtom(jsbytecode *pc);
     bool abort(const char *message, ...);
     void spew(const char *message);
 
     static bool inliningEnabled() {
         return js_IonOptions.inlining;
     }
 
-    JSFunction *getSingleCallTarget(uint32 argc, jsbytecode *pc);
-    unsigned getPolyCallTargets(uint32 argc, jsbytecode *pc,
+    JSFunction *getSingleCallTarget(uint32_t argc, jsbytecode *pc);
+    unsigned getPolyCallTargets(uint32_t argc, jsbytecode *pc,
                                 AutoObjectVector &targets, uint32_t maxTargets);
     bool canInlineTarget(JSFunction *target);
 
     void popCfgStack();
     bool processDeferredContinues(CFGState &state);
     ControlStatus processControlEnd();
     ControlStatus processCfgStack();
     ControlStatus processCfgEntry(CFGState &state);
@@ -213,19 +213,19 @@ class IonBuilder : public MIRGenerator
     ControlStatus processThrow();
     ControlStatus processContinue(JSOp op, jssrcnote *sn);
     ControlStatus processBreak(JSOp op, jssrcnote *sn);
     ControlStatus maybeLoop(JSOp op, jssrcnote *sn);
     bool pushLoop(CFGState::State state, jsbytecode *stopAt, MBasicBlock *entry,
                   jsbytecode *bodyStart, jsbytecode *bodyEnd, jsbytecode *exitpc,
                   jsbytecode *continuepc = NULL);
 
-    MBasicBlock *addBlock(MBasicBlock *block, uint32 loopDepth);
+    MBasicBlock *addBlock(MBasicBlock *block, uint32_t loopDepth);
     MBasicBlock *newBlock(MBasicBlock *predecessor, jsbytecode *pc);
-    MBasicBlock *newBlock(MBasicBlock *predecessor, jsbytecode *pc, uint32 loopDepth);
+    MBasicBlock *newBlock(MBasicBlock *predecessor, jsbytecode *pc, uint32_t loopDepth);
     MBasicBlock *newBlock(MBasicBlock *predecessor, jsbytecode *pc, MResumePoint *priorResumePoint);
     MBasicBlock *newBlockAfter(MBasicBlock *at, MBasicBlock *predecessor, jsbytecode *pc);
     MBasicBlock *newOsrPreheader(MBasicBlock *header, jsbytecode *loopEntry);
     MBasicBlock *newPendingLoopHeader(MBasicBlock *predecessor, jsbytecode *pc);
     MBasicBlock *newBlock(jsbytecode *pc) {
         return newBlock(NULL, pc);
     }
     MBasicBlock *newBlockAfter(MBasicBlock *at, jsbytecode *pc) {
@@ -271,24 +271,24 @@ class IonBuilder : public MIRGenerator
     JSObject *getSingletonPrototype(JSFunction *target);
 
     MDefinition *createThisNative();
     MDefinition *createThisScripted(MDefinition *callee);
     MDefinition *createThisScriptedSingleton(HandleFunction target, HandleObject proto, MDefinition *callee);
     MDefinition *createThis(HandleFunction target, MDefinition *callee);
     MInstruction *createCallObject(MDefinition *callee, MDefinition *scopeObj);
 
-    bool makeCall(HandleFunction target, uint32 argc, bool constructing);
+    bool makeCall(HandleFunction target, uint32_t argc, bool constructing);
 
     MDefinition *walkScopeChain(unsigned hops);
 
     MInstruction *addBoundsCheck(MDefinition *index, MDefinition *length);
     MInstruction *addShapeGuard(MDefinition *obj, const Shape *shape, BailoutKind bailoutKind);
 
-    JSObject *getNewArrayTemplateObject(uint32 count);
+    JSObject *getNewArrayTemplateObject(uint32_t count);
 
     bool invalidatedIdempotentCache();
 
     bool loadSlot(MDefinition *obj, Shape *shape, MIRType rvalType);
     bool storeSlot(MDefinition *obj, Shape *shape, MDefinition *value, bool needsBarrier);
 
     // jsop_getprop() helpers.
     bool getPropTryArgumentsLength(bool *emitted);
@@ -307,21 +307,21 @@ class IonBuilder : public MIRGenerator
 
     bool jsop_add(MDefinition *left, MDefinition *right);
     bool jsop_bitnot();
     bool jsop_bitop(JSOp op);
     bool jsop_binary(JSOp op);
     bool jsop_binary(JSOp op, MDefinition *left, MDefinition *right);
     bool jsop_pos();
     bool jsop_neg();
-    bool jsop_defvar(uint32 index);
+    bool jsop_defvar(uint32_t index);
     bool jsop_notearg();
-    bool jsop_funcall(uint32 argc);
-    bool jsop_funapply(uint32 argc);
-    bool jsop_call(uint32 argc, bool constructing);
+    bool jsop_funcall(uint32_t argc);
+    bool jsop_funapply(uint32_t argc);
+    bool jsop_call(uint32_t argc, bool constructing);
     bool jsop_ifeq(JSOp op);
     bool jsop_andor(JSOp op);
     bool jsop_dup2();
     bool jsop_loophead(jsbytecode *pc);
     bool jsop_compare(JSOp op);
     bool jsop_getgname(HandlePropertyName name);
     bool jsop_setgname(HandlePropertyName name);
     bool jsop_getname(HandlePropertyName name);
@@ -339,29 +339,29 @@ class IonBuilder : public MIRGenerator
     bool jsop_arguments();
     bool jsop_arguments_length();
     bool jsop_arguments_getelem();
     bool jsop_arguments_setelem();
     bool jsop_not();
     bool jsop_getprop(HandlePropertyName name);
     bool jsop_setprop(HandlePropertyName name);
     bool jsop_delprop(HandlePropertyName name);
-    bool jsop_newarray(uint32 count);
+    bool jsop_newarray(uint32_t count);
     bool jsop_newobject(HandleObject baseObj);
     bool jsop_initelem();
     bool jsop_initelem_dense();
     bool jsop_initprop(HandlePropertyName name);
     bool jsop_regexp(RegExpObject *reobj);
     bool jsop_object(JSObject *obj);
     bool jsop_lambda(JSFunction *fun);
-    bool jsop_deflocalfun(uint32 local, JSFunction *fun);
+    bool jsop_deflocalfun(uint32_t local, JSFunction *fun);
     bool jsop_this();
     bool jsop_typeof();
     bool jsop_toid();
-    bool jsop_iter(uint8 flags);
+    bool jsop_iter(uint8_t flags);
     bool jsop_iternext();
     bool jsop_itermore();
     bool jsop_iterend();
     bool jsop_in();
     bool jsop_in_dense();
     bool jsop_instanceof();
     bool jsop_getaliasedvar(ScopeCoordinate sc);
     bool jsop_setaliasedvar(ScopeCoordinate sc);
@@ -371,60 +371,60 @@ class IonBuilder : public MIRGenerator
     enum InliningStatus
     {
         InliningStatus_Error,
         InliningStatus_NotInlined,
         InliningStatus_Inlined
     };
 
     // Inlining helpers.
-    bool discardCallArgs(uint32 argc, MDefinitionVector &argv, MBasicBlock *bb);
-    bool discardCall(uint32 argc, MDefinitionVector &argv, MBasicBlock *bb);
+    bool discardCallArgs(uint32_t argc, MDefinitionVector &argv, MBasicBlock *bb);
+    bool discardCall(uint32_t argc, MDefinitionVector &argv, MBasicBlock *bb);
     types::StackTypeSet *getInlineReturnTypeSet();
     MIRType getInlineReturnType();
-    types::StackTypeSet *getInlineArgTypeSet(uint32 argc, uint32 arg);
-    MIRType getInlineArgType(uint32 argc, uint32 arg);
+    types::StackTypeSet *getInlineArgTypeSet(uint32_t argc, uint32_t arg);
+    MIRType getInlineArgType(uint32_t argc, uint32_t arg);
 
     // Array natives.
-    InliningStatus inlineArray(uint32 argc, bool constructing);
-    InliningStatus inlineArrayPopShift(MArrayPopShift::Mode mode, uint32 argc, bool constructing);
-    InliningStatus inlineArrayPush(uint32 argc, bool constructing);
-    InliningStatus inlineArrayConcat(uint32 argc, bool constructing);
+    InliningStatus inlineArray(uint32_t argc, bool constructing);
+    InliningStatus inlineArrayPopShift(MArrayPopShift::Mode mode, uint32_t argc, bool constructing);
+    InliningStatus inlineArrayPush(uint32_t argc, bool constructing);
+    InliningStatus inlineArrayConcat(uint32_t argc, bool constructing);
 
     // Math natives.
-    InliningStatus inlineMathAbs(uint32 argc, bool constructing);
-    InliningStatus inlineMathFloor(uint32 argc, bool constructing);
-    InliningStatus inlineMathRound(uint32 argc, bool constructing);
-    InliningStatus inlineMathSqrt(uint32 argc, bool constructing);
-    InliningStatus inlineMathMinMax(bool max, uint32 argc, bool constructing);
-    InliningStatus inlineMathPow(uint32 argc, bool constructing);
-    InliningStatus inlineMathRandom(uint32 argc, bool constructing);
-    InliningStatus inlineMathFunction(MMathFunction::Function function, uint32 argc,
+    InliningStatus inlineMathAbs(uint32_t argc, bool constructing);
+    InliningStatus inlineMathFloor(uint32_t argc, bool constructing);
+    InliningStatus inlineMathRound(uint32_t argc, bool constructing);
+    InliningStatus inlineMathSqrt(uint32_t argc, bool constructing);
+    InliningStatus inlineMathMinMax(bool max, uint32_t argc, bool constructing);
+    InliningStatus inlineMathPow(uint32_t argc, bool constructing);
+    InliningStatus inlineMathRandom(uint32_t argc, bool constructing);
+    InliningStatus inlineMathFunction(MMathFunction::Function function, uint32_t argc,
                                       bool constructing);
 
     // String natives.
-    InliningStatus inlineStringObject(uint32 argc, bool constructing);
-    InliningStatus inlineStrCharCodeAt(uint32 argc, bool constructing);
-    InliningStatus inlineStrFromCharCode(uint32 argc, bool constructing);
-    InliningStatus inlineStrCharAt(uint32 argc, bool constructing);
+    InliningStatus inlineStringObject(uint32_t argc, bool constructing);
+    InliningStatus inlineStrCharCodeAt(uint32_t argc, bool constructing);
+    InliningStatus inlineStrFromCharCode(uint32_t argc, bool constructing);
+    InliningStatus inlineStrCharAt(uint32_t argc, bool constructing);
 
     // RegExp natives.
-    InliningStatus inlineRegExpTest(uint32 argc, bool constructing);
+    InliningStatus inlineRegExpTest(uint32_t argc, bool constructing);
 
-    InliningStatus inlineNativeCall(JSNative native, uint32 argc, bool constructing);
+    InliningStatus inlineNativeCall(JSNative native, uint32_t argc, bool constructing);
 
-    bool jsop_call_inline(HandleFunction callee, uint32 argc, bool constructing,
+    bool jsop_call_inline(HandleFunction callee, uint32_t argc, bool constructing,
                           MConstant *constFun, MBasicBlock *bottom,
                           Vector<MDefinition *, 8, IonAllocPolicy> &retvalDefns);
-    bool inlineScriptedCall(AutoObjectVector &targets, uint32 argc, bool constructing,
+    bool inlineScriptedCall(AutoObjectVector &targets, uint32_t argc, bool constructing,
                             types::StackTypeSet *types, types::StackTypeSet *barrier);
-    bool makeInliningDecision(AutoObjectVector &targets, uint32 argc);
+    bool makeInliningDecision(AutoObjectVector &targets, uint32_t argc);
 
-    MCall *makeCallHelper(HandleFunction target, uint32 argc, bool constructing);
-    bool makeCallBarrier(HandleFunction target, uint32 argc, bool constructing,
+    MCall *makeCallHelper(HandleFunction target, uint32_t argc, bool constructing);
+    bool makeCallBarrier(HandleFunction target, uint32_t argc, bool constructing,
                          types::StackTypeSet *types, types::StackTypeSet *barrier);
 
     inline bool TestCommonPropFunc(JSContext *cx, types::StackTypeSet *types,
                                    HandleId id, JSFunction **funcp,
                                    bool isGetter, bool *isDOM,
                                    MDefinition **guardOut);
 
     bool annotateGetPropertyCache(JSContext *cx, MDefinition *obj, MGetPropertyCache *getPropCache,
@@ -460,17 +460,17 @@ class IonBuilder : public MIRGenerator
     CodeGenerator *backgroundCodegen() const { return backgroundCodegen_; }
     void setBackgroundCodegen(CodeGenerator *codegen) { backgroundCodegen_ = codegen; }
 
   private:
     JSContext *cx;
 
     jsbytecode *pc;
     MBasicBlock *current;
-    uint32 loopDepth_;
+    uint32_t loopDepth_;
 
     /* Information used for inline-call builders. */
     MResumePoint *callerResumePoint_;
     jsbytecode *callerPC() {
         return callerResumePoint_ ? callerResumePoint_->pc() : NULL;
     }
     IonBuilder *callerBuilder_;
 

--- a/js/src/ion/IonCaches.cpp
+++ b/js/src/ion/IonCaches.cpp
@@ -465,17 +465,17 @@ struct GetNativePropertyStub
         Register argUintNReg     = regSet.takeGeneral();
         Register argVpReg        = regSet.takeGeneral();
 
         // Shape has a getter function.
         bool callNative = IsCacheableGetPropCallNative(obj, holder, shape);
         JS_ASSERT_IF(!callNative, IsCacheableGetPropCallPropertyOp(obj, holder, shape));
 
         // TODO: ensure stack is aligned?
-        DebugOnly<uint32> initialStack = masm.framePushed();
+        DebugOnly<uint32_t> initialStack = masm.framePushed();
 
         Label success, exception;
 
         // Push the IonCode pointer for the stub we're generating.
         // WARNING:
         // WARNING: If IonCode ever becomes relocatable, the following code is incorrect.
         // WARNING: Note that we're not marking the pointer being pushed as an ImmGCPtr.
         // WARNING: This is not a marking issue since the stub IonCode won't be collected
@@ -1014,17 +1014,17 @@ IonCacheSetProperty::attachSetterCall(JS
     Register scratchReg     = regSet.takeGeneral();
     Register argJSContextReg = regSet.takeGeneral();
     Register argObjReg       = regSet.takeGeneral();
     Register argIdReg        = regSet.takeGeneral();
     Register argStrictReg    = regSet.takeGeneral();
     Register argVpReg        = regSet.takeGeneral();
 
     // Ensure stack is aligned.
-    DebugOnly<uint32> initialStack = masm.framePushed();
+    DebugOnly<uint32_t> initialStack = masm.framePushed();
 
     Label success, exception;
 
     // Push the IonCode pointer for the stub we're generating.
     // WARNING:
     // WARNING: If IonCode ever becomes relocatable, the following code is incorrect.
     // WARNING: Note that we're not marking the pointer being pushed as an ImmGCPtr.
     // WARNING: This is not a marking issue since the stub IonCode won't be collected

--- a/js/src/ion/IonCaches.h
+++ b/js/src/ion/IonCaches.h
@@ -167,19 +167,19 @@ class IonCache
     
     // Reset the cache around garbage collection.
     void reset();
 
     CodeLocationJump lastJump() const { return lastJump_; }
     CodeLocationLabel cacheLabel() const { return cacheLabel_; }
 
     CodeLocationLabel rejoinLabel() const {
-        uint8 *ptr = initialJump_.raw();
+        uint8_t *ptr = initialJump_.raw();
 #ifdef JS_CPU_ARM
-        uint32 i = 0;
+        uint32_t i = 0;
         while (i < REJOIN_LABEL_OFFSET)
             ptr = Assembler::nextInstruction(ptr, &i);
 #endif
         return CodeLocationLabel(ptr);
     }
 
     bool pure() {
         return pure_;

--- a/js/src/ion/IonCode.h
+++ b/js/src/ion/IonCode.h
@@ -21,65 +21,65 @@ namespace JSC {
 struct JSScript;
 
 namespace js {
 namespace ion {
 
 // The maximum size of any buffer associated with an assembler or code object.
 // This is chosen to not overflow a signed integer, leaving room for an extra
 // bit on offsets.
-static const uint32 MAX_BUFFER_SIZE = (1 << 30) - 1;
+static const uint32_t MAX_BUFFER_SIZE = (1 << 30) - 1;
 
 // Maximum number of scripted arg and stack slots.
-static const uint32 SNAPSHOT_MAX_NARGS = 127;
-static const uint32 SNAPSHOT_MAX_STACK = 127;
+static const uint32_t SNAPSHOT_MAX_NARGS = 127;
+static const uint32_t SNAPSHOT_MAX_STACK = 127;
 
 class MacroAssembler;
 class CodeOffsetLabel;
 
 class IonCode : public gc::Cell
 {
   protected:
-    uint8 *code_;
+    uint8_t *code_;
     JSC::ExecutablePool *pool_;
-    uint32 bufferSize_;             // Total buffer size.
-    uint32 insnSize_;               // Instruction stream size.
-    uint32 dataSize_;               // Size of the read-only data area.
-    uint32 jumpRelocTableBytes_;    // Size of the jump relocation table.
-    uint32 dataRelocTableBytes_;    // Size of the data relocation table.
+    uint32_t bufferSize_;             // Total buffer size.
+    uint32_t insnSize_;               // Instruction stream size.
+    uint32_t dataSize_;               // Size of the read-only data area.
+    uint32_t jumpRelocTableBytes_;    // Size of the jump relocation table.
+    uint32_t dataRelocTableBytes_;    // Size of the data relocation table.
     JSBool invalidated_;            // Whether the code object has been invalidated.
                                     // This is necessary to prevent GC tracing.
 
     IonCode()
       : code_(NULL),
         pool_(NULL)
     { }
-    IonCode(uint8 *code, uint32 bufferSize, JSC::ExecutablePool *pool)
+    IonCode(uint8_t *code, uint32_t bufferSize, JSC::ExecutablePool *pool)
       : code_(code),
         pool_(pool),
         bufferSize_(bufferSize),
         insnSize_(0),
         dataSize_(0),
         jumpRelocTableBytes_(0),
         dataRelocTableBytes_(0),
         invalidated_(false)
     { }
 
-    uint32 dataOffset() const {
+    uint32_t dataOffset() const {
         return insnSize_;
     }
-    uint32 jumpRelocTableOffset() const {
+    uint32_t jumpRelocTableOffset() const {
         return dataOffset() + dataSize_;
     }
-    uint32 dataRelocTableOffset() const {
+    uint32_t dataRelocTableOffset() const {
         return jumpRelocTableOffset() + jumpRelocTableBytes_;
     }
 
   public:
-    uint8 *raw() const {
+    uint8_t *raw() const {
         return code_;
     }
     size_t instructionsSize() const {
         return insnSize_;
     }
     void trace(JSTracer *trc);
     void finalize(FreeOp *fop);
     void setInvalidated() {
@@ -94,34 +94,34 @@ class IonCode : public gc::Cell
     }
 
     template <typename T> T as() const {
         return JS_DATA_TO_FUNC_PTR(T, raw());
     }
 
     void copyFrom(MacroAssembler &masm);
 
-    static IonCode *FromExecutable(uint8 *buffer) {
+    static IonCode *FromExecutable(uint8_t *buffer) {
         IonCode *code = *(IonCode **)(buffer - sizeof(IonCode *));
         JS_ASSERT(code->raw() == buffer);
         return code;
     }
 
     static size_t offsetOfCode() {
         return offsetof(IonCode, code_);
     }
 
-    uint8 *jumpRelocTable() {
+    uint8_t *jumpRelocTable() {
         return code_ + jumpRelocTableOffset();
     }
 
     // Allocates a new IonCode object which will be managed by the GC. If no
     // object can be allocated, NULL is returned. On failure, |pool| is
     // automatically released, so the code may be freed.
-    static IonCode *New(JSContext *cx, uint8 *code, uint32 bufferSize, JSC::ExecutablePool *pool);
+    static IonCode *New(JSContext *cx, uint8_t *code, uint32_t bufferSize, JSC::ExecutablePool *pool);
 
   public:
     static void readBarrier(IonCode *code);
     static void writeBarrierPre(IonCode *code);
     static void writeBarrierPost(IonCode *code, void *addr);
 };
 
 class SnapshotWriter;
@@ -139,120 +139,120 @@ struct IonScript
 
     // Deoptimization table used by this method.
     HeapPtr<IonCode> deoptTable_;
 
     // Entrypoint for OSR, or NULL.
     jsbytecode *osrPc_;
 
     // Offset to OSR entrypoint from method_->raw(), or 0.
-    uint32 osrEntryOffset_;
+    uint32_t osrEntryOffset_;
 
     // Offset of the invalidation epilogue (which pushes this IonScript
     // and calls the invalidation thunk).
-    uint32 invalidateEpilogueOffset_;
+    uint32_t invalidateEpilogueOffset_;
 
     // The offset immediately after the IonScript immediate.
     // NOTE: technically a constant delta from
     // |invalidateEpilogueOffset_|, so we could hard-code this
     // per-platform if we want.
-    uint32 invalidateEpilogueDataOffset_;
+    uint32_t invalidateEpilogueDataOffset_;
 
     // Flag set when we bailout, to avoid frequent bailouts.
     bool bailoutExpected_;
 
     // Offset from the start of the code buffer to its snapshot buffer.
-    uint32 snapshots_;
-    uint32 snapshotsSize_;
+    uint32_t snapshots_;
+    uint32_t snapshotsSize_;
 
     // Table mapping bailout IDs to snapshot offsets.
-    uint32 bailoutTable_;
-    uint32 bailoutEntries_;
+    uint32_t bailoutTable_;
+    uint32_t bailoutEntries_;
 
     // Constant table for constants stored in snapshots.
-    uint32 constantTable_;
-    uint32 constantEntries_;
+    uint32_t constantTable_;
+    uint32_t constantEntries_;
 
     // Map code displacement to safepoint / OSI-patch-delta.
-    uint32 safepointIndexOffset_;
-    uint32 safepointIndexEntries_;
+    uint32_t safepointIndexOffset_;
+    uint32_t safepointIndexEntries_;
 
     // Number of STACK_SLOT_SIZE-length slots this function reserves on the
     // stack.
-    uint32 frameSlots_;
+    uint32_t frameSlots_;
 
     // Frame size is the value that can be added to the StackPointer along
     // with the frame prefix to get a valid IonJSFrameLayout.
-    uint32 frameSize_;
+    uint32_t frameSize_;
 
     // Map OSI-point displacement to snapshot.
-    uint32 osiIndexOffset_;
-    uint32 osiIndexEntries_;
+    uint32_t osiIndexOffset_;
+    uint32_t osiIndexEntries_;
 
     // State for polymorphic caches in the compiled code.
-    uint32 cacheList_;
-    uint32 cacheEntries_;
+    uint32_t cacheList_;
+    uint32_t cacheEntries_;
 
     // Offset list for patchable pre-barriers.
-    uint32 prebarrierList_;
-    uint32 prebarrierEntries_;
+    uint32_t prebarrierList_;
+    uint32_t prebarrierEntries_;
 
     // Offset to and length of the safepoint table in bytes.
-    uint32 safepointsStart_;
-    uint32 safepointsSize_;
+    uint32_t safepointsStart_;
+    uint32_t safepointsSize_;
 
     // List of compiled/inlined JSScript's.
-    uint32 scriptList_;
-    uint32 scriptEntries_;
+    uint32_t scriptList_;
+    uint32_t scriptEntries_;
 
     // Number of references from invalidation records.
     size_t refcount_;
 
     types::RecompileInfo recompileInfo_;
 
   public:
     // Number of times this function has tried to call a non-IM compileable function
-    uint32 slowCallCount;
+    uint32_t slowCallCount;
 
     SnapshotOffset *bailoutTable() {
-        return (SnapshotOffset *)(reinterpret_cast<uint8 *>(this) + bailoutTable_);
+        return (SnapshotOffset *)(reinterpret_cast<uint8_t *>(this) + bailoutTable_);
     }
     HeapValue *constants() {
-        return (HeapValue *)(reinterpret_cast<uint8 *>(this) + constantTable_);
+        return (HeapValue *)(reinterpret_cast<uint8_t *>(this) + constantTable_);
     }
     const SafepointIndex *safepointIndices() const {
         return const_cast<IonScript *>(this)->safepointIndices();
     }
     SafepointIndex *safepointIndices() {
-        return (SafepointIndex *)(reinterpret_cast<uint8 *>(this) + safepointIndexOffset_);
+        return (SafepointIndex *)(reinterpret_cast<uint8_t *>(this) + safepointIndexOffset_);
     }
     const OsiIndex *osiIndices() const {
         return const_cast<IonScript *>(this)->osiIndices();
     }
     OsiIndex *osiIndices() {
-        return (OsiIndex *)(reinterpret_cast<uint8 *>(this) + osiIndexOffset_);
+        return (OsiIndex *)(reinterpret_cast<uint8_t *>(this) + osiIndexOffset_);
     }
     IonCache *cacheList() {
-        return (IonCache *)(reinterpret_cast<uint8 *>(this) + cacheList_);
+        return (IonCache *)(reinterpret_cast<uint8_t *>(this) + cacheList_);
     }
     CodeOffsetLabel *prebarrierList() {
-        return (CodeOffsetLabel *)(reinterpret_cast<uint8 *>(this) + prebarrierList_);
+        return (CodeOffsetLabel *)(reinterpret_cast<uint8_t *>(this) + prebarrierList_);
     }
     JSScript **scriptList() const {
-        return (JSScript **)(reinterpret_cast<const uint8 *>(this) + scriptList_);
+        return (JSScript **)(reinterpret_cast<const uint8_t *>(this) + scriptList_);
     }
 
   private:
     void trace(JSTracer *trc);
 
   public:
     // Do not call directly, use IonScript::New. This is public for cx->new_.
     IonScript();
 
-    static IonScript *New(JSContext *cx, uint32 frameLocals, uint32 frameSize,
+    static IonScript *New(JSContext *cx, uint32_t frameLocals, uint32_t frameSize,
                           size_t snapshotsSize, size_t snapshotEntries,
                           size_t constants, size_t safepointIndexEntries, size_t osiIndexEntries,
                           size_t cacheEntries, size_t prebarrierEntries, size_t safepointsSize,
                           size_t scriptEntries);
     static void Trace(JSTracer *trc, IonScript *script);
     static void Destroy(FreeOp *fop, IonScript *script);
 
     static inline size_t offsetOfMethod() {
@@ -274,61 +274,61 @@ struct IonScript
         deoptTable_ = code;
     }
     void setOsrPc(jsbytecode *osrPc) {
         osrPc_ = osrPc;
     }
     jsbytecode *osrPc() const {
         return osrPc_;
     }
-    void setOsrEntryOffset(uint32 offset) {
+    void setOsrEntryOffset(uint32_t offset) {
         JS_ASSERT(!osrEntryOffset_);
         osrEntryOffset_ = offset;
     }
-    uint32 osrEntryOffset() const {
+    uint32_t osrEntryOffset() const {
         return osrEntryOffset_;
     }
-    bool containsCodeAddress(uint8 *addr) const {
+    bool containsCodeAddress(uint8_t *addr) const {
         return method()->raw() <= addr && addr <= method()->raw() + method()->instructionsSize();
     }
-    bool containsReturnAddress(uint8 *addr) const {
+    bool containsReturnAddress(uint8_t *addr) const {
         // This accounts for an off by one error caused by the return address of a
         // bailout sitting outside the range of the containing function.
         return method()->raw() <= addr && addr <= method()->raw() + method()->instructionsSize();
     }
-    void setInvalidationEpilogueOffset(uint32 offset) {
+    void setInvalidationEpilogueOffset(uint32_t offset) {
         JS_ASSERT(!invalidateEpilogueOffset_);
         invalidateEpilogueOffset_ = offset;
     }
-    uint32 invalidateEpilogueOffset() const {
+    uint32_t invalidateEpilogueOffset() const {
         JS_ASSERT(invalidateEpilogueOffset_);
         return invalidateEpilogueOffset_;
     }
-    void setInvalidationEpilogueDataOffset(uint32 offset) {
+    void setInvalidationEpilogueDataOffset(uint32_t offset) {
         JS_ASSERT(!invalidateEpilogueDataOffset_);
         invalidateEpilogueDataOffset_ = offset;
     }
-    uint32 invalidateEpilogueDataOffset() const {
+    uint32_t invalidateEpilogueDataOffset() const {
         JS_ASSERT(invalidateEpilogueDataOffset_);
         return invalidateEpilogueDataOffset_;
     }
     void setBailoutExpected() {
         bailoutExpected_ = true;
     }
     bool bailoutExpected() const {
         return bailoutExpected_;
     }
-    const uint8 *snapshots() const {
-        return reinterpret_cast<const uint8 *>(this) + snapshots_;
+    const uint8_t *snapshots() const {
+        return reinterpret_cast<const uint8_t *>(this) + snapshots_;
     }
     size_t snapshotsSize() const {
         return snapshotsSize_;
     }
-    const uint8 *safepoints() const {
-        return reinterpret_cast<const uint8 *>(this) + safepointsStart_;
+    const uint8_t *safepoints() const {
+        return reinterpret_cast<const uint8_t *>(this) + safepointsStart_;
     }
     size_t safepointsSize() const {
         return safepointsSize_;
     }
     JSScript *getScript(size_t i) const {
         JS_ASSERT(i < scriptEntries_);
         return scriptList()[i];
     }
@@ -340,33 +340,33 @@ struct IonScript
     }
     HeapValue &getConstant(size_t index) {
         JS_ASSERT(index < numConstants());
         return constants()[index];
     }
     size_t numConstants() const {
         return constantEntries_;
     }
-    uint32 frameSlots() const {
+    uint32_t frameSlots() const {
         return frameSlots_;
     }
-    uint32 frameSize() const {
+    uint32_t frameSize() const {
         return frameSize_;
     }
-    SnapshotOffset bailoutToSnapshot(uint32 bailoutId) {
+    SnapshotOffset bailoutToSnapshot(uint32_t bailoutId) {
         JS_ASSERT(bailoutId < bailoutEntries_);
         return bailoutTable()[bailoutId];
     }
-    const SafepointIndex *getSafepointIndex(uint32 disp) const;
-    const SafepointIndex *getSafepointIndex(uint8 *retAddr) const {
+    const SafepointIndex *getSafepointIndex(uint32_t disp) const;
+    const SafepointIndex *getSafepointIndex(uint8_t *retAddr) const {
         JS_ASSERT(containsCodeAddress(retAddr));
         return getSafepointIndex(retAddr - method()->raw());
     }
-    const OsiIndex *getOsiIndex(uint32 disp) const;
-    const OsiIndex *getOsiIndex(uint8 *retAddr) const;
+    const OsiIndex *getOsiIndex(uint32_t disp) const;
+    const OsiIndex *getOsiIndex(uint8_t *retAddr) const;
     inline IonCache &getCache(size_t index);
     size_t numCaches() const {
         return cacheEntries_;
     }
     inline CodeOffsetLabel &getPrebarrier(size_t index);
     size_t numPrebarriers() const {
         return prebarrierEntries_;
     }
@@ -402,113 +402,113 @@ struct IonScript
     }
 };
 
 // Execution information for a basic block which may persist after the
 // accompanying IonScript is destroyed, for use during profiling.
 struct IonBlockCounts
 {
   private:
-    uint32 id_;
+    uint32_t id_;
 
     // Approximate bytecode in the outer (not inlined) script this block
     // was generated from.
-    uint32 offset_;
+    uint32_t offset_;
 
     // ids for successors of this block.
-    uint32 numSuccessors_;
-    uint32 *successors_;
+    uint32_t numSuccessors_;
+    uint32_t *successors_;
 
     // Hit count for this block.
-    uint64 hitCount_;
+    uint64_t hitCount_;
 
     // Text information about the code generated for this block.
     char *code_;
 
     // Number of bytes of code generated in this block. Spill code is counted
     // separately from other, instruction implementing code.
-    uint32 instructionBytes_;
-    uint32 spillBytes_;
+    uint32_t instructionBytes_;
+    uint32_t spillBytes_;
 
   public:
 
-    bool init(uint32 id, uint32 offset, uint32 numSuccessors) {
+    bool init(uint32_t id, uint32_t offset, uint32_t numSuccessors) {
         id_ = id;
         offset_ = offset;
         numSuccessors_ = numSuccessors;
         if (numSuccessors) {
-            successors_ = (uint32 *) js_calloc(numSuccessors * sizeof(uint32));
+            successors_ = (uint32_t *) js_calloc(numSuccessors * sizeof(uint32_t));
             if (!successors_)
                 return false;
         }
         return true;
     }
 
     void destroy() {
         if (successors_)
             js_free(successors_);
         if (code_)
             js_free(code_);
     }
 
-    uint32 id() const {
+    uint32_t id() const {
         return id_;
     }
 
-    uint32 offset() const {
+    uint32_t offset() const {
         return offset_;
     }
 
     size_t numSuccessors() const {
         return numSuccessors_;
     }
 
-    void setSuccessor(size_t i, uint32 id) {
+    void setSuccessor(size_t i, uint32_t id) {
         JS_ASSERT(i < numSuccessors_);
         successors_[i] = id;
     }
 
-    uint32 successor(size_t i) const {
+    uint32_t successor(size_t i) const {
         JS_ASSERT(i < numSuccessors_);
         return successors_[i];
     }
 
-    uint64 *addressOfHitCount() {
+    uint64_t *addressOfHitCount() {
         return &hitCount_;
     }
 
-    uint64 hitCount() const {
+    uint64_t hitCount() const {
         return hitCount_;
     }
 
     void setCode(const char *code) {
         char *ncode = (char *) js_malloc(strlen(code) + 1);
         if (ncode) {
             strcpy(ncode, code);
             code_ = ncode;
         }
     }
 
     const char *code() const {
         return code_;
     }
 
-    void setInstructionBytes(uint32 bytes) {
+    void setInstructionBytes(uint32_t bytes) {
         instructionBytes_ = bytes;
     }
 
-    uint32 instructionBytes() const {
+    uint32_t instructionBytes() const {
         return instructionBytes_;
     }
 
-    void setSpillBytes(uint32 bytes) {
+    void setSpillBytes(uint32_t bytes) {
         spillBytes_ = bytes;
     }
 
-    uint32 spillBytes() const {
+    uint32_t spillBytes() const {
         return spillBytes_;
     }
 };
 
 // Execution information for a compiled script which may persist after the
 // IonScript is destroyed, for use during profiling.
 struct IonScriptCounts
 {