wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity

Bug 820686 - Follow-up: s/MOZ_ASSUME_NOT_REACHED/MOZ_ASSUME_UNREACHABLE/. rs=waldo

Browse Source 
I'd meant to do this, but I only got as far as the comment in mfbt.  Oops!

--HG--
extra : rebase_source : 3cfe3ef1bf401eb7d9a10fcabcfb39008e9553a4
This commit is contained in:
Justin Lebar 2013-06-28 19:20:12 -07:00
parent 90b850ae97
commit 904130e9c2
120 changed files with 559 additions and 559 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
js/public/RootingAPI.h
View File

@ -888,11 +888,11 @@ template <typename T> class MaybeRooted<T, NoGC>
typedef FakeMutableHandle<T> MutableHandleType;
static inline JS::Handle<T> toHandle(HandleType v) {
MOZ_ASSUME_NOT_REACHED("Bad conversion");
MOZ_ASSUME_UNREACHABLE("Bad conversion");
}
static inline JS::MutableHandle<T> toMutableHandle(MutableHandleType v) {
MOZ_ASSUME_NOT_REACHED("Bad conversion");
MOZ_ASSUME_UNREACHABLE("Bad conversion");
}
};

2
js/src/assembler/assembler/ARMAssembler.h
View File

@ -1549,7 +1549,7 @@ namespace JSC {
dblToFloat ? SD(dest) : DD(dest),
dblToFloat ? DM(src) : SM(src), 0);
} else {
MOZ_ASSUME_NOT_REACHED("Other conversions did not seem useful on 2011/08/04");
MOZ_ASSUME_UNREACHABLE("Other conversions did not seem useful on 2011/08/04");
}
}

2
js/src/assembler/jit/ExecutableAllocator.h
View File

@ -162,7 +162,7 @@ private:
case ASMJS_CODE: m_asmJSCodeBytes += n; break;
case REGEXP_CODE: m_regexpCodeBytes += n; break;
case OTHER_CODE: m_otherCodeBytes += n; break;
default: MOZ_ASSUME_NOT_REACHED("bad code kind");
default: MOZ_ASSUME_UNREACHABLE("bad code kind");
}
return result;
}

2
js/src/assembler/wtf/Assertions.h
View File

@ -44,7 +44,7 @@
(void)variable; \
ASSERT(assertion); \
} while (0)
#define ASSERT_NOT_REACHED() MOZ_ASSUME_NOT_REACHED()
#define ASSERT_NOT_REACHED() MOZ_ASSUME_UNREACHABLE()
#define CRASH() MOZ_CRASH()
#define COMPILE_ASSERT(exp, name) MOZ_STATIC_ASSERT(exp, #name)

70
js/src/builtin/Intl.cpp
View File

@ -76,7 +76,7 @@ using icu::NumberingSystem;
static int32_t
u_strlen(const UChar *s)
{
MOZ_ASSUME_NOT_REACHED("u_strlen: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("u_strlen: Intl API disabled");
}
struct UEnumeration;
@ -84,19 +84,19 @@ struct UEnumeration;
static int32_t
uenum_count(UEnumeration *en, UErrorCode *status)
{
MOZ_ASSUME_NOT_REACHED("uenum_count: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("uenum_count: Intl API disabled");
}
static const char *
uenum_next(UEnumeration *en, int32_t *resultLength, UErrorCode *status)
{
MOZ_ASSUME_NOT_REACHED("uenum_next: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("uenum_next: Intl API disabled");
}
static void
uenum_close(UEnumeration *en)
{
MOZ_ASSUME_NOT_REACHED("uenum_close: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("uenum_close: Intl API disabled");
}
struct UCollator;
@ -131,45 +131,45 @@ enum UCollationResult {
static int32_t
ucol_countAvailable(void)
{
MOZ_ASSUME_NOT_REACHED("ucol_countAvailable: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("ucol_countAvailable: Intl API disabled");
}
static const char *
ucol_getAvailable(int32_t localeIndex)
{
MOZ_ASSUME_NOT_REACHED("ucol_getAvailable: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("ucol_getAvailable: Intl API disabled");
}
static UCollator *
ucol_open(const char *loc, UErrorCode *status)
{
MOZ_ASSUME_NOT_REACHED("ucol_open: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("ucol_open: Intl API disabled");
}
static void
ucol_setAttribute(UCollator *coll, UColAttribute attr, UColAttributeValue value, UErrorCode *status)
{
MOZ_ASSUME_NOT_REACHED("ucol_setAttribute: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("ucol_setAttribute: Intl API disabled");
}
static UCollationResult
ucol_strcoll(const UCollator *coll, const UChar *source, int32_t sourceLength,
const UChar *target, int32_t targetLength)
{
MOZ_ASSUME_NOT_REACHED("ucol_strcoll: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("ucol_strcoll: Intl API disabled");
}
static void
ucol_close(UCollator *coll)
{
MOZ_ASSUME_NOT_REACHED("ucol_close: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("ucol_close: Intl API disabled");
}
static UEnumeration *
ucol_getKeywordValuesForLocale(const char *key, const char *locale, UBool commonlyUsed,
UErrorCode *status)
{
MOZ_ASSUME_NOT_REACHED("ucol_getKeywordValuesForLocale: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("ucol_getKeywordValuesForLocale: Intl API disabled");
}
struct UParseError;
@ -206,46 +206,46 @@ enum UNumberFormatTextAttribute {
static int32_t
unum_countAvailable(void)
{
MOZ_ASSUME_NOT_REACHED("unum_countAvailable: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("unum_countAvailable: Intl API disabled");
}
static const char *
unum_getAvailable(int32_t localeIndex)
{
MOZ_ASSUME_NOT_REACHED("unum_getAvailable: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("unum_getAvailable: Intl API disabled");
}
static UNumberFormat *
unum_open(UNumberFormatStyle style, const UChar *pattern, int32_t patternLength,
const char *locale, UParseError *parseErr, UErrorCode *status)
{
MOZ_ASSUME_NOT_REACHED("unum_open: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("unum_open: Intl API disabled");
}
static void
unum_setAttribute(UNumberFormat *fmt, UNumberFormatAttribute attr, int32_t newValue)
{
MOZ_ASSUME_NOT_REACHED("unum_setAttribute: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("unum_setAttribute: Intl API disabled");
}
static int32_t
unum_formatDouble(const UNumberFormat *fmt, double number, UChar *result,
int32_t resultLength, UFieldPosition *pos, UErrorCode *status)
{
MOZ_ASSUME_NOT_REACHED("unum_formatDouble: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("unum_formatDouble: Intl API disabled");
}
static void
unum_close(UNumberFormat *fmt)
{
MOZ_ASSUME_NOT_REACHED("unum_close: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("unum_close: Intl API disabled");
}
static void
unum_setTextAttribute(UNumberFormat *fmt, UNumberFormatTextAttribute tag, const UChar *newValue,
int32_t newValueLength, UErrorCode *status)
{
MOZ_ASSUME_NOT_REACHED("unum_setTextAttribute: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("unum_setTextAttribute: Intl API disabled");
}
class Locale {
@ -257,7 +257,7 @@ class Locale {
Locale::Locale(const char *language, const char *country, const char *variant,
const char *keywordsAndValues)
{
MOZ_ASSUME_NOT_REACHED("Locale::Locale: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("Locale::Locale: Intl API disabled");
}
class NumberingSystem {
@ -269,13 +269,13 @@ class NumberingSystem {
NumberingSystem *
NumberingSystem::createInstance(const Locale &inLocale, UErrorCode &status)
{
MOZ_ASSUME_NOT_REACHED("NumberingSystem::createInstance: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("NumberingSystem::createInstance: Intl API disabled");
}
const char *
NumberingSystem::getName()
{
MOZ_ASSUME_NOT_REACHED("NumberingSystem::getName: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("NumberingSystem::getName: Intl API disabled");
}
typedef void *UCalendar;
@ -290,26 +290,26 @@ static UCalendar *
ucal_open(const UChar *zoneID, int32_t len, const char *locale,
UCalendarType type, UErrorCode *status)
{
MOZ_ASSUME_NOT_REACHED("ucal_open: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("ucal_open: Intl API disabled");
}
static const char *
ucal_getType(const UCalendar *cal, UErrorCode *status)
{
MOZ_ASSUME_NOT_REACHED("ucal_getType: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("ucal_getType: Intl API disabled");
}
static UEnumeration *
ucal_getKeywordValuesForLocale(const char *key, const char *locale,
UBool commonlyUsed, UErrorCode *status)
{
MOZ_ASSUME_NOT_REACHED("ucal_getKeywordValuesForLocale: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("ucal_getKeywordValuesForLocale: Intl API disabled");
}
static void
ucal_close(UCalendar *cal)
{
MOZ_ASSUME_NOT_REACHED("ucal_close: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("ucal_close: Intl API disabled");
}
typedef void *UDateTimePatternGenerator;
@ -317,7 +317,7 @@ typedef void *UDateTimePatternGenerator;
static UDateTimePatternGenerator *
udatpg_open(const char *locale, UErrorCode *pErrorCode)
{
MOZ_ASSUME_NOT_REACHED("udatpg_open: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("udatpg_open: Intl API disabled");
}
static int32_t
@ -325,13 +325,13 @@ udatpg_getBestPattern(UDateTimePatternGenerator *dtpg, const UChar *skeleton,
int32_t length, UChar *bestPattern, int32_t capacity,
UErrorCode *pErrorCode)
{
MOZ_ASSUME_NOT_REACHED("udatpg_getBestPattern: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("udatpg_getBestPattern: Intl API disabled");
}
static void
udatpg_close(UDateTimePatternGenerator *dtpg)
{
MOZ_ASSUME_NOT_REACHED("udatpg_close: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("udatpg_close: Intl API disabled");
}
typedef void *UCalendar;
@ -345,13 +345,13 @@ enum UDateFormatStyle {
static int32_t
udat_countAvailable(void)
{
MOZ_ASSUME_NOT_REACHED("udat_countAvailable: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("udat_countAvailable: Intl API disabled");
}
static const char *
udat_getAvailable(int32_t localeIndex)
{
MOZ_ASSUME_NOT_REACHED("udat_getAvailable: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("udat_getAvailable: Intl API disabled");
}
static UDateFormat *
@ -359,32 +359,32 @@ udat_open(UDateFormatStyle timeStyle, UDateFormatStyle dateStyle, const char *lo
const UChar *tzID, int32_t tzIDLength, const UChar *pattern,
int32_t patternLength, UErrorCode *status)
{
MOZ_ASSUME_NOT_REACHED("udat_open: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("udat_open: Intl API disabled");
}
static const UCalendar *
udat_getCalendar(const UDateFormat *fmt)
{
MOZ_ASSUME_NOT_REACHED("udat_getCalendar: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("udat_getCalendar: Intl API disabled");
}
static void
ucal_setGregorianChange(UCalendar *cal, UDate date, UErrorCode *pErrorCode)
{
MOZ_ASSUME_NOT_REACHED("ucal_setGregorianChange: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("ucal_setGregorianChange: Intl API disabled");
}
static int32_t
udat_format(const UDateFormat *format, UDate dateToFormat, UChar *result,
int32_t resultLength, UFieldPosition *position, UErrorCode *status)
{
MOZ_ASSUME_NOT_REACHED("udat_format: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("udat_format: Intl API disabled");
}
static void
udat_close(UDateFormat *format)
{
MOZ_ASSUME_NOT_REACHED("udat_close: Intl API disabled");
MOZ_ASSUME_UNREACHABLE("udat_close: Intl API disabled");
}
#endif

2
js/src/builtin/TestingFunctions.cpp
View File

@ -490,7 +490,7 @@ GCState(JSContext *cx, unsigned argc, jsval *vp)
else if (globalState == gc::SWEEP)
state = "sweep";
else
MOZ_ASSUME_NOT_REACHED("Unobserveable global GC state");
MOZ_ASSUME_UNREACHABLE("Unobserveable global GC state");
JSString *str = JS_NewStringCopyZ(cx, state);
if (!str)

18
js/src/ctypes/CTypes.cpp
View File

@ -2129,7 +2129,7 @@ ConvertToJS(JSContext* cx,
break;
}
case TYPE_function:
MOZ_ASSUME_NOT_REACHED("cannot return a FunctionType");
MOZ_ASSUME_UNREACHABLE("cannot return a FunctionType");
}
return true;
@ -2569,7 +2569,7 @@ ImplicitConvert(JSContext* cx,
}
case TYPE_void_t:
case TYPE_function:
MOZ_ASSUME_NOT_REACHED("invalid type");
MOZ_ASSUME_UNREACHABLE("invalid type");
}
return true;
@ -2641,7 +2641,7 @@ ExplicitConvert(JSContext* cx, HandleValue val, HandleObject targetType, void* b
return false;
case TYPE_void_t:
case TYPE_function:
MOZ_ASSUME_NOT_REACHED("invalid type");
MOZ_ASSUME_UNREACHABLE("invalid type");
}
return true;
}
@ -2813,7 +2813,7 @@ BuildTypeSource(JSContext* cx,
AppendString(result, "ctypes.winapi_abi, ");
break;
case INVALID_ABI:
MOZ_ASSUME_NOT_REACHED("invalid abi");
MOZ_ASSUME_UNREACHABLE("invalid abi");
}
// Recursively build the source string describing the function return and
@ -3057,7 +3057,7 @@ BuildDataSource(JSContext* cx,
break;
}
case TYPE_void_t:
MOZ_ASSUME_NOT_REACHED("invalid type");
MOZ_ASSUME_UNREACHABLE("invalid type");
}
return true;
@ -3530,7 +3530,7 @@ CType::GetFFIType(JSContext* cx, JSObject* obj)
break;
default:
MOZ_ASSUME_NOT_REACHED("simple types must have an ffi_type");
MOZ_ASSUME_UNREACHABLE("simple types must have an ffi_type");
}
if (!result)
@ -5459,7 +5459,7 @@ FunctionType::BuildSymbolName(JSString* name,
}
case INVALID_ABI:
MOZ_ASSUME_NOT_REACHED("invalid abi");
MOZ_ASSUME_UNREACHABLE("invalid abi");
}
}
@ -6795,7 +6795,7 @@ CDataFinalizer::Methods::ToString(JSContext *cx, unsigned argc, jsval *vp)
return JS_FALSE;
}
} else if (!CDataFinalizer::GetValue(cx, objThis, value.address())) {
MOZ_ASSUME_NOT_REACHED("Could not convert an empty CDataFinalizer");
MOZ_ASSUME_UNREACHABLE("Could not convert an empty CDataFinalizer");
} else {
strMessage = JS_ValueToString(cx, value);
if (!strMessage) {
@ -7003,7 +7003,7 @@ CDataFinalizer::Construct(JSContext* cx, unsigned argc, jsval *vp)
objBestArgType = CData::GetCType(objData);
size_t sizeBestArg;
if (!CType::GetSafeSize(objBestArgType, &sizeBestArg)) {
MOZ_ASSUME_NOT_REACHED("object with unknown size");
MOZ_ASSUME_UNREACHABLE("object with unknown size");
}
if (sizeBestArg != sizeArg) {
return TypeError(cx, "(an object with the same size as that expected by the C finalization function)", valData);

24
js/src/frontend/BytecodeEmitter.cpp
View File

@ -919,7 +919,7 @@ EmitVarOp(JSContext *cx, ParseNode *pn, JSOp op, BytecodeEmitter *bce)
case JSOP_GETARG: case JSOP_GETLOCAL: op = JSOP_GETALIASEDVAR; break;
case JSOP_SETARG: case JSOP_SETLOCAL: op = JSOP_SETALIASEDVAR; break;
case JSOP_CALLARG: case JSOP_CALLLOCAL: op = JSOP_CALLALIASEDVAR; break;
default: MOZ_ASSUME_NOT_REACHED("unexpected var op");
default: MOZ_ASSUME_UNREACHABLE("unexpected var op");
}
return EmitAliasedVarOp(cx, op, pn, bce);
@ -1013,7 +1013,7 @@ BytecodeEmitter::isAliasedName(ParseNode *pn)
case Definition::PLACEHOLDER:
case Definition::NAMED_LAMBDA:
case Definition::MISSING:
MOZ_ASSUME_NOT_REACHED("unexpected dn->kind");
MOZ_ASSUME_UNREACHABLE("unexpected dn->kind");
}
return false;
}
@ -1108,7 +1108,7 @@ TryConvertFreeName(BytecodeEmitter *bce, ParseNode *pn)
case JSOP_NAME: op = JSOP_GETINTRINSIC; break;
case JSOP_SETNAME: op = JSOP_SETINTRINSIC; break;
/* Other *NAME ops aren't (yet) supported in self-hosted code. */
default: MOZ_ASSUME_NOT_REACHED("intrinsic");
default: MOZ_ASSUME_UNREACHABLE("intrinsic");
}
pn->setOp(op);
return true;
@ -1214,7 +1214,7 @@ TryConvertFreeName(BytecodeEmitter *bce, ParseNode *pn)
case JSOP_SETCONST:
/* Not supported. */
return false;
default: MOZ_ASSUME_NOT_REACHED("gname");
default: MOZ_ASSUME_UNREACHABLE("gname");
}
pn->setOp(op);
return true;
@ -1363,7 +1363,7 @@ BindNameToSlotHelper(JSContext *cx, BytecodeEmitter *bce, ParseNode *pn)
switch (op) {
case JSOP_NAME: op = JSOP_GETARG; break;
case JSOP_SETNAME: op = JSOP_SETARG; break;
default: MOZ_ASSUME_NOT_REACHED("arg");
default: MOZ_ASSUME_UNREACHABLE("arg");
}
JS_ASSERT(!pn->isConst());
break;
@ -1375,7 +1375,7 @@ BindNameToSlotHelper(JSContext *cx, BytecodeEmitter *bce, ParseNode *pn)
case JSOP_NAME: op = JSOP_GETLOCAL; break;
case JSOP_SETNAME: op = JSOP_SETLOCAL; break;
case JSOP_SETCONST: op = JSOP_SETLOCAL; break;
default: MOZ_ASSUME_NOT_REACHED("local");
default: MOZ_ASSUME_UNREACHABLE("local");
}
break;
@ -1432,7 +1432,7 @@ BindNameToSlotHelper(JSContext *cx, BytecodeEmitter *bce, ParseNode *pn)
return true;
case Definition::MISSING:
MOZ_ASSUME_NOT_REACHED("missing");
MOZ_ASSUME_UNREACHABLE("missing");
}
/*
@ -1624,7 +1624,7 @@ CheckSideEffects(JSContext *cx, BytecodeEmitter *bce, ParseNode *pn, bool *answe
default:
return CheckSideEffects(cx, bce, pn2, answer);
}
MOZ_ASSUME_NOT_REACHED("We have a returning default case");
MOZ_ASSUME_UNREACHABLE("We have a returning default case");
}
case PNK_TYPEOF:
@ -1647,7 +1647,7 @@ CheckSideEffects(JSContext *cx, BytecodeEmitter *bce, ParseNode *pn, bool *answe
*answer = true;
return true;
}
MOZ_ASSUME_NOT_REACHED("We have a returning default case");
MOZ_ASSUME_UNREACHABLE("We have a returning default case");
case PN_NAME:
/*
@ -3363,7 +3363,7 @@ EmitAssignment(JSContext *cx, BytecodeEmitter *bce, ParseNode *lhs, JSOp op, Par
case JSOP_SETARG: op = JSOP_GETARG; break;
case JSOP_SETLOCAL: op = JSOP_GETLOCAL; break;
case JSOP_SETALIASEDVAR: op = JSOP_GETALIASEDVAR; break;
default: MOZ_ASSUME_NOT_REACHED("Bad op");
default: MOZ_ASSUME_UNREACHABLE("Bad op");
}
if (!EmitVarOp(cx, lhs, op, bce))
return false;
@ -3587,7 +3587,7 @@ ParseNode::getConstantValue(JSContext *cx, bool strictChecks, MutableHandleValue
return true;
}
default:
MOZ_ASSUME_NOT_REACHED("Unexpected node");
MOZ_ASSUME_UNREACHABLE("Unexpected node");
}
return false;
}
@ -5421,7 +5421,7 @@ EmitObject(JSContext *cx, BytecodeEmitter *bce, ParseNode *pn)
case JSOP_INITPROP: op = JSOP_INITELEM; break;
case JSOP_INITPROP_GETTER: op = JSOP_INITELEM_GETTER; break;
case JSOP_INITPROP_SETTER: op = JSOP_INITELEM_SETTER; break;
default: MOZ_ASSUME_NOT_REACHED("Invalid op");
default: MOZ_ASSUME_UNREACHABLE("Invalid op");
}
if (Emit1(cx, bce, op) < 0)
return false;

2
js/src/frontend/ParseNode.cpp
View File

@ -381,7 +381,7 @@ Parser<FullParseHandler>::cloneParseTree(ParseNode *opn)
case PN_CODE:
if (pn->getKind() == PNK_MODULE) {
MOZ_ASSUME_NOT_REACHED("module nodes cannot be cloned");
MOZ_ASSUME_UNREACHABLE("module nodes cannot be cloned");
}
NULLCHECK(pn->pn_funbox =
newFunctionBox(opn->pn_funbox->function(), pc, opn->pn_funbox->strict));

8
js/src/frontend/Parser.cpp
View File

@ -188,7 +188,7 @@ ParseContext<FullParseHandler>::define(JSContext *cx, HandlePropertyName name,
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected kind");
MOZ_ASSUME_UNREACHABLE("unexpected kind");
}
return true;
@ -278,7 +278,7 @@ AppendPackedBindings(const ParseContext<ParseHandler> *pc, const DeclVector &vec
kind = ARGUMENT;
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected dn->kind");
MOZ_ASSUME_UNREACHABLE("unexpected dn->kind");
}
/*
@ -3974,7 +3974,7 @@ Parser<FullParseHandler>::forStatement()
#if JS_HAS_DESTRUCTURING
case PNK_ASSIGN:
MOZ_ASSUME_NOT_REACHED("forStatement TOK_ASSIGN");
MOZ_ASSUME_UNREACHABLE("forStatement TOK_ASSIGN");
case PNK_ARRAY:
case PNK_OBJECT:
@ -6654,7 +6654,7 @@ Parser<ParseHandler>::primaryExpr(TokenKind tt)
} else if (op == JSOP_INITPROP_SETTER) {
assignType = SET;
} else {
MOZ_ASSUME_NOT_REACHED("bad opcode in object initializer");
MOZ_ASSUME_UNREACHABLE("bad opcode in object initializer");
}
AtomIndexAddPtr p = seen.lookupForAdd(atom);

2
js/src/gc/RootMarking.cpp
View File

@ -66,7 +66,7 @@ MarkExactStackRoot(JSTracer *trc, Rooted<void*> *rooter, ThingRootKind kind)
case THING_ROOT_PROPERTY_ID: MarkIdRoot(trc, &((js::PropertyId *)addr)->asId(), "exact-propertyid"); break;
case THING_ROOT_BINDINGS: ((Bindings *)addr)->trace(trc); break;
case THING_ROOT_PROPERTY_DESCRIPTOR: ((JSPropertyDescriptor *)addr)->trace(trc); break;
default: MOZ_ASSUME_NOT_REACHED("Invalid THING_ROOT kind"); break;
default: MOZ_ASSUME_UNREACHABLE("Invalid THING_ROOT kind"); break;
}
}

2
js/src/gc/Statistics.cpp
View File

@ -251,7 +251,7 @@ ExplainReason(JS::gcreason::Reason reason)
GCREASONS(SWITCH_REASON)
default:
MOZ_ASSUME_NOT_REACHED("bad GC reason");
MOZ_ASSUME_UNREACHABLE("bad GC reason");
#undef SWITCH_REASON
}
}

2
js/src/gc/StoreBuffer.cpp
View File

@ -70,7 +70,7 @@ StoreBuffer::WholeCellEdges::mark(JSTracer *trc)
JS_ASSERT(kind == JSTRACE_IONCODE);
static_cast<ion::IonCode *>(tenured)->trace(trc);
#else
MOZ_ASSUME_NOT_REACHED("Only objects can be in the wholeCellBuffer if IonMonkey is disabled.");
MOZ_ASSUME_UNREACHABLE("Only objects can be in the wholeCellBuffer if IonMonkey is disabled.");
#endif
}

28
js/src/ion/AsmJS.cpp
View File

@ -412,7 +412,7 @@ class Type
case Unknown:
return MIRType_None;
}
MOZ_ASSUME_NOT_REACHED("Invalid Type");
MOZ_ASSUME_UNREACHABLE("Invalid Type");
}
const char *toChars() const {
@ -427,7 +427,7 @@ class Type
case Void: return "void";
case Unknown: return "unknown";
}
MOZ_ASSUME_NOT_REACHED("Invalid Type");
MOZ_ASSUME_UNREACHABLE("Invalid Type");
}
};
@ -466,7 +466,7 @@ class RetType
case Signed: return AsmJSModule::Return_Int32;
case Double: return AsmJSModule::Return_Double;
}
MOZ_ASSUME_NOT_REACHED("Unexpected return type");
MOZ_ASSUME_UNREACHABLE("Unexpected return type");
}
MIRType toMIRType() const {
switch (which_) {
@ -474,7 +474,7 @@ class RetType
case Signed: return MIRType_Int32;
case Double: return MIRType_Double;
}
MOZ_ASSUME_NOT_REACHED("Unexpected return type");
MOZ_ASSUME_UNREACHABLE("Unexpected return type");
}
bool operator==(RetType rhs) const { return which_ == rhs.which_; }
bool operator!=(RetType rhs) const { return which_ != rhs.which_; }
@ -489,7 +489,7 @@ operator<=(Type lhs, RetType rhs)
case RetType::Double: return lhs == Type::Double;
case RetType::Void: return lhs == Type::Void;
}
MOZ_ASSUME_NOT_REACHED("Unexpected rhs type");
MOZ_ASSUME_UNREACHABLE("Unexpected rhs type");
}
// Represents the subset of Type that can be used as a variable or
@ -562,7 +562,7 @@ operator<=(Type lhs, VarType rhs)
case VarType::Int: return lhs.isInt();
case VarType::Double: return lhs.isDouble();
}
MOZ_ASSUME_NOT_REACHED("Unexpected rhs type");
MOZ_ASSUME_UNREACHABLE("Unexpected rhs type");
}
// Passed from parent expressions to child expressions to indicate if and how
@ -723,7 +723,7 @@ IsLiteralUint32(ParseNode *pn, uint32_t *u32)
return false;
}
MOZ_ASSUME_NOT_REACHED("Bad literal type");
MOZ_ASSUME_UNREACHABLE("Bad literal type");
}
static inline bool
@ -743,7 +743,7 @@ IsBits32(ParseNode *pn, int32_t i)
return false;
}
MOZ_ASSUME_NOT_REACHED("Bad literal type");
MOZ_ASSUME_UNREACHABLE("Bad literal type");
}
/*****************************************************************************/
@ -765,7 +765,7 @@ TypedArrayLoadType(ArrayBufferView::ViewType viewType)
return Type::Doublish;
default:;
}
MOZ_ASSUME_NOT_REACHED("Unexpected array type");
MOZ_ASSUME_UNREACHABLE("Unexpected array type");
}
enum ArrayStoreEnum {
@ -789,7 +789,7 @@ TypedArrayStoreType(ArrayBufferView::ViewType viewType)
return ArrayStore_Doublish;
default:;
}
MOZ_ASSUME_NOT_REACHED("Unexpected array type");
MOZ_ASSUME_UNREACHABLE("Unexpected array type");
}
/*****************************************************************************/
@ -3855,7 +3855,7 @@ IsValidIntMultiplyConstant(ParseNode *expr)
return false;
}
MOZ_ASSUME_NOT_REACHED("Bad literal");
MOZ_ASSUME_UNREACHABLE("Bad literal");
}
static bool
@ -4033,7 +4033,7 @@ CheckBitwise(FunctionCompiler &f, ParseNode *bitwise, MDefinition **def, Type *t
case PNK_LSH: identityElement = 0; onlyOnRight = true; *type = Type::Signed; break;
case PNK_RSH: identityElement = 0; onlyOnRight = true; *type = Type::Signed; break;
case PNK_URSH: identityElement = 0; onlyOnRight = true; *type = Type::Unsigned; break;
default: MOZ_ASSUME_NOT_REACHED("not a bitwise op");
default: MOZ_ASSUME_UNREACHABLE("not a bitwise op");
}
if (!onlyOnRight && IsBits32(lhs, identityElement)) {
@ -4079,7 +4079,7 @@ CheckBitwise(FunctionCompiler &f, ParseNode *bitwise, MDefinition **def, Type *t
case PNK_LSH: *def = f.bitwise<MLsh>(lhsDef, rhsDef); break;
case PNK_RSH: *def = f.bitwise<MRsh>(lhsDef, rhsDef); break;
case PNK_URSH: *def = f.bitwise<MUrsh>(lhsDef, rhsDef); break;
default: MOZ_ASSUME_NOT_REACHED("not a bitwise op");
default: MOZ_ASSUME_UNREACHABLE("not a bitwise op");
}
return true;
@ -5627,7 +5627,7 @@ GenerateOOLConvert(ModuleCompiler &m, RetType retType, Label *throwLabel)
#endif
break;
default:
MOZ_ASSUME_NOT_REACHED("Unsupported convert type");
MOZ_ASSUME_UNREACHABLE("Unsupported convert type");
}
masm.freeStack(stackDec);

4
js/src/ion/BacktrackingAllocator.cpp
View File

@ -1151,7 +1151,7 @@ BacktrackingAllocator::populateSafepoints()
break;
#endif
default:
MOZ_ASSUME_NOT_REACHED("Bad register type");
MOZ_ASSUME_UNREACHABLE("Bad register type");
}
}
}
@ -1439,7 +1439,7 @@ BacktrackingAllocator::computeSpillWeight(const LiveInterval *interval)
default:
// Note: RECOVERED_INPUT will not appear in UsePositionIterator.
MOZ_ASSUME_NOT_REACHED("Bad use");
MOZ_ASSUME_UNREACHABLE("Bad use");
}
}

2
js/src/ion/BaselineBailouts.cpp
View File

@ -1328,7 +1328,7 @@ ion::FinishBailoutToBaseline(BaselineBailoutInfo *bailoutInfo)
return false;
break;
default:
MOZ_ASSUME_NOT_REACHED("Unknown bailout kind!");
MOZ_ASSUME_UNREACHABLE("Unknown bailout kind!");
}
if (!CheckFrequentBailouts(cx, outerScript))

2
js/src/ion/BaselineCompiler.cpp
View File

@ -1087,7 +1087,7 @@ BaselineCompiler::storeValue(const StackValue *source, const Address &dest,
masm.storeValue(scratch, dest);
break;
default:
MOZ_ASSUME_NOT_REACHED("Invalid kind");
MOZ_ASSUME_UNREACHABLE("Invalid kind");
}
}

8
js/src/ion/BaselineFrameInfo.cpp
View File

@ -48,7 +48,7 @@ FrameInfo::sync(StackValue *val)
masm.pushValue(val->constant());
break;
default:
MOZ_ASSUME_NOT_REACHED("Invalid kind");
MOZ_ASSUME_UNREACHABLE("Invalid kind");
}
val->setStack();
@ -104,7 +104,7 @@ FrameInfo::popValue(ValueOperand dest)
masm.moveValue(val->reg(), dest);
break;
default:
MOZ_ASSUME_NOT_REACHED("Invalid kind");
MOZ_ASSUME_UNREACHABLE("Invalid kind");
}
// masm.popValue already adjusted the stack pointer, don't do it twice.
@ -140,7 +140,7 @@ FrameInfo::popRegsAndSync(uint32_t uses)
break;
}
default:
MOZ_ASSUME_NOT_REACHED("Invalid uses");
MOZ_ASSUME_UNREACHABLE("Invalid uses");
}
}
@ -177,7 +177,7 @@ FrameInfo::assertValidState(const BytecodeInfo &info)
JS_ASSERT(!usedR1);
usedR1 = true;
} else {
MOZ_ASSUME_NOT_REACHED("Invalid register");
MOZ_ASSUME_UNREACHABLE("Invalid register");
}
}
}

24
js/src/ion/BaselineIC.cpp
View File

@ -220,7 +220,7 @@ ICStub::trace(JSTracer *trc)
case 2: setElemStub->toImpl<2>()->traceShapes(trc); break;
case 3: setElemStub->toImpl<3>()->traceShapes(trc); break;
case 4: setElemStub->toImpl<4>()->traceShapes(trc); break;
default: MOZ_ASSUME_NOT_REACHED("Invalid proto stub.");
default: MOZ_ASSUME_UNREACHABLE("Invalid proto stub.");
}
break;
}
@ -358,7 +358,7 @@ ICStub::trace(JSTracer *trc)
case 2: propStub->toImpl<2>()->traceShapes(trc); break;
case 3: propStub->toImpl<3>()->traceShapes(trc); break;
case 4: propStub->toImpl<4>()->traceShapes(trc); break;
default: MOZ_ASSUME_NOT_REACHED("Invalid proto stub.");
default: MOZ_ASSUME_UNREACHABLE("Invalid proto stub.");
}
break;
}
@ -723,7 +723,7 @@ EnsureCanEnterIon(JSContext *cx, ICUseCount_Fallback *stub, BaselineFrame *frame
else if (stat == Method_Compiled)
IonSpew(IonSpew_BaselineOSR, " Compiled with Ion!");
else
MOZ_ASSUME_NOT_REACHED("Invalid MethodStatus!");
MOZ_ASSUME_UNREACHABLE("Invalid MethodStatus!");
// Failed to compile. Reset use count and return.
if (stat != Method_Compiled) {
@ -1436,7 +1436,7 @@ DoTypeUpdateFallback(JSContext *cx, BaselineFrame *frame, ICUpdatedStub *stub, H
break;
}
default:
MOZ_ASSUME_NOT_REACHED("Invalid stub");
MOZ_ASSUME_UNREACHABLE("Invalid stub");
}
return stub->addUpdateStubForValue(cx, script, obj, id, value);
@ -2463,7 +2463,7 @@ DoBinaryArithFallback(JSContext *cx, BaselineFrame *frame, ICBinaryArith_Fallbac
break;
}
default:
MOZ_ASSUME_NOT_REACHED("Unhandled baseline arith op");
MOZ_ASSUME_UNREACHABLE("Unhandled baseline arith op");
}
if (ret.isDouble())
@ -2781,7 +2781,7 @@ ICBinaryArith_Double::Compiler::generateStubCode(MacroAssembler &masm)
JS_ASSERT(ReturnFloatReg == FloatReg0);
break;
default:
MOZ_ASSUME_NOT_REACHED("Unexpected op");
MOZ_ASSUME_UNREACHABLE("Unexpected op");
}
masm.boxDouble(FloatReg0, R0);
@ -2861,7 +2861,7 @@ ICBinaryArith_BooleanWithInt32::Compiler::generateStubCode(MacroAssembler &masm)
break;
}
default:
MOZ_ASSUME_NOT_REACHED("Unhandled op for BinaryArith_BooleanWithInt32.");
MOZ_ASSUME_UNREACHABLE("Unhandled op for BinaryArith_BooleanWithInt32.");
}
// Failure case - jump to next stub
@ -2923,7 +2923,7 @@ ICBinaryArith_DoubleWithInt32::Compiler::generateStubCode(MacroAssembler &masm)
masm.andPtr(intReg, intReg2);
break;
default:
MOZ_ASSUME_NOT_REACHED("Unhandled op for BinaryArith_DoubleWithInt32.");
MOZ_ASSUME_UNREACHABLE("Unhandled op for BinaryArith_DoubleWithInt32.");
}
masm.tagValue(JSVAL_TYPE_INT32, intReg2, R0);
EmitReturnFromIC(masm);
@ -2964,7 +2964,7 @@ DoUnaryArithFallback(JSContext *cx, BaselineFrame *frame, ICUnaryArith_Fallback
return false;
break;
default:
MOZ_ASSUME_NOT_REACHED("Unexpected op");
MOZ_ASSUME_UNREACHABLE("Unexpected op");
}
if (res.isDouble())
@ -4472,7 +4472,7 @@ ICSetElemDenseAddCompiler::getStub(ICStubSpace *space)
case 2: stub = getStubSpecific<2>(space, &shapes); break;
case 3: stub = getStubSpecific<3>(space, &shapes); break;
case 4: stub = getStubSpecific<4>(space, &shapes); break;
default: MOZ_ASSUME_NOT_REACHED("ProtoChainDepth too high.");
default: MOZ_ASSUME_UNREACHABLE("ProtoChainDepth too high.");
}
if (!stub || !stub->initUpdatingChain(cx, space))
return NULL;
@ -6446,7 +6446,7 @@ ICSetPropNativeAddCompiler::getStub(ICStubSpace *space)
case 2: stub = getStubSpecific<2>(space, &shapes); break;
case 3: stub = getStubSpecific<3>(space, &shapes); break;
case 4: stub = getStubSpecific<4>(space, &shapes); break;
default: MOZ_ASSUME_NOT_REACHED("ProtoChainDepth too high.");
default: MOZ_ASSUME_UNREACHABLE("ProtoChainDepth too high.");
}
if (!stub || !stub->initUpdatingChain(cx, space))
return NULL;
@ -8133,7 +8133,7 @@ ICTypeOf_Typed::Compiler::generateStubCode(MacroAssembler &masm)
break;
default:
MOZ_ASSUME_NOT_REACHED("Unexpected type");
MOZ_ASSUME_UNREACHABLE("Unexpected type");
}
masm.movePtr(ImmGCPtr(typeString_), R0.scratchReg());

4
js/src/ion/BaselineIC.h
View File

@ -544,7 +544,7 @@ class ICStub
IC_STUB_KIND_LIST(DEF_KIND_STR)
#undef DEF_KIND_STR
default:
MOZ_ASSUME_NOT_REACHED("Invalid kind.");
MOZ_ASSUME_UNREACHABLE("Invalid kind.");
}
}
@ -1045,7 +1045,7 @@ class ICStubCompiler
regs.take(R1);
break;
default:
MOZ_ASSUME_NOT_REACHED("Invalid numInputs");
MOZ_ASSUME_UNREACHABLE("Invalid numInputs");
}
return regs;

6
js/src/ion/BaselineJIT.cpp
View File

@ -490,7 +490,7 @@ BaselineScript::icEntryFromPCOffset(uint32_t pcOffset)
if (icEntry(i).isForOp())
return icEntry(i);
}
MOZ_ASSUME_NOT_REACHED("Invalid PC offset for IC entry.");
MOZ_ASSUME_UNREACHABLE("Invalid PC offset for IC entry.");
}
ICEntry &
@ -635,7 +635,7 @@ BaselineScript::nativeCodeForPC(JSScript *script, jsbytecode *pc, PCMappingSlotI
curPC += GetBytecodeLength(curPC);
}
MOZ_ASSUME_NOT_REACHED("Invalid pc");
MOZ_ASSUME_UNREACHABLE("Invalid pc");
}
jsbytecode *
@ -679,7 +679,7 @@ BaselineScript::pcForReturnOffset(JSScript *script, uint32_t nativeOffset)
curPC += GetBytecodeLength(curPC);
}
MOZ_ASSUME_NOT_REACHED("Invalid pc");
MOZ_ASSUME_UNREACHABLE("Invalid pc");
}
jsbytecode *

24
js/src/ion/CodeGenerator.cpp
View File

@ -596,7 +596,7 @@ CodeGenerator::visitIntToString(LIntToString *lir)
StoreRegisterTo(output));
break;
default:
MOZ_ASSUME_NOT_REACHED("No such execution mode");
MOZ_ASSUME_UNREACHABLE("No such execution mode");
}
if (!ool)
return false;
@ -637,7 +637,7 @@ CodeGenerator::visitDoubleToString(LDoubleToString *lir)
StoreRegisterTo(output));
break;
default:
MOZ_ASSUME_NOT_REACHED("No such execution mode");
MOZ_ASSUME_UNREACHABLE("No such execution mode");
}
if (!ool)
return false;
@ -3526,7 +3526,7 @@ CodeGenerator::visitMathFunctionD(LMathFunctionD *ins)
funptr = JS_FUNC_TO_DATA_PTR(void *, js::math_acos_impl);
break;
default:
MOZ_ASSUME_NOT_REACHED("Unknown math function");
MOZ_ASSUME_UNREACHABLE("Unknown math function");
}
masm.callWithABI(funptr, MacroAssembler::DOUBLE);
@ -3588,7 +3588,7 @@ CodeGenerator::visitBinaryV(LBinaryV *lir)
return callVM(UrshInfo, lir);
default:
MOZ_ASSUME_NOT_REACHED("Unexpected binary op");
MOZ_ASSUME_UNREACHABLE("Unexpected binary op");
}
}
@ -3735,7 +3735,7 @@ CodeGenerator::visitCompareVM(LCompareVM *lir)
return callVM(GeInfo, lir);
default:
MOZ_ASSUME_NOT_REACHED("Unexpected compare op");
MOZ_ASSUME_UNREACHABLE("Unexpected compare op");
}
case ParallelExecution:
@ -3765,11 +3765,11 @@ CodeGenerator::visitCompareVM(LCompareVM *lir)
return callVM(ParGeInfo, lir);
default:
MOZ_ASSUME_NOT_REACHED("Unexpected compare op");
MOZ_ASSUME_UNREACHABLE("Unexpected compare op");
}
}
MOZ_ASSUME_NOT_REACHED("Unexpected exec mode");
MOZ_ASSUME_UNREACHABLE("Unexpected exec mode");
}
bool
@ -4135,7 +4135,7 @@ IonCompartment::generateStringConcatStub(JSContext *cx, ExecutionMode mode)
masm.pop(temp1);
break;
default:
MOZ_ASSUME_NOT_REACHED("No such execution mode");
MOZ_ASSUME_UNREACHABLE("No such execution mode");
}
// Store lengthAndFlags.
@ -4180,7 +4180,7 @@ IonCompartment::generateStringConcatStub(JSContext *cx, ExecutionMode mode)
masm.pop(temp1);
break;
default:
MOZ_ASSUME_NOT_REACHED("No such execution mode");
MOZ_ASSUME_UNREACHABLE("No such execution mode");
}
// Set lengthAndFlags.
@ -5726,7 +5726,7 @@ CodeGenerator::addGetPropertyCache(LInstruction *ins, RegisterSet liveRegs, Regi
return addCache(ins, allocateCache(cache));
}
default:
MOZ_ASSUME_NOT_REACHED("Bad execution mode");
MOZ_ASSUME_UNREACHABLE("Bad execution mode");
}
}
@ -6069,7 +6069,7 @@ CodeGenerator::visitBitOpV(LBitOpV *lir)
default:
break;
}
MOZ_ASSUME_NOT_REACHED("unexpected bitop");
MOZ_ASSUME_UNREACHABLE("unexpected bitop");
}
class OutOfLineTypeOfV : public OutOfLineCodeBase<CodeGenerator>
@ -6913,7 +6913,7 @@ CodeGenerator::visitFunctionBoundary(LFunctionBoundary *lir)
return true;
default:
MOZ_ASSUME_NOT_REACHED("invalid LFunctionBoundary type");
MOZ_ASSUME_UNREACHABLE("invalid LFunctionBoundary type");
}
}

2
js/src/ion/CompactBuffer.h
View File

@ -42,7 +42,7 @@ class CompactBufferReader
if (!(byte & 1))
return val;
}
MOZ_ASSUME_NOT_REACHED("unreachable");
MOZ_ASSUME_UNREACHABLE("unreachable");
}
public:

16
js/src/ion/ExecutionModeInlines.h
View File

@ -19,7 +19,7 @@ HasIonScript(JSScript *script, ExecutionMode cmode)
case SequentialExecution: return script->hasIonScript();
case ParallelExecution: return script->hasParallelIonScript();
}
MOZ_ASSUME_NOT_REACHED("No such execution mode");
MOZ_ASSUME_UNREACHABLE("No such execution mode");
}
static inline IonScript *
@ -29,7 +29,7 @@ GetIonScript(JSScript *script, ExecutionMode cmode)
case SequentialExecution: return script->maybeIonScript();
case ParallelExecution: return script->maybeParallelIonScript();
}
MOZ_ASSUME_NOT_REACHED("No such execution mode");
MOZ_ASSUME_UNREACHABLE("No such execution mode");
}
static inline void
@ -39,7 +39,7 @@ SetIonScript(JSScript *script, ExecutionMode cmode, IonScript *ionScript)
case SequentialExecution: script->setIonScript(ionScript); return;
case ParallelExecution: script->setParallelIonScript(ionScript); return;
}
MOZ_ASSUME_NOT_REACHED("No such execution mode");
MOZ_ASSUME_UNREACHABLE("No such execution mode");
}
static inline size_t
@ -49,7 +49,7 @@ OffsetOfIonInJSScript(ExecutionMode cmode)
case SequentialExecution: return JSScript::offsetOfIonScript();
case ParallelExecution: return JSScript::offsetOfParallelIonScript();
}
MOZ_ASSUME_NOT_REACHED("No such execution mode");
MOZ_ASSUME_UNREACHABLE("No such execution mode");
}
static inline bool
@ -59,7 +59,7 @@ CanIonCompile(JSScript *script, ExecutionMode cmode)
case SequentialExecution: return script->canIonCompile();
case ParallelExecution: return script->canParallelIonCompile();
}
MOZ_ASSUME_NOT_REACHED("No such execution mode");
MOZ_ASSUME_UNREACHABLE("No such execution mode");
return false;
}
@ -76,7 +76,7 @@ CompilingOffThread(JSScript *script, ExecutionMode cmode)
case SequentialExecution: return script->isIonCompilingOffThread();
case ParallelExecution: return script->isParallelIonCompilingOffThread();
}
MOZ_ASSUME_NOT_REACHED("No such execution mode");
MOZ_ASSUME_UNREACHABLE("No such execution mode");
}
static inline bool
@ -86,7 +86,7 @@ CompilingOffThread(HandleScript script, ExecutionMode cmode)
case SequentialExecution: return script->isIonCompilingOffThread();
case ParallelExecution: return script->isParallelIonCompilingOffThread();
}
MOZ_ASSUME_NOT_REACHED("No such execution mode");
MOZ_ASSUME_UNREACHABLE("No such execution mode");
}
static inline types::CompilerOutput::Kind
@ -96,7 +96,7 @@ CompilerOutputKind(ExecutionMode cmode)
case SequentialExecution: return types::CompilerOutput::Ion;
case ParallelExecution: return types::CompilerOutput::ParallelIon;
}
MOZ_ASSUME_NOT_REACHED("No such execution mode");
MOZ_ASSUME_UNREACHABLE("No such execution mode");
}
} // namespace ion

4
js/src/ion/FixedArityList.h
View File

@ -35,10 +35,10 @@ class FixedArityList<T, 0>
{
public:
T &operator [](size_t index) {
MOZ_ASSUME_NOT_REACHED("no items");
MOZ_ASSUME_UNREACHABLE("no items");
}
const T &operator [](size_t index) const {
MOZ_ASSUME_NOT_REACHED("no items");
MOZ_ASSUME_UNREACHABLE("no items");
}
};

10
js/src/ion/Ion.cpp
View File

@ -819,7 +819,7 @@ IonScript::getSafepointIndex(uint32_t disp) const
}
}
MOZ_ASSUME_NOT_REACHED("displacement not found.");
MOZ_ASSUME_UNREACHABLE("displacement not found.");
}
const OsiIndex *
@ -833,7 +833,7 @@ IonScript::getOsiIndex(uint32_t disp) const
return it;
}
MOZ_ASSUME_NOT_REACHED("Failed to find OSI point return address");
MOZ_ASSUME_UNREACHABLE("Failed to find OSI point return address");
}
const OsiIndex *
@ -1216,7 +1216,7 @@ GenerateLIR(MIRGenerator *mir)
}
default:
MOZ_ASSUME_NOT_REACHED("Bad regalloc");
MOZ_ASSUME_UNREACHABLE("Bad regalloc");
}
if (mir->shouldCancel("Allocate Registers"))
@ -2003,7 +2003,7 @@ InvalidateActivation(FreeOp *fop, uint8_t *ionTop, bool invalidateAll)
break;
case IonFrame_Unwound_OptimizedJS:
case IonFrame_Unwound_BaselineStub:
MOZ_ASSUME_NOT_REACHED("invalid");
MOZ_ASSUME_UNREACHABLE("invalid");
case IonFrame_Unwound_Rectifier:
IonSpew(IonSpew_Invalidate, "#%d unwound rectifier frame @ %p", frameno, it.fp());
break;
@ -2315,7 +2315,7 @@ ion::ForbidCompilation(JSContext *cx, JSScript *script, ExecutionMode mode)
return;
}
MOZ_ASSUME_NOT_REACHED("No such execution mode");
MOZ_ASSUME_UNREACHABLE("No such execution mode");
}
uint32_t

2
js/src/ion/IonAnalysis.cpp
View File

@ -570,7 +570,7 @@ TypeAnalyzer::replaceRedundantPhi(MPhi *phi)
v = MagicValue(JS_OPTIMIZED_ARGUMENTS);
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected type");
MOZ_ASSUME_UNREACHABLE("unexpected type");
}
MConstant *c = MConstant::New(v);
// The instruction pass will insert the box

28
js/src/ion/IonBuilder.cpp
View File

@ -1104,7 +1104,7 @@ IonBuilder::snoopControlFlow(JSOp op)
default:
// Hard assert for now - make an error later.
MOZ_ASSUME_NOT_REACHED("unknown goto case");
MOZ_ASSUME_UNREACHABLE("unknown goto case");
}
break;
}
@ -1115,7 +1115,7 @@ IonBuilder::snoopControlFlow(JSOp op)
case JSOP_IFNE:
// We should never reach an IFNE, it's a stopAt point, which will
// trigger closing the loop.
MOZ_ASSUME_NOT_REACHED("we should never reach an ifne!");
MOZ_ASSUME_UNREACHABLE("we should never reach an ifne!");
default:
break;
@ -1403,7 +1403,7 @@ IonBuilder::inspectOpcode(JSOp op)
case JSOP_LOOPHEAD:
// JSOP_LOOPHEAD is handled when processing the loop header.
MOZ_ASSUME_NOT_REACHED("JSOP_LOOPHEAD outside loop");
MOZ_ASSUME_UNREACHABLE("JSOP_LOOPHEAD outside loop");
case JSOP_GETELEM:
case JSOP_CALLELEM:
@ -1603,7 +1603,7 @@ IonBuilder::processCfgEntry(CFGState &state)
return processLabelEnd(state);
default:
MOZ_ASSUME_NOT_REACHED("unknown cfgstate");
MOZ_ASSUME_UNREACHABLE("unknown cfgstate");
}
}
@ -2251,7 +2251,7 @@ IonBuilder::processSwitchBreak(JSOp op)
breaks = &state.condswitch.breaks;
break;
default:
MOZ_ASSUME_NOT_REACHED("Unexpected switch state.");
MOZ_ASSUME_UNREACHABLE("Unexpected switch state.");
}
*breaks = new DeferredEdge(current, *breaks);
@ -2327,7 +2327,7 @@ IonBuilder::maybeLoop(JSOp op, jssrcnote *sn)
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected opcode");
MOZ_ASSUME_UNREACHABLE("unexpected opcode");
}
return ControlStatus_None;
@ -2357,7 +2357,7 @@ IonBuilder::assertValidLoopHeadOp(jsbytecode *pc)
break;
default:
MOZ_ASSUME_NOT_REACHED("JSOP_LOOPHEAD unexpected source note");
MOZ_ASSUME_UNREACHABLE("JSOP_LOOPHEAD unexpected source note");
}
// Make sure this loop goes to the same ifne as the loop header's
@ -3139,7 +3139,7 @@ IonBuilder::jsop_ifeq(JSOp op)
}
default:
MOZ_ASSUME_NOT_REACHED("unexpected source note type");
MOZ_ASSUME_UNREACHABLE("unexpected source note type");
}
// Switch to parsing the true branch. Note that no PC update is needed,
@ -3168,7 +3168,7 @@ IonBuilder::processReturn(JSOp op)
default:
def = NULL;
MOZ_ASSUME_NOT_REACHED("unknown return op");
MOZ_ASSUME_UNREACHABLE("unknown return op");
}
if (instrumentedProfiling())
@ -3257,7 +3257,7 @@ IonBuilder::jsop_bitop(JSOp op)
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected bitop");
MOZ_ASSUME_UNREACHABLE("unexpected bitop");
}
current->add(ins);
@ -3314,7 +3314,7 @@ IonBuilder::jsop_binary(JSOp op, MDefinition *left, MDefinition *right)
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected binary opcode");
MOZ_ASSUME_UNREACHABLE("unexpected binary opcode");
}
bool overflowed = types::HasOperationOverflowed(script(), pc);
@ -6076,7 +6076,7 @@ ion::TypeSetIncludes(types::TypeSet *types, MIRType input, types::TypeSet *input
return types->unknown() || (inputTypes && inputTypes->isSubset(types));
default:
MOZ_ASSUME_NOT_REACHED("Bad input type");
MOZ_ASSUME_UNREACHABLE("Bad input type");
}
}
@ -6584,7 +6584,7 @@ IonBuilder::jsop_getelem_typed(int arrayType)
knownType = MIRType_Double;
break;
default:
MOZ_ASSUME_NOT_REACHED("Unknown typed array type");
MOZ_ASSUME_UNREACHABLE("Unknown typed array type");
}
// Get the length.
@ -6630,7 +6630,7 @@ IonBuilder::jsop_getelem_typed(int arrayType)
needsBarrier = false;
break;
default:
MOZ_ASSUME_NOT_REACHED("Unknown typed array type");
MOZ_ASSUME_UNREACHABLE("Unknown typed array type");
}
// Assume we will read out-of-bound values. In this case the

2
js/src/ion/IonCaches.cpp
View File

@ -2834,7 +2834,7 @@ IsCacheableScopeChain(JSObject *scopeChain, JSObject *holder)
}
}
MOZ_ASSUME_NOT_REACHED();
MOZ_ASSUME_UNREACHABLE();
}
JSObject *

2
js/src/ion/IonCaches.h
View File

@ -38,7 +38,7 @@ class IonCacheVisitor
public:
#define VISIT_INS(op) \
virtual bool visit##op##IC(CodeGenerator *codegen, op##IC *) { \
MOZ_ASSUME_NOT_REACHED("NYI: " #op "IC"); \
MOZ_ASSUME_UNREACHABLE("NYI: " #op "IC"); \
}
IONCACHE_KIND_LIST(VISIT_INS)

4
js/src/ion/IonCompartment.h
View File

@ -290,7 +290,7 @@ class IonCompartment
switch (mode) {
case SequentialExecution: return rt->argumentsRectifier_;
case ParallelExecution: return rt->parallelArgumentsRectifier_;
default: MOZ_ASSUME_NOT_REACHED("No such execution mode");
default: MOZ_ASSUME_UNREACHABLE("No such execution mode");
}
}
@ -326,7 +326,7 @@ class IonCompartment
switch (mode) {
case SequentialExecution: return stringConcatStub_;
case ParallelExecution: return parallelStringConcatStub_;
default: MOZ_ASSUME_NOT_REACHED("No such execution mode");
default: MOZ_ASSUME_UNREACHABLE("No such execution mode");
}
}

2
js/src/ion/IonFrames-inl.h
View File

@ -47,7 +47,7 @@ SizeOfFramePrefix(FrameType type)
case IonFrame_Osr:
return IonOsrFrameLayout::Size();
default:
MOZ_ASSUME_NOT_REACHED("unknown frame type");
MOZ_ASSUME_UNREACHABLE("unknown frame type");
}
}

20
js/src/ion/IonFrames.cpp
View File

@ -394,7 +394,7 @@ HandleException(JSContext *cx, const IonFrameIterator &frame, ResumeFromExceptio
return;
default:
MOZ_ASSUME_NOT_REACHED("Invalid trap status");
MOZ_ASSUME_UNREACHABLE("Invalid trap status");
}
}
@ -456,7 +456,7 @@ HandleException(JSContext *cx, const IonFrameIterator &frame, ResumeFromExceptio
break;
default:
MOZ_ASSUME_NOT_REACHED("Invalid try note");
MOZ_ASSUME_UNREACHABLE("Invalid try note");
}
}
@ -627,7 +627,7 @@ MarkCalleeToken(JSTracer *trc, CalleeToken token)
return CalleeToToken(script);
}
default:
MOZ_ASSUME_NOT_REACHED("unknown callee token type");
MOZ_ASSUME_UNREACHABLE("unknown callee token type");
}
}
@ -777,7 +777,7 @@ JitActivationIterator::jitStackRange(uintptr_t *&min, uintptr_t *&end)
if (exitFrame->isWrapperExit() && f->outParam == Type_Handle) {
switch (f->outParamRootType) {
case VMFunction::RootNone:
MOZ_ASSUME_NOT_REACHED("Handle outparam must have root type");
MOZ_ASSUME_UNREACHABLE("Handle outparam must have root type");
case VMFunction::RootObject:
case VMFunction::RootString:
case VMFunction::RootPropertyName:
@ -919,7 +919,7 @@ MarkIonExitFrame(JSTracer *trc, const IonFrameIterator &frame)
if (f->outParam == Type_Handle) {
switch (f->outParamRootType) {
case VMFunction::RootNone:
MOZ_ASSUME_NOT_REACHED("Handle outparam must have root type");
MOZ_ASSUME_UNREACHABLE("Handle outparam must have root type");
case VMFunction::RootObject:
gc::MarkObjectRoot(trc, footer->outParam<JSObject *>(), "ion-vm-out");
break;
@ -958,7 +958,7 @@ MarkJitActivation(JSTracer *trc, const JitActivationIterator &activations)
MarkIonJSFrame(trc, frames);
break;
case IonFrame_Unwound_OptimizedJS:
MOZ_ASSUME_NOT_REACHED("invalid");
MOZ_ASSUME_UNREACHABLE("invalid");
case IonFrame_Rectifier:
case IonFrame_Unwound_Rectifier:
break;
@ -968,7 +968,7 @@ MarkJitActivation(JSTracer *trc, const JitActivationIterator &activations)
// dead.
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected frame type");
MOZ_ASSUME_UNREACHABLE("unexpected frame type");
}
}
}
@ -1110,7 +1110,7 @@ SnapshotIterator::FromTypedPayload(JSValueType type, uintptr_t payload)
case JSVAL_TYPE_OBJECT:
return ObjectValue(*reinterpret_cast<JSObject *>(payload));
default:
MOZ_ASSUME_NOT_REACHED("unexpected type - needs payload");
MOZ_ASSUME_UNREACHABLE("unexpected type - needs payload");
}
}
@ -1179,7 +1179,7 @@ SnapshotIterator::slotValue(const Slot &slot)
return ionScript_->getConstant(slot.constantIndex());
default:
MOZ_ASSUME_NOT_REACHED("huh?");
MOZ_ASSUME_UNREACHABLE("huh?");
}
}
@ -1198,7 +1198,7 @@ IonFrameIterator::ionScript() const
case CalleeToken_ParallelFunction:
return script()->parallelIonScript();
default:
MOZ_ASSUME_NOT_REACHED("unknown callee token type");
MOZ_ASSUME_UNREACHABLE("unknown callee token type");
}
}

2
js/src/ion/IonFrames.h
View File

@ -90,7 +90,7 @@ ScriptFromCalleeToken(CalleeToken token)
case CalleeToken_ParallelFunction:
return CalleeTokenToParallelFunction(token)->nonLazyScript();
}
MOZ_ASSUME_NOT_REACHED("invalid callee token tag");
MOZ_ASSUME_UNREACHABLE("invalid callee token tag");
}
// In between every two frames lies a small header describing both frames. This

16
js/src/ion/IonMacroAssembler.cpp
View File

@ -307,7 +307,7 @@ MacroAssembler::loadFromTypedArray(int arrayType, const T &src, AnyRegister dest
canonicalizeDouble(dest.fpu());
break;
default:
MOZ_ASSUME_NOT_REACHED("Invalid typed array type");
MOZ_ASSUME_UNREACHABLE("Invalid typed array type");
}
}
@ -362,7 +362,7 @@ MacroAssembler::loadFromTypedArray(int arrayType, const T &src, const ValueOpera
boxDouble(ScratchFloatReg, dest);
break;
default:
MOZ_ASSUME_NOT_REACHED("Invalid typed array type");
MOZ_ASSUME_UNREACHABLE("Invalid typed array type");
}
}
@ -1049,7 +1049,7 @@ MacroAssembler::enterExitFrameAndLoadContext(const VMFunction *f, Register cxReg
enterParallelExitFrameAndLoadSlice(f, cxReg, scratch);
break;
default:
MOZ_ASSUME_NOT_REACHED("No such execution mode");
MOZ_ASSUME_UNREACHABLE("No such execution mode");
}
}
@ -1071,7 +1071,7 @@ MacroAssembler::handleFailure(ExecutionMode executionMode)
handler = JS_FUNC_TO_DATA_PTR(void *, ion::HandleParallelFailure);
break;
default:
MOZ_ASSUME_NOT_REACHED("No such execution mode");
MOZ_ASSUME_UNREACHABLE("No such execution mode");
}
MacroAssemblerSpecific::handleFailureWithHandler(handler);
@ -1091,7 +1091,7 @@ MacroAssembler::tagCallee(Register callee, ExecutionMode mode)
orPtr(Imm32(CalleeToken_ParallelFunction), callee);
return;
default:
MOZ_ASSUME_NOT_REACHED("No such execution mode");
MOZ_ASSUME_UNREACHABLE("No such execution mode");
}
}
@ -1106,7 +1106,7 @@ MacroAssembler::clearCalleeTag(Register callee, ExecutionMode mode)
andPtr(Imm32(~0x3), callee);
return;
default:
MOZ_ASSUME_NOT_REACHED("No such execution mode");
MOZ_ASSUME_UNREACHABLE("No such execution mode");
}
}
@ -1255,7 +1255,7 @@ MacroAssembler::PushEmptyRooted(VMFunction::RootType rootType)
{
switch (rootType) {
case VMFunction::RootNone:
MOZ_ASSUME_NOT_REACHED("Handle must have root type");
MOZ_ASSUME_UNREACHABLE("Handle must have root type");
case VMFunction::RootObject:
case VMFunction::RootString:
case VMFunction::RootPropertyName:
@ -1275,7 +1275,7 @@ MacroAssembler::popRooted(VMFunction::RootType rootType, Register cellReg,
{
switch (rootType) {
case VMFunction::RootNone:
MOZ_ASSUME_NOT_REACHED("Handle must have root type");
MOZ_ASSUME_UNREACHABLE("Handle must have root type");
case VMFunction::RootObject:
case VMFunction::RootString:
case VMFunction::RootPropertyName:

12
js/src/ion/IonMacroAssembler.h
View File

@ -189,7 +189,7 @@ class MacroAssembler : public MacroAssemblerSpecific
case MIRType_Object: return testObject(cond, val);
case MIRType_Double: return testDouble(cond, val);
default:
MOZ_ASSUME_NOT_REACHED("Bad MIRType");
MOZ_ASSUME_UNREACHABLE("Bad MIRType");
}
}
@ -546,7 +546,7 @@ class MacroAssembler : public MacroAssemblerSpecific
store32(value, dest);
break;
default:
MOZ_ASSUME_NOT_REACHED("Invalid typed array type");
MOZ_ASSUME_UNREACHABLE("Invalid typed array type");
}
}
@ -561,7 +561,7 @@ class MacroAssembler : public MacroAssemblerSpecific
storeDouble(value, dest);
break;
default:
MOZ_ASSUME_NOT_REACHED("Invalid typed array type");
MOZ_ASSUME_UNREACHABLE("Invalid typed array type");
}
}
@ -944,7 +944,7 @@ JSOpToDoubleCondition(JSOp op)
case JSOP_GE:
return Assembler::DoubleGreaterThanOrEqual;
default:
MOZ_ASSUME_NOT_REACHED("Unexpected comparison operation");
MOZ_ASSUME_UNREACHABLE("Unexpected comparison operation");
}
}
@ -971,7 +971,7 @@ JSOpToCondition(JSOp op, bool isSigned)
case JSOP_GE:
return Assembler::GreaterThanOrEqual;
default:
MOZ_ASSUME_NOT_REACHED("Unrecognized comparison operation");
MOZ_ASSUME_UNREACHABLE("Unrecognized comparison operation");
}
} else {
switch (op) {
@ -990,7 +990,7 @@ JSOpToCondition(JSOp op, bool isSigned)
case JSOP_GE:
return Assembler::AboveOrEqual;
default:
MOZ_ASSUME_NOT_REACHED("Unrecognized comparison operation");
MOZ_ASSUME_UNREACHABLE("Unrecognized comparison operation");
}
}
}

6
js/src/ion/IonTypes.h
View File

@ -67,7 +67,7 @@ BailoutKindString(BailoutKind kind)
case Bailout_CachedShapeGuard:
return "Bailout_CachedShapeGuard";
default:
MOZ_ASSUME_NOT_REACHED("Invalid BailoutKind");
MOZ_ASSUME_UNREACHABLE("Invalid BailoutKind");
}
}
#endif
@ -117,7 +117,7 @@ MIRTypeFromValueType(JSValueType type)
case JSVAL_TYPE_UNKNOWN:
return MIRType_Value;
default:
MOZ_ASSUME_NOT_REACHED("unexpected jsval type");
MOZ_ASSUME_UNREACHABLE("unexpected jsval type");
}
}
@ -184,7 +184,7 @@ StringFromMIRType(MIRType type)
case MIRType_ForkJoinSlice:
return "ForkJoinSlice";
default:
MOZ_ASSUME_NOT_REACHED("Unknown MIRType.");
MOZ_ASSUME_UNREACHABLE("Unknown MIRType.");
}
}

16
js/src/ion/LIR-Common.h
View File

@ -4480,19 +4480,19 @@ class LPhi : public LInstruction
return 0;
}
LDefinition *getTemp(size_t index) {
MOZ_ASSUME_NOT_REACHED("no temps");
MOZ_ASSUME_UNREACHABLE("no temps");
}
void setTemp(size_t index, const LDefinition &temp) {
MOZ_ASSUME_NOT_REACHED("no temps");
MOZ_ASSUME_UNREACHABLE("no temps");
}
size_t numSuccessors() const {
return 0;
}
MBasicBlock *getSuccessor(size_t i) const {
MOZ_ASSUME_NOT_REACHED("no successors");
MOZ_ASSUME_UNREACHABLE("no successors");
}
void setSuccessor(size_t i, MBasicBlock *) {
MOZ_ASSUME_NOT_REACHED("no successors");
MOZ_ASSUME_UNREACHABLE("no successors");
}
virtual void printInfo(FILE *fp) {
@ -4791,19 +4791,19 @@ class LAsmJSCall : public LInstruction
return 0;
}
LDefinition *getTemp(size_t index) {
MOZ_ASSUME_NOT_REACHED("no temps");
MOZ_ASSUME_UNREACHABLE("no temps");
}
void setTemp(size_t index, const LDefinition &a) {
MOZ_ASSUME_NOT_REACHED("no temps");
MOZ_ASSUME_UNREACHABLE("no temps");
}
size_t numSuccessors() const {
return 0;
}
MBasicBlock *getSuccessor(size_t i) const {
MOZ_ASSUME_NOT_REACHED("no successors");
MOZ_ASSUME_UNREACHABLE("no successors");
}
void setSuccessor(size_t i, MBasicBlock *) {
MOZ_ASSUME_NOT_REACHED("no successors");
MOZ_ASSUME_UNREACHABLE("no successors");
}
};

2
js/src/ion/LIR.cpp
View File

@ -270,7 +270,7 @@ LAllocation::toString() const
PrintUse(buf, sizeof(buf), toUse());
return buf;
default:
MOZ_ASSUME_NOT_REACHED("what?");
MOZ_ASSUME_UNREACHABLE("what?");
}
}
#endif // DEBUG

4
js/src/ion/LIR.h
View File

@ -550,7 +550,7 @@ class LDefinition
case MIRType_ForkJoinSlice:
return LDefinition::GENERAL;
default:
MOZ_ASSUME_NOT_REACHED("unexpected type");
MOZ_ASSUME_UNREACHABLE("unexpected type");
}
}
};
@ -716,7 +716,7 @@ class LInstructionVisitor
{}
public:
#define VISIT_INS(op) virtual bool visit##op(L##op *) { MOZ_ASSUME_NOT_REACHED("NYI: " #op); }
#define VISIT_INS(op) virtual bool visit##op(L##op *) { MOZ_ASSUME_UNREACHABLE("NYI: " #op); }
LIR_OPCODE_LIST(VISIT_INS)
#undef VISIT_INS
};

2
js/src/ion/LiveRangeAllocator.cpp
View File

@ -30,7 +30,7 @@ Requirement::priority() const
return 2;
default:
MOZ_ASSUME_NOT_REACHED("Unknown requirement kind.");
MOZ_ASSUME_UNREACHABLE("Unknown requirement kind.");
}
}

4
js/src/ion/LiveRangeAllocator.h
View File

@ -117,7 +117,7 @@ UseCompatibleWith(const LUse *use, LAllocation alloc)
// UsePosition is only used as hint.
return alloc.isRegister();
default:
MOZ_ASSUME_NOT_REACHED("Unknown use policy");
MOZ_ASSUME_UNREACHABLE("Unknown use policy");
}
}
@ -146,7 +146,7 @@ DefinitionCompatibleWith(LInstruction *ins, const LDefinition *def, LAllocation
case LDefinition::PASSTHROUGH:
return true;
default:
MOZ_ASSUME_NOT_REACHED("Unknown definition policy");
MOZ_ASSUME_UNREACHABLE("Unknown definition policy");
}
}

24
js/src/ion/Lowering.cpp
View File

@ -843,7 +843,7 @@ LIRGenerator::visitCompare(MCompare *comp)
return define(lir, comp);
}
MOZ_ASSUME_NOT_REACHED("Unrecognized compare type.");
MOZ_ASSUME_UNREACHABLE("Unrecognized compare type.");
}
static void
@ -1451,7 +1451,7 @@ LIRGenerator::visitToDouble(MToDouble *convert)
default:
// Objects might be effectful.
// Strings are complicated - we don't handle them yet.
MOZ_ASSUME_NOT_REACHED("unexpected type");
MOZ_ASSUME_UNREACHABLE("unexpected type");
}
}
@ -1497,7 +1497,7 @@ LIRGenerator::visitToInt32(MToInt32 *convert)
return false;
default:
MOZ_ASSUME_NOT_REACHED("unexpected type");
MOZ_ASSUME_UNREACHABLE("unexpected type");
}
}
@ -1529,7 +1529,7 @@ LIRGenerator::visitTruncateToInt32(MTruncateToInt32 *truncate)
default:
// Objects might be effectful.
// Strings are complicated - we don't handle them yet.
MOZ_ASSUME_NOT_REACHED("unexpected type");
MOZ_ASSUME_UNREACHABLE("unexpected type");
}
}
@ -1542,7 +1542,7 @@ LIRGenerator::visitToString(MToString *ins)
case MIRType_Null:
case MIRType_Undefined:
case MIRType_Boolean:
MOZ_ASSUME_NOT_REACHED("NYI: Lower MToString");
MOZ_ASSUME_UNREACHABLE("NYI: Lower MToString");
case MIRType_Double: {
LDoubleToString *lir = new LDoubleToString(useRegister(opd), temp());
@ -1562,7 +1562,7 @@ LIRGenerator::visitToString(MToString *ins)
default:
// Objects might be effectful. (see ToPrimitive)
MOZ_ASSUME_NOT_REACHED("unexpected type");
MOZ_ASSUME_UNREACHABLE("unexpected type");
}
}
@ -1655,7 +1655,7 @@ LIRGenerator::visitLoadSlot(MLoadSlot *ins)
case MIRType_Undefined:
case MIRType_Null:
MOZ_ASSUME_NOT_REACHED("typed load must have a payload");
MOZ_ASSUME_UNREACHABLE("typed load must have a payload");
default:
return define(new LLoadSlotT(useRegister(ins->slots())), ins);
@ -1900,7 +1900,7 @@ LIRGenerator::visitNot(MNot *ins)
}
default:
MOZ_ASSUME_NOT_REACHED("Unexpected MIRType.");
MOZ_ASSUME_UNREACHABLE("Unexpected MIRType.");
}
}
@ -1968,7 +1968,7 @@ LIRGenerator::visitLoadElement(MLoadElement *ins)
}
case MIRType_Undefined:
case MIRType_Null:
MOZ_ASSUME_NOT_REACHED("typed load must have a payload");
MOZ_ASSUME_UNREACHABLE("typed load must have a payload");
default:
{
@ -2074,7 +2074,7 @@ LIRGenerator::visitArrayPopShift(MArrayPopShift *ins)
}
case MIRType_Undefined:
case MIRType_Null:
MOZ_ASSUME_NOT_REACHED("typed load must have a payload");
MOZ_ASSUME_UNREACHABLE("typed load must have a payload");
default:
{
@ -2169,7 +2169,7 @@ LIRGenerator::visitClampToUint8(MClampToUint8 *ins)
}
default:
MOZ_ASSUME_NOT_REACHED("unexpected type");
MOZ_ASSUME_UNREACHABLE("unexpected type");
}
}
@ -2715,7 +2715,7 @@ LIRGenerator::visitAsmJSReturn(MAsmJSReturn *ins)
else if (rval->type() == MIRType_Int32)
lir->setOperand(0, useFixed(rval, ReturnReg));
else
MOZ_ASSUME_NOT_REACHED("Unexpected asm.js return type");
MOZ_ASSUME_UNREACHABLE("Unexpected asm.js return type");
return add(lir);
}

6
js/src/ion/MCallOptimize.cpp
View File

@ -1017,7 +1017,7 @@ IonBuilder::inlineUnsafeSetElement(CallInfo &callInfo)
continue;
}
MOZ_ASSUME_NOT_REACHED("Element access not dense array nor typed array");
MOZ_ASSUME_UNREACHABLE("Element access not dense array nor typed array");
}
return InliningStatus_Inlined;
@ -1088,7 +1088,7 @@ IonBuilder::inlineForceSequentialOrInParallelSection(CallInfo &callInfo)
return InliningStatus_Inlined;
}
MOZ_ASSUME_NOT_REACHED("Invalid execution mode");
MOZ_ASSUME_UNREACHABLE("Invalid execution mode");
}
IonBuilder::InliningStatus
@ -1262,7 +1262,7 @@ IonBuilder::inlineNewDenseArray(CallInfo &callInfo)
return inlineNewDenseArrayForParallelExecution(callInfo);
}
MOZ_ASSUME_NOT_REACHED("unknown ExecutionMode");
MOZ_ASSUME_UNREACHABLE("unknown ExecutionMode");
}
IonBuilder::InliningStatus

20
js/src/ion/MIR.cpp
View File

@ -116,7 +116,7 @@ EvaluateConstantOperands(MBinaryInstruction *ins, bool *ptypeChange = NULL)
ret.setNumber(NumberMod(lhs.toNumber(), rhs.toNumber()));
break;
default:
MOZ_ASSUME_NOT_REACHED("NYI");
MOZ_ASSUME_UNREACHABLE("NYI");
}
if (ins->type() != MIRTypeFromValue(ret)) {
@ -436,7 +436,7 @@ MConstant::printOpcode(FILE *fp)
fprintf(fp, "magic");
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected type");
MOZ_ASSUME_UNREACHABLE("unexpected type");
}
}
@ -1484,7 +1484,7 @@ MCompare::inputType()
case Compare_Value:
return MIRType_Value;
default:
MOZ_ASSUME_NOT_REACHED("No known conversion");
MOZ_ASSUME_UNREACHABLE("No known conversion");
}
}
@ -1934,7 +1934,7 @@ MCompare::tryFold(bool *result)
*result = (op == JSOP_NE || op == JSOP_STRICTNE);
return true;
default:
MOZ_ASSUME_NOT_REACHED("Unexpected type");
MOZ_ASSUME_UNREACHABLE("Unexpected type");
}
}
@ -1955,9 +1955,9 @@ MCompare::tryFold(bool *result)
return true;
case MIRType_Boolean:
// Int32 specialization should handle this.
MOZ_ASSUME_NOT_REACHED("Wrong specialization");
MOZ_ASSUME_UNREACHABLE("Wrong specialization");
default:
MOZ_ASSUME_NOT_REACHED("Unexpected type");
MOZ_ASSUME_UNREACHABLE("Unexpected type");
}
}
@ -1978,9 +1978,9 @@ MCompare::tryFold(bool *result)
return true;
case MIRType_String:
// Compare_String specialization should handle this.
MOZ_ASSUME_NOT_REACHED("Wrong specialization");
MOZ_ASSUME_UNREACHABLE("Wrong specialization");
default:
MOZ_ASSUME_NOT_REACHED("Unexpected type");
MOZ_ASSUME_UNREACHABLE("Unexpected type");
}
}
@ -2032,7 +2032,7 @@ MCompare::evaluateConstantOperands(bool *result)
*result = (comp != 0);
break;
default:
MOZ_ASSUME_NOT_REACHED("Unexpected op.");
MOZ_ASSUME_UNREACHABLE("Unexpected op.");
}
return true;
@ -2064,7 +2064,7 @@ MCompare::evaluateConstantOperands(bool *result)
*result = (lhsUint != rhsUint);
break;
default:
MOZ_ASSUME_NOT_REACHED("Unexpected op.");
MOZ_ASSUME_UNREACHABLE("Unexpected op.");
}
return true;

6
js/src/ion/MIR.h
View File

@ -3459,7 +3459,7 @@ class MDiv : public MBinaryArithInstruction
void analyzeEdgeCasesBackward();
double getIdentity() {
MOZ_ASSUME_NOT_REACHED("not used");
MOZ_ASSUME_UNREACHABLE("not used");
}
bool canBeNegativeZero() {
@ -3506,7 +3506,7 @@ class MMod : public MBinaryArithInstruction
MDefinition *foldsTo(bool useValueNumbers);
double getIdentity() {
MOZ_ASSUME_NOT_REACHED("not used");
MOZ_ASSUME_UNREACHABLE("not used");
}
bool fallible();
@ -5922,7 +5922,7 @@ class MPolyInlineDispatch : public MControlInstruction, public SingleObjectPolic
if (getFunction(i) == func)
return getFunctionBlock(i);
}
MOZ_ASSUME_NOT_REACHED("Bad function lookup!");
MOZ_ASSUME_UNREACHABLE("Bad function lookup!");
}
InlinePropertyTable *propTable() const {

6
js/src/ion/MIRGraph.cpp
View File

@ -921,7 +921,7 @@ MBasicBlock::getSuccessorIndex(MBasicBlock *block) const
if (getSuccessor(i) == block)
return i;
}
MOZ_ASSUME_NOT_REACHED("Invalid successor");
MOZ_ASSUME_UNREACHABLE("Invalid successor");
}
void
@ -953,7 +953,7 @@ MBasicBlock::replacePredecessor(MBasicBlock *old, MBasicBlock *split)
}
}
MOZ_ASSUME_NOT_REACHED("predecessor was not found");
MOZ_ASSUME_UNREACHABLE("predecessor was not found");
}
void
@ -990,7 +990,7 @@ MBasicBlock::removePredecessor(MBasicBlock *pred)
return;
}
MOZ_ASSUME_NOT_REACHED("predecessor was not found");
MOZ_ASSUME_UNREACHABLE("predecessor was not found");
}
void

2
js/src/ion/MOpcodes.h
View File

@ -213,7 +213,7 @@ class MInstructionVisitor // interface i.e. pure abstract class
class MInstructionVisitorWithDefaults : public MInstructionVisitor
{
public:
#define VISIT_INS(op) virtual bool visit##op(M##op *) { MOZ_ASSUME_NOT_REACHED("NYI: " #op); }
#define VISIT_INS(op) virtual bool visit##op(M##op *) { MOZ_ASSUME_UNREACHABLE("NYI: " #op); }
MIR_OPCODE_LIST(VISIT_INS)
#undef VISIT_INS
};

4
js/src/ion/Snapshots.cpp
View File

@ -268,7 +268,7 @@ SnapshotReader::readSlot()
}
}
MOZ_ASSUME_NOT_REACHED("huh?");
MOZ_ASSUME_UNREACHABLE("huh?");
}
SnapshotOffset
@ -377,7 +377,7 @@ ValTypeToString(JSValueType type)
case JSVAL_TYPE_MAGIC:
return "magic";
default:
MOZ_ASSUME_NOT_REACHED("no payload");
MOZ_ASSUME_UNREACHABLE("no payload");
}
}

2
js/src/ion/StupidAllocator.cpp
View File

@ -36,7 +36,7 @@ StupidAllocator::registerIndex(AnyRegister reg)
if (reg == registers[i].reg)
return i;
}
MOZ_ASSUME_NOT_REACHED("Bad register");
MOZ_ASSUME_UNREACHABLE("Bad register");
}
bool

6
js/src/ion/TypePolicy.cpp
View File

@ -209,7 +209,7 @@ ComparePolicy::adjustInputs(MInstruction *def)
replace = MUnbox::New(in, MIRType_String, MUnbox::Infallible);
break;
default:
MOZ_ASSUME_NOT_REACHED("Unknown compare specialization");
MOZ_ASSUME_UNREACHABLE("Unknown compare specialization");
}
def->block()->insertBefore(def, replace);
@ -490,7 +490,7 @@ StoreTypedArrayPolicy::adjustValueInput(MInstruction *ins, int arrayType,
value = boxAt(ins, value);
break;
default:
MOZ_ASSUME_NOT_REACHED("Unexpected type");
MOZ_ASSUME_UNREACHABLE("Unexpected type");
}
if (value != curValue) {
@ -527,7 +527,7 @@ StoreTypedArrayPolicy::adjustValueInput(MInstruction *ins, int arrayType,
}
break;
default:
MOZ_ASSUME_NOT_REACHED("Invalid array type");
MOZ_ASSUME_UNREACHABLE("Invalid array type");
}
if (value != curValue) {

6
js/src/ion/VMFunctions.cpp
View File

@ -633,7 +633,7 @@ DebugPrologue(JSContext *cx, BaselineFrame *frame, JSBool *mustReturn)
return false;
default:
MOZ_ASSUME_NOT_REACHED("Invalid trap status");
MOZ_ASSUME_UNREACHABLE("Invalid trap status");
}
}
@ -767,7 +767,7 @@ HandleDebugTrap(JSContext *cx, BaselineFrame *frame, uint8_t *retAddr, JSBool *m
return false;
default:
MOZ_ASSUME_NOT_REACHED("Invalid trap status");
MOZ_ASSUME_UNREACHABLE("Invalid trap status");
}
return true;
@ -805,7 +805,7 @@ OnDebuggerStatement(JSContext *cx, BaselineFrame *frame, jsbytecode *pc, JSBool
return false;
default:
MOZ_ASSUME_NOT_REACHED("Invalid trap status");
MOZ_ASSUME_UNREACHABLE("Invalid trap status");
}
}

26
js/src/ion/arm/Assembler-arm.cpp
View File

@ -55,7 +55,7 @@ ABIArgGenerator::next(MIRType type)
floatRegIndex_++;
break;
default:
MOZ_ASSUME_NOT_REACHED("Unexpected argument type");
MOZ_ASSUME_UNREACHABLE("Unexpected argument type");
}
return current_;
#else
@ -87,7 +87,7 @@ ABIArgGenerator::next(MIRType type)
}
break;
default:
MOZ_ASSUME_NOT_REACHED("Unexpected argument type");
MOZ_ASSUME_UNREACHABLE("Unexpected argument type");
}
return current_;
#endif
@ -730,7 +730,7 @@ Assembler::getCF32Target(Iter *iter)
}
MOZ_ASSUME_NOT_REACHED("unsupported branch relocation");
MOZ_ASSUME_UNREACHABLE("unsupported branch relocation");
}
uintptr_t
@ -793,7 +793,7 @@ Assembler::getPtr32Target(Iter *start, Register *dest, RelocStyle *style)
uint32_t **ptr = (uint32_t **)&dataInst[offset + 8];
return *ptr;
}
MOZ_ASSUME_NOT_REACHED("unsupported relocation");
MOZ_ASSUME_UNREACHABLE("unsupported relocation");
}
static IonCode *
@ -1679,7 +1679,7 @@ Assembler::as_extdtr(LoadStore ls, int size, bool IsSigned, Index mode,
extra_bits1 = 0;
break;
default:
MOZ_ASSUME_NOT_REACHED("SAY WHAT?");
MOZ_ASSUME_UNREACHABLE("SAY WHAT?");
}
return writeInst(extra_bits2 << 5 | extra_bits1 << 20 | 0x90 |
addr.encode() | RT(rt) | mode | c, dest);
@ -1763,7 +1763,7 @@ Assembler::patchConstantPoolLoad(void* loadAddr, void* constPoolAddr)
int offset = (char *)constPoolAddr - (char *)loadAddr;
switch(data.getLoadType()) {
case PoolHintData::poolBOGUS:
MOZ_ASSUME_NOT_REACHED("bogus load type!");
MOZ_ASSUME_UNREACHABLE("bogus load type!");
case PoolHintData::poolDTR:
dummy->as_dtr(IsLoad, 32, Offset, data.getReg(),
DTRAddr(pc, DtrOffImm(offset+4*data.getIndex() - 8)), data.getCond(), instAddr);
@ -1801,7 +1801,7 @@ Assembler::placeConstantPoolBarrier(int offset)
// BUG: 700526
// this is still an active path, however, we do not hit it in the test
// suite at all.
MOZ_ASSUME_NOT_REACHED("ARMAssembler holdover");
MOZ_ASSUME_UNREACHABLE("ARMAssembler holdover");
#if 0
offset = (offset - sizeof(ARMWord)) >> 2;
ASSERT((offset <= BOFFSET_MAX && offset >= BOFFSET_MIN));
@ -2001,21 +2001,21 @@ Assembler::as_vnmul(VFPRegister vd, VFPRegister vn, VFPRegister vm,
Condition c)
{
return as_vfp_float(vd, vn, vm, opv_mul, c);
MOZ_ASSUME_NOT_REACHED("Feature NYI");
MOZ_ASSUME_UNREACHABLE("Feature NYI");
}
BufferOffset
Assembler::as_vnmla(VFPRegister vd, VFPRegister vn, VFPRegister vm,
Condition c)
{
MOZ_ASSUME_NOT_REACHED("Feature NYI");
MOZ_ASSUME_UNREACHABLE("Feature NYI");
}
BufferOffset
Assembler::as_vnmls(VFPRegister vd, VFPRegister vn, VFPRegister vm,
Condition c)
{
MOZ_ASSUME_NOT_REACHED("Feature NYI");
MOZ_ASSUME_UNREACHABLE("Feature NYI");
return BufferOffset();
}
@ -2203,7 +2203,7 @@ Assembler::as_vimm(VFPRegister vd, VFPImm imm, Condition c)
// Don't know how to handle this right now.
if (!vd.isDouble())
MOZ_ASSUME_NOT_REACHED("non-double immediate");
MOZ_ASSUME_UNREACHABLE("non-double immediate");
return writeVFPInst(sz, c | imm.encode() | VD(vd) | 0x02B00000);
@ -2258,7 +2258,7 @@ Assembler::bind(Label *label, BufferOffset boff)
else if (branch.is<InstBLImm>())
as_bl(dest.diffB<BOffImm>(b), c, b);
else
MOZ_ASSUME_NOT_REACHED("crazy fixup!");
MOZ_ASSUME_UNREACHABLE("crazy fixup!");
b = next;
} while (more);
}
@ -2316,7 +2316,7 @@ Assembler::retarget(Label *label, Label *target)
else if (branch.is<InstBLImm>())
as_bl(BOffImm(prev), c, labelBranchOffset);
else
MOZ_ASSUME_NOT_REACHED("crazy fixup!");
MOZ_ASSUME_UNREACHABLE("crazy fixup!");
} else {
// The target is unbound and unused. We can just take the head of
// the list hanging off of label, and dump that into target.

4
js/src/ion/arm/BaselineIC-arm.cpp
View File

@ -196,7 +196,7 @@ ICBinaryArith_Int32::Compiler::generateStubCode(MacroAssembler &masm)
}
break;
default:
MOZ_ASSUME_NOT_REACHED("Unhandled op for BinaryArith_Int32.");
MOZ_ASSUME_UNREACHABLE("Unhandled op for BinaryArith_Int32.");
}
EmitReturnFromIC(masm);
@ -247,7 +247,7 @@ ICUnaryArith_Int32::Compiler::generateStubCode(MacroAssembler &masm)
masm.ma_rsb(R0.payloadReg(), Imm32(0), R0.payloadReg());
break;
default:
MOZ_ASSUME_NOT_REACHED("Unexpected op");
MOZ_ASSUME_UNREACHABLE("Unexpected op");
}
EmitReturnFromIC(masm);

18
js/src/ion/arm/CodeGenerator-arm.cpp
View File

@ -215,7 +215,7 @@ CodeGeneratorARM::bailoutFrom(Label *label, LSnapshot *snapshot)
case SequentialExecution:
break;
default:
MOZ_ASSUME_NOT_REACHED("No such execution mode");
MOZ_ASSUME_UNREACHABLE("No such execution mode");
}
if (!encode(snapshot))
@ -803,7 +803,7 @@ CodeGeneratorARM::visitBitOpI(LBitOpI *ins)
masm.ma_and(ToRegister(rhs), ToRegister(lhs), ToRegister(dest));
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected binary opcode");
MOZ_ASSUME_UNREACHABLE("unexpected binary opcode");
}
return true;
@ -845,7 +845,7 @@ CodeGeneratorARM::visitShiftI(LShiftI *ins)
}
break;
default:
MOZ_ASSUME_NOT_REACHED("Unexpected shift op");
MOZ_ASSUME_UNREACHABLE("Unexpected shift op");
}
} else {
// The shift amounts should be AND'ed into the 0-31 range since arm
@ -870,7 +870,7 @@ CodeGeneratorARM::visitShiftI(LShiftI *ins)
}
break;
default:
MOZ_ASSUME_NOT_REACHED("Unexpected shift op");
MOZ_ASSUME_UNREACHABLE("Unexpected shift op");
}
}
@ -1069,7 +1069,7 @@ CodeGeneratorARM::visitMathD(LMathD *math)
masm.ma_vdiv(ToFloatRegister(src1), ToFloatRegister(src2), ToFloatRegister(output));
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected opcode");
MOZ_ASSUME_UNREACHABLE("unexpected opcode");
}
return true;
}
@ -1702,13 +1702,13 @@ getBase(U *mir)
bool
CodeGeneratorARM::visitLoadTypedArrayElementStatic(LLoadTypedArrayElementStatic *ins)
{
MOZ_ASSUME_NOT_REACHED("NYI");
MOZ_ASSUME_UNREACHABLE("NYI");
}
bool
CodeGeneratorARM::visitStoreTypedArrayElementStatic(LStoreTypedArrayElementStatic *ins)
{
MOZ_ASSUME_NOT_REACHED("NYI");
MOZ_ASSUME_UNREACHABLE("NYI");
}
bool
@ -1730,7 +1730,7 @@ CodeGeneratorARM::visitAsmJSLoadHeap(LAsmJSLoadHeap *ins)
isFloat = true;
size = 32;
break;
default: MOZ_ASSUME_NOT_REACHED("unexpected array type");
default: MOZ_ASSUME_UNREACHABLE("unexpected array type");
}
Register index = ToRegister(ins->ptr());
BufferOffset bo = masm.ma_BoundsCheck(index);
@ -1770,7 +1770,7 @@ CodeGeneratorARM::visitAsmJSStoreHeap(LAsmJSStoreHeap *ins)
isFloat = true;
size = 32;
break;
default: MOZ_ASSUME_NOT_REACHED("unexpected array type");
default: MOZ_ASSUME_UNREACHABLE("unexpected array type");
}
Register index = ToRegister(ins->ptr());

4
js/src/ion/arm/Lowering-arm.cpp
View File

@ -464,7 +464,7 @@ LIRGeneratorARM::visitAsmJSStoreHeap(MAsmJSStoreHeap *ins)
lir = new LAsmJSStoreHeap(useRegisterAtStart(ins->ptr()),
useRegisterAtStart(ins->value()));
break;
default: MOZ_ASSUME_NOT_REACHED("unexpected array type");
default: MOZ_ASSUME_UNREACHABLE("unexpected array type");
}
return add(lir, ins);
@ -488,7 +488,7 @@ LIRGeneratorARM::lowerTruncateDToInt32(MTruncateToInt32 *ins)
bool
LIRGeneratorARM::visitStoreTypedArrayElementStatic(MStoreTypedArrayElementStatic *ins)
{
MOZ_ASSUME_NOT_REACHED("NYI");
MOZ_ASSUME_UNREACHABLE("NYI");
}
//__aeabi_uidiv

18
js/src/ion/arm/MacroAssembler-arm.cpp
View File

@ -695,7 +695,7 @@ MacroAssemblerARM::ma_cmn(Register src1, Register src2, Condition c)
void
MacroAssemblerARM::ma_cmn(Register src1, Operand op, Condition c)
{
MOZ_ASSUME_NOT_REACHED("Feature NYI");
MOZ_ASSUME_UNREACHABLE("Feature NYI");
}
// Compare (src - src2).
@ -729,7 +729,7 @@ MacroAssemblerARM::ma_cmp(Register src1, Operand op, Condition c)
as_cmp(src1, O2Reg(ScratchRegister), c);
break;
default:
MOZ_ASSUME_NOT_REACHED("trying to compare FP and integer registers");
MOZ_ASSUME_UNREACHABLE("trying to compare FP and integer registers");
}
}
void
@ -802,7 +802,7 @@ MacroAssemblerARM::ma_check_mul(Register src1, Register src2, Register dest, Con
return NotEqual;
}
MOZ_ASSUME_NOT_REACHED("Condition NYI");
MOZ_ASSUME_UNREACHABLE("Condition NYI");
}
Assembler::Condition
@ -820,7 +820,7 @@ MacroAssemblerARM::ma_check_mul(Register src1, Imm32 imm, Register dest, Conditi
return NotEqual;
}
MOZ_ASSUME_NOT_REACHED("Condition NYI");
MOZ_ASSUME_UNREACHABLE("Condition NYI");
}
void
@ -902,7 +902,7 @@ void
MacroAssemblerARM::ma_dtr(LoadStore ls, Register rn, Register rm, Register rt,
Index mode, Assembler::Condition cc)
{
MOZ_ASSUME_NOT_REACHED("Feature NYI");
MOZ_ASSUME_UNREACHABLE("Feature NYI");
}
void
@ -1216,7 +1216,7 @@ MacroAssemblerARM::ma_b(void *target, Relocation::Kind reloc, Assembler::Conditi
m_buffer.markGuard();
break;
default:
MOZ_ASSUME_NOT_REACHED("Other methods of generating tracable jumps NYI");
MOZ_ASSUME_UNREACHABLE("Other methods of generating tracable jumps NYI");
}
}
@ -2766,7 +2766,7 @@ MacroAssemblerARMCompat::loadValue(Address src, ValueOperand val)
mode = IB;
break;
default:
MOZ_ASSUME_NOT_REACHED("Bogus Offset for LoadValue as DTM");
MOZ_ASSUME_UNREACHABLE("Bogus Offset for LoadValue as DTM");
}
startDataTransferM(IsLoad, Register::FromCode(srcOp.base()), mode);
transferReg(val.payloadReg());
@ -2836,7 +2836,7 @@ MacroAssemblerARMCompat::storePayload(Register src, Operand dest)
ma_str(src, ToPayload(dest));
return;
}
MOZ_ASSUME_NOT_REACHED("why do we do all of these things?");
MOZ_ASSUME_UNREACHABLE("why do we do all of these things?");
}
@ -2873,7 +2873,7 @@ MacroAssemblerARMCompat::storeTypeTag(ImmTag tag, Operand dest) {
return;
}
MOZ_ASSUME_NOT_REACHED("why do we do all of these things?");
MOZ_ASSUME_UNREACHABLE("why do we do all of these things?");
}

6
js/src/ion/arm/MacroAssembler-arm.h
View File

@ -362,7 +362,7 @@ class MacroAssemblerARM : public Assembler
return transferMultipleByRunsImpl
<FloatRegisterBackwardIterator>(set, ls, rm, mode, -1);
}
MOZ_ASSUME_NOT_REACHED("Invalid data transfer addressing mode");
MOZ_ASSUME_UNREACHABLE("Invalid data transfer addressing mode");
}
private:
@ -483,10 +483,10 @@ class MacroAssemblerARMCompat : public MacroAssemblerARM
ma_mov(Imm32(imm.value), dest);
}
void mov(Register src, Address dest) {
MOZ_ASSUME_NOT_REACHED("NYI-IC");
MOZ_ASSUME_UNREACHABLE("NYI-IC");
}
void mov(Address src, Register dest) {
MOZ_ASSUME_NOT_REACHED("NYI-IC");
MOZ_ASSUME_UNREACHABLE("NYI-IC");
}
void call(const Register reg) {

2
js/src/ion/arm/MoveEmitter-arm.cpp
View File

@ -190,7 +190,7 @@ MoveEmitterARM::emitMove(const MoveOperand &from, const MoveOperand &to)
masm.ma_str(from.reg(), toOperand(to, false));
break;
default:
MOZ_ASSUME_NOT_REACHED("strange move!");
MOZ_ASSUME_UNREACHABLE("strange move!");
}
} else if (to.isGeneralReg()) {
JS_ASSERT(from.isMemory() || from.isEffectiveAddress());

2
js/src/ion/arm/Trampoline-arm.cpp
View File

@ -695,7 +695,7 @@ IonRuntime::generateVMWrapper(JSContext *cx, const VMFunction &f)
masm.branch32(Assembler::NotEqual, r0, Imm32(TP_SUCCESS), &failure);
break;
default:
MOZ_ASSUME_NOT_REACHED("unknown failure kind");
MOZ_ASSUME_UNREACHABLE("unknown failure kind");
}
// Load the outparam and free any allocated stack.

4
js/src/ion/shared/Assembler-shared.h
View File

@ -63,7 +63,7 @@ ScaleFromElemWidth(int shift)
return TimesEight;
}
MOZ_ASSUME_NOT_REACHED("Invalid scale");
MOZ_ASSUME_UNREACHABLE("Invalid scale");
}
// Used for 32-bit immediates which do not require relocation.
@ -85,7 +85,7 @@ struct Imm32
case TimesEight:
return Imm32(3);
};
MOZ_ASSUME_NOT_REACHED("Invalid scale");
MOZ_ASSUME_UNREACHABLE("Invalid scale");
}
static inline Imm32 FactorOf(enum Scale s) {

2
js/src/ion/shared/Assembler-x86-shared.cpp
View File

@ -123,7 +123,7 @@ AssemblerX86Shared::InvertCondition(Condition cond)
case BelowOrEqual:
return Above;
default:
MOZ_ASSUME_NOT_REACHED("unexpected condition");
MOZ_ASSUME_UNREACHABLE("unexpected condition");
}
}

102
js/src/ion/shared/Assembler-x86-shared.h
View File

@ -134,7 +134,7 @@ class AssemblerX86Shared
return NaN_IsTrue;
}
MOZ_ASSUME_NOT_REACHED("Unknown double condition");
MOZ_ASSUME_UNREACHABLE("Unknown double condition");
}
static void staticAsserts() {
@ -247,7 +247,7 @@ class AssemblerX86Shared
break;
#endif
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void movl(const Register &src, const Operand &dest) {
@ -267,7 +267,7 @@ class AssemblerX86Shared
break;
#endif
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void movl(const Imm32 &imm32, const Operand &dest) {
@ -282,7 +282,7 @@ class AssemblerX86Shared
masm.movl_i32m(imm32.value, dest.disp(), dest.base(), dest.index(), dest.scale());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
@ -307,7 +307,7 @@ class AssemblerX86Shared
masm.movsd_mr(src.disp(), src.base(), src.index(), src.scale(), dest.code());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void movsd(const FloatRegister &src, const Operand &dest) {
@ -323,7 +323,7 @@ class AssemblerX86Shared
masm.movsd_rm(src.code(), dest.disp(), dest.base(), dest.index(), dest.scale());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void movss(const Operand &src, const FloatRegister &dest) {
@ -336,7 +336,7 @@ class AssemblerX86Shared
masm.movss_mr(src.disp(), src.base(), src.index(), src.scale(), dest.code());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void movss(const FloatRegister &src, const Operand &dest) {
@ -349,7 +349,7 @@ class AssemblerX86Shared
masm.movss_rm(src.code(), dest.disp(), dest.base(), dest.index(), dest.scale());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void movdqa(const Operand &src, const FloatRegister &dest) {
@ -362,7 +362,7 @@ class AssemblerX86Shared
masm.movdqa_mr(src.disp(), src.base(), src.index(), src.scale(), dest.code());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void movdqa(const FloatRegister &src, const Operand &dest) {
@ -375,7 +375,7 @@ class AssemblerX86Shared
masm.movdqa_rm(src.code(), dest.disp(), dest.base(), dest.index(), dest.scale());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void cvtss2sd(const FloatRegister &src, const FloatRegister &dest) {
@ -395,7 +395,7 @@ class AssemblerX86Shared
masm.movzbl_mr(src.disp(), src.base(), src.index(), src.scale(), dest.code());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void movsbl(const Operand &src, const Register &dest) {
@ -407,7 +407,7 @@ class AssemblerX86Shared
masm.movsbl_mr(src.disp(), src.base(), src.index(), src.scale(), dest.code());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void movb(const Register &src, const Operand &dest) {
@ -419,7 +419,7 @@ class AssemblerX86Shared
masm.movb_rm(src.code(), dest.disp(), dest.base(), dest.index(), dest.scale());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void movb(const Imm32 &src, const Operand &dest) {
@ -431,7 +431,7 @@ class AssemblerX86Shared
masm.movb_i8m(src.value, dest.disp(), dest.base(), dest.index(), dest.scale());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void movzwl(const Operand &src, const Register &dest) {
@ -443,7 +443,7 @@ class AssemblerX86Shared
masm.movzwl_mr(src.disp(), src.base(), src.index(), src.scale(), dest.code());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
@ -456,7 +456,7 @@ class AssemblerX86Shared
masm.movw_rm(src.code(), dest.disp(), dest.base(), dest.index(), dest.scale());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void movw(const Imm32 &src, const Operand &dest) {
@ -468,7 +468,7 @@ class AssemblerX86Shared
masm.movw_i16m(src.value, dest.disp(), dest.base(), dest.index(), dest.scale());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void movswl(const Operand &src, const Register &dest) {
@ -480,7 +480,7 @@ class AssemblerX86Shared
masm.movswl_mr(src.disp(), src.base(), src.index(), src.scale(), dest.code());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void leal(const Operand &src, const Register &dest) {
@ -492,7 +492,7 @@ class AssemblerX86Shared
masm.leal_mr(src.disp(), src.base(), src.index(), src.scale(), dest.code());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
@ -577,7 +577,7 @@ class AssemblerX86Shared
masm.jmp_r(op.reg());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void cmpEAX(Label *label) { cmpSrc(label); }
@ -674,7 +674,7 @@ class AssemblerX86Shared
masm.call_m(op.disp(), op.base());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
@ -707,7 +707,7 @@ class AssemblerX86Shared
masm.cmpl_mr(rhs.disp(), rhs.base(), lhs.code());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void cmpl(const Register &src, Imm32 imm) {
@ -730,7 +730,7 @@ class AssemblerX86Shared
break;
#endif
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void cmpl(const Operand &lhs, const Register &rhs) {
@ -747,7 +747,7 @@ class AssemblerX86Shared
break;
#endif
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void cmpl(const Operand &op, ImmWord imm) {
@ -764,7 +764,7 @@ class AssemblerX86Shared
break;
#endif
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void setCC(Condition cond, const Register &r) {
@ -790,7 +790,7 @@ class AssemblerX86Shared
masm.testl_i32m(rhs.value, lhs.disp(), lhs.base());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
break;
}
}
@ -812,7 +812,7 @@ class AssemblerX86Shared
break;
#endif
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void subl(Imm32 imm, const Register &dest) {
@ -827,7 +827,7 @@ class AssemblerX86Shared
masm.subl_im(imm.value, op.disp(), op.base());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void addl(const Register &src, const Register &dest) {
@ -845,7 +845,7 @@ class AssemblerX86Shared
masm.subl_mr(src.disp(), src.base(), dest.code());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void orl(const Register &reg, const Register &dest) {
@ -863,7 +863,7 @@ class AssemblerX86Shared
masm.orl_im(imm.value, op.disp(), op.base());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void xorl(const Register &src, const Register &dest) {
@ -881,7 +881,7 @@ class AssemblerX86Shared
masm.xorl_im(imm.value, op.disp(), op.base());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void andl(const Register &src, const Register &dest) {
@ -899,7 +899,7 @@ class AssemblerX86Shared
masm.andl_im(imm.value, op.disp(), op.base());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void addl(const Operand &src, const Register &dest) {
@ -911,7 +911,7 @@ class AssemblerX86Shared
masm.addl_mr(src.disp(), src.base(), dest.code());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void orl(const Operand &src, const Register &dest) {
@ -923,7 +923,7 @@ class AssemblerX86Shared
masm.orl_mr(src.disp(), src.base(), dest.code());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void xorl(const Operand &src, const Register &dest) {
@ -935,7 +935,7 @@ class AssemblerX86Shared
masm.xorl_mr(src.disp(), src.base(), dest.code());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void andl(const Operand &src, const Register &dest) {
@ -947,7 +947,7 @@ class AssemblerX86Shared
masm.andl_mr(src.disp(), src.base(), dest.code());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void imull(Imm32 imm, const Register &dest) {
@ -965,7 +965,7 @@ class AssemblerX86Shared
masm.imull_mr(src.disp(), src.base(), dest.code());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void negl(const Operand &src) {
@ -977,7 +977,7 @@ class AssemblerX86Shared
masm.negl_m(src.disp(), src.base());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void negl(const Register &reg) {
@ -992,7 +992,7 @@ class AssemblerX86Shared
masm.notl_m(src.disp(), src.base());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void notl(const Register &reg) {
@ -1030,7 +1030,7 @@ class AssemblerX86Shared
masm.push_m(src.disp(), src.base());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void push(const Register &src) {
@ -1046,7 +1046,7 @@ class AssemblerX86Shared
masm.pop_m(src.disp(), src.base());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void pop(const Register &src) {
@ -1102,7 +1102,7 @@ class AssemblerX86Shared
masm.pinsrd_mr(src.disp(), src.base(), dest.code());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void psrldq(Imm32 shift, const FloatRegister &dest) {
@ -1131,7 +1131,7 @@ class AssemblerX86Shared
masm.cvtsi2sd_mr(src.disp(), src.base(), src.index(), src.scale(), dest.code());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void cvttsd2si(const FloatRegister &src, const Register &dest) {
@ -1185,7 +1185,7 @@ class AssemblerX86Shared
break;
#endif
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void subsd(const FloatRegister &src, const FloatRegister &dest) {
@ -1202,7 +1202,7 @@ class AssemblerX86Shared
masm.subsd_mr(src.disp(), src.base(), dest.code());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void mulsd(const FloatRegister &src, const FloatRegister &dest) {
@ -1219,7 +1219,7 @@ class AssemblerX86Shared
masm.mulsd_mr(src.disp(), src.base(), dest.code());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void divsd(const FloatRegister &src, const FloatRegister &dest) {
@ -1236,7 +1236,7 @@ class AssemblerX86Shared
masm.divsd_mr(src.disp(), src.base(), dest.code());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void xorpd(const FloatRegister &src, const FloatRegister &dest) {
@ -1268,7 +1268,7 @@ class AssemblerX86Shared
masm.fisttp_m(dest.disp(), dest.base());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void fld(const Operand &dest) {
@ -1277,7 +1277,7 @@ class AssemblerX86Shared
masm.fld_m(dest.disp(), dest.base());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void fstp(const Operand &src) {
@ -1286,7 +1286,7 @@ class AssemblerX86Shared
masm.fstp_m(src.disp(), src.base());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
@ -1336,7 +1336,7 @@ class AssemblerX86Shared
return 1;
}
static uint8_t *nextInstruction(uint8_t *cur, uint32_t *count) {
MOZ_ASSUME_NOT_REACHED("nextInstruction NYI on x86");
MOZ_ASSUME_UNREACHABLE("nextInstruction NYI on x86");
}
// Toggle a jmp or cmp emitted by toggledJump().

2
js/src/ion/shared/CodeGenerator-shared-inl.h
View File

@ -17,7 +17,7 @@ ToInt32(const LAllocation *a)
return a->toConstant()->toInt32();
if (a->isConstantIndex())
return a->toConstantIndex()->index();
MOZ_ASSUME_NOT_REACHED("this is not a constant!");
MOZ_ASSUME_UNREACHABLE("this is not a constant!");
}
static inline double
ToDouble(const LAllocation *a)

10
js/src/ion/shared/CodeGenerator-x86-shared.cpp
View File

@ -292,7 +292,7 @@ CodeGeneratorX86Shared::bailout(const T &binder, LSnapshot *snapshot)
case SequentialExecution:
break;
default:
MOZ_ASSUME_NOT_REACHED("No such execution mode");
MOZ_ASSUME_UNREACHABLE("No such execution mode");
}
if (!encode(snapshot))
@ -938,7 +938,7 @@ CodeGeneratorX86Shared::visitBitOpI(LBitOpI *ins)
masm.andl(ToOperand(rhs), ToRegister(lhs));
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected binary opcode");
MOZ_ASSUME_UNREACHABLE("unexpected binary opcode");
}
return true;
@ -972,7 +972,7 @@ CodeGeneratorX86Shared::visitShiftI(LShiftI *ins)
}
break;
default:
MOZ_ASSUME_NOT_REACHED("Unexpected shift op");
MOZ_ASSUME_UNREACHABLE("Unexpected shift op");
}
} else {
JS_ASSERT(ToRegister(rhs) == ecx);
@ -993,7 +993,7 @@ CodeGeneratorX86Shared::visitShiftI(LShiftI *ins)
}
break;
default:
MOZ_ASSUME_NOT_REACHED("Unexpected shift op");
MOZ_ASSUME_UNREACHABLE("Unexpected shift op");
}
}
@ -1138,7 +1138,7 @@ CodeGeneratorX86Shared::visitMathD(LMathD *math)
masm.divsd(rhs, lhs);
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected opcode");
MOZ_ASSUME_UNREACHABLE("unexpected opcode");
}
return true;
}

2
js/src/ion/shared/IonAssemblerBuffer.h
View File

@ -238,7 +238,7 @@ struct AssemblerBuffer
return BufferOffset(bufferSize);
}
BufferOffset prevOffset() const {
MOZ_ASSUME_NOT_REACHED("Don't current record lastInstSize");
MOZ_ASSUME_UNREACHABLE("Don't current record lastInstSize");
}
// Break the instruction stream so we can go back and edit it at this point

2
js/src/ion/shared/IonAssemblerBufferWithConstantPools.h
View File

@ -1130,7 +1130,7 @@ struct AssemblerBufferWithConstantPool : public AssemblerBuffer<SliceSize, Inst>
}
start = poolGroup[idx].other->addPoolSize(start);
}
MOZ_ASSUME_NOT_REACHED("Entry is not in a pool");
MOZ_ASSUME_UNREACHABLE("Entry is not in a pool");
}
void writePoolEntry(PoolEntry pe, uint8_t *buff) {
size_t size = getPoolEntrySize(pe);

4
js/src/ion/x64/Assembler-x64.cpp
View File

@ -45,7 +45,7 @@ ABIArgGenerator::next(MIRType type)
current_ = ABIArg(FloatArgRegs[regIndex_++]);
break;
default:
MOZ_ASSUME_NOT_REACHED("Unexpected argument type");
MOZ_ASSUME_UNREACHABLE("Unexpected argument type");
}
return current_;
#else
@ -68,7 +68,7 @@ ABIArgGenerator::next(MIRType type)
current_ = ABIArg(FloatArgRegs[floatRegIndex_++]);
break;
default:
MOZ_ASSUME_NOT_REACHED("Unexpected argument type");
MOZ_ASSUME_UNREACHABLE("Unexpected argument type");
}
return current_;
#endif

24
js/src/ion/x64/Assembler-x64.h
View File

@ -385,7 +385,7 @@ class Assembler : public AssemblerX86Shared
masm.movq_mr(src.disp(), src.base(), src.index(), src.scale(), dest.code());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void movq(const Register &src, const Operand &dest) {
@ -400,7 +400,7 @@ class Assembler : public AssemblerX86Shared
masm.movq_rm(src.code(), dest.disp(), dest.base(), dest.index(), dest.scale());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void movq(Imm32 imm32, const Operand &dest) {
@ -415,7 +415,7 @@ class Assembler : public AssemblerX86Shared
masm.movq_i32m(imm32.value, dest.disp(), dest.base(), dest.index(), dest.scale());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void movqsd(const Register &src, const FloatRegister &dest) {
@ -451,7 +451,7 @@ class Assembler : public AssemblerX86Shared
masm.addq_im(imm.value, dest.disp(), dest.base());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void addq(const Register &src, const Register &dest) {
@ -466,7 +466,7 @@ class Assembler : public AssemblerX86Shared
masm.addq_mr(src.disp(), src.base(), dest.code());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
@ -485,7 +485,7 @@ class Assembler : public AssemblerX86Shared
masm.subq_mr(src.disp(), src.base(), dest.code());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void shlq(Imm32 imm, const Register &dest) {
@ -512,7 +512,7 @@ class Assembler : public AssemblerX86Shared
masm.orq_mr(src.disp(), src.base(), dest.code());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void xorq(const Register &src, const Register &dest) {
@ -568,7 +568,7 @@ class Assembler : public AssemblerX86Shared
masm.leaq_mr(src.disp(), src.base(), src.index(), src.scale(), dest.code());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexepcted operand kind");
MOZ_ASSUME_UNREACHABLE("unexepcted operand kind");
}
}
@ -603,7 +603,7 @@ class Assembler : public AssemblerX86Shared
masm.cmpq_rm(rhs.code(), lhs.disp(), lhs.base());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void cmpq(const Operand &lhs, Imm32 rhs) {
@ -615,7 +615,7 @@ class Assembler : public AssemblerX86Shared
masm.cmpq_im(rhs.value, lhs.disp(), lhs.base());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void cmpq(const Register &lhs, const Operand &rhs) {
@ -627,7 +627,7 @@ class Assembler : public AssemblerX86Shared
masm.cmpq_mr(rhs.disp(), rhs.base(), lhs.code());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void cmpq(const Register &lhs, const Register &rhs) {
@ -652,7 +652,7 @@ class Assembler : public AssemblerX86Shared
masm.testq_i32m(rhs.value, lhs.disp(), lhs.base());
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
break;
}
}

4
js/src/ion/x64/BaselineIC-x64.cpp
View File

@ -180,7 +180,7 @@ ICBinaryArith_Int32::Compiler::generateStubCode(MacroAssembler &masm)
}
break;
default:
MOZ_ASSUME_NOT_REACHED("Unhandled op in BinaryArith_Int32");
MOZ_ASSUME_UNREACHABLE("Unhandled op in BinaryArith_Int32");
}
// Return from stub.
@ -229,7 +229,7 @@ ICUnaryArith_Int32::Compiler::generateStubCode(MacroAssembler &masm)
masm.negl(R0.valueReg());
break;
default:
MOZ_ASSUME_NOT_REACHED("Unexpected op");
MOZ_ASSUME_UNREACHABLE("Unexpected op");
}
masm.tagValue(JSVAL_TYPE_INT32, R0.valueReg(), R0);

18
js/src/ion/x64/CodeGenerator-x64.cpp
View File

@ -57,7 +57,7 @@ FrameSizeClass::ClassLimit()
uint32_t
FrameSizeClass::frameSize() const
{
MOZ_ASSUME_NOT_REACHED("x64 does not use frame size classes");
MOZ_ASSUME_UNREACHABLE("x64 does not use frame size classes");
}
bool
@ -117,7 +117,7 @@ CodeGeneratorX64::visitUnbox(LUnbox *unbox)
cond = masm.testString(Assembler::NotEqual, value);
break;
default:
MOZ_ASSUME_NOT_REACHED("Given MIRType cannot be unboxed.");
MOZ_ASSUME_UNREACHABLE("Given MIRType cannot be unboxed.");
}
if (!bailoutIf(cond, unbox->snapshot()))
return false;
@ -137,7 +137,7 @@ CodeGeneratorX64::visitUnbox(LUnbox *unbox)
masm.unboxString(value, ToRegister(result));
break;
default:
MOZ_ASSUME_NOT_REACHED("Given MIRType cannot be unboxed.");
MOZ_ASSUME_UNREACHABLE("Given MIRType cannot be unboxed.");
}
return true;
@ -173,7 +173,7 @@ CodeGeneratorX64::loadUnboxedValue(Operand source, MIRType type, const LDefiniti
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected type");
MOZ_ASSUME_UNREACHABLE("unexpected type");
}
}
@ -386,13 +386,13 @@ CodeGeneratorX64::visitUInt32ToDouble(LUInt32ToDouble *lir)
bool
CodeGeneratorX64::visitLoadTypedArrayElementStatic(LLoadTypedArrayElementStatic *ins)
{
MOZ_ASSUME_NOT_REACHED("NYI");
MOZ_ASSUME_UNREACHABLE("NYI");
}
bool
CodeGeneratorX64::visitStoreTypedArrayElementStatic(LStoreTypedArrayElementStatic *ins)
{
MOZ_ASSUME_NOT_REACHED("NYI");
MOZ_ASSUME_UNREACHABLE("NYI");
}
bool
@ -421,7 +421,7 @@ CodeGeneratorX64::visitAsmJSLoadHeap(LAsmJSLoadHeap *ins)
case ArrayBufferView::TYPE_INT32: masm.movl(srcAddr, ToRegister(ins->output())); break;
case ArrayBufferView::TYPE_UINT32: masm.movl(srcAddr, ToRegister(ins->output())); break;
case ArrayBufferView::TYPE_FLOAT64: masm.movsd(srcAddr, ToFloatRegister(ins->output())); break;
default: MOZ_ASSUME_NOT_REACHED("unexpected array type");
default: MOZ_ASSUME_UNREACHABLE("unexpected array type");
}
uint32_t after = masm.size();
return gen->noteHeapAccess(AsmJSHeapAccess(before, after, vt, ToAnyRegister(ins->output())));
@ -452,7 +452,7 @@ CodeGeneratorX64::visitAsmJSStoreHeap(LAsmJSStoreHeap *ins)
case ArrayBufferView::TYPE_UINT16: masm.movw(Imm32(ToInt32(ins->value())), dstAddr); break;
case ArrayBufferView::TYPE_INT32: masm.movl(Imm32(ToInt32(ins->value())), dstAddr); break;
case ArrayBufferView::TYPE_UINT32: masm.movl(Imm32(ToInt32(ins->value())), dstAddr); break;
default: MOZ_ASSUME_NOT_REACHED("unexpected array type");
default: MOZ_ASSUME_UNREACHABLE("unexpected array type");
}
} else {
switch (vt) {
@ -463,7 +463,7 @@ CodeGeneratorX64::visitAsmJSStoreHeap(LAsmJSStoreHeap *ins)
case ArrayBufferView::TYPE_INT32: masm.movl(ToRegister(ins->value()), dstAddr); break;
case ArrayBufferView::TYPE_UINT32: masm.movl(ToRegister(ins->value()), dstAddr); break;
case ArrayBufferView::TYPE_FLOAT64: masm.movsd(ToFloatRegister(ins->value()), dstAddr); break;
default: MOZ_ASSUME_NOT_REACHED("unexpected array type");
default: MOZ_ASSUME_UNREACHABLE("unexpected array type");
}
}
uint32_t after = masm.size();

4
js/src/ion/x64/Lowering-x64.cpp
View File

@ -157,7 +157,7 @@ LIRGeneratorX64::visitAsmJSStoreHeap(MAsmJSStoreHeap *ins)
lir = new LAsmJSStoreHeap(useRegisterAtStart(ins->ptr()),
useRegisterAtStart(ins->value()));
break;
default: MOZ_ASSUME_NOT_REACHED("unexpected array type");
default: MOZ_ASSUME_UNREACHABLE("unexpected array type");
}
return add(lir, ins);
@ -178,5 +178,5 @@ LIRGeneratorX64::newLGetPropertyCacheT(MGetPropertyCache *ins)
bool
LIRGeneratorX64::visitStoreTypedArrayElementStatic(MStoreTypedArrayElementStatic *ins)
{
MOZ_ASSUME_NOT_REACHED("NYI");
MOZ_ASSUME_UNREACHABLE("NYI");
}

2
js/src/ion/x64/MacroAssembler-x64.h
View File

@ -95,7 +95,7 @@ class MacroAssemblerX64 : public MacroAssemblerX86Shared
base.scale(), base.disp() + 4);
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
static inline Operand ToUpper32(const Address &address) {

6
js/src/ion/x64/Trampoline-x64.cpp
View File

@ -450,7 +450,7 @@ GenerateBailoutThunk(JSContext *cx, MacroAssembler &masm, uint32_t frameClass)
IonCode *
IonRuntime::generateBailoutTable(JSContext *cx, uint32_t frameClass)
{
MOZ_ASSUME_NOT_REACHED("x64 does not use bailout tables");
MOZ_ASSUME_UNREACHABLE("x64 does not use bailout tables");
}
IonCode *
@ -561,7 +561,7 @@ IonRuntime::generateVMWrapper(JSContext *cx, const VMFunction &f)
break;
case VMFunction::DoubleByValue:
case VMFunction::DoubleByRef:
MOZ_ASSUME_NOT_REACHED("NYI: x64 callVM should not be used with 128bits values.");
MOZ_ASSUME_UNREACHABLE("NYI: x64 callVM should not be used with 128bits values.");
}
}
}
@ -586,7 +586,7 @@ IonRuntime::generateVMWrapper(JSContext *cx, const VMFunction &f)
masm.branchPtr(Assembler::NotEqual, rax, Imm32(TP_SUCCESS), &failure);
break;
default:
MOZ_ASSUME_NOT_REACHED("unknown failure kind");
MOZ_ASSUME_UNREACHABLE("unknown failure kind");
}
// Load the outparam and free any allocated stack.

2
js/src/ion/x86/Assembler-x86.cpp
View File

@ -28,7 +28,7 @@ ABIArgGenerator::next(MIRType type)
stackOffset_ += sizeof(uint64_t);
break;
default:
MOZ_ASSUME_NOT_REACHED("Unexpected argument type");
MOZ_ASSUME_UNREACHABLE("Unexpected argument type");
}
return current_;
}

4
js/src/ion/x86/Assembler-x86.h
View File

@ -312,7 +312,7 @@ class Assembler : public AssemblerX86Shared
writeDataRelocation(ptr);
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void movl(ImmWord imm, Register dest) {
@ -375,7 +375,7 @@ class Assembler : public AssemblerX86Shared
writeDataRelocation(imm);
break;
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
CodeOffsetLabel cmplWithPatch(const Register &lhs, Imm32 rhs) {

4
js/src/ion/x86/BaselineIC-x86.cpp
View File

@ -184,7 +184,7 @@ ICBinaryArith_Int32::Compiler::generateStubCode(MacroAssembler &masm)
}
break;
default:
MOZ_ASSUME_NOT_REACHED("Unhandled op for BinaryArith_Int32. ");
MOZ_ASSUME_UNREACHABLE("Unhandled op for BinaryArith_Int32. ");
}
// Return.
@ -245,7 +245,7 @@ ICUnaryArith_Int32::Compiler::generateStubCode(MacroAssembler &masm)
masm.negl(R0.payloadReg());
break;
default:
MOZ_ASSUME_NOT_REACHED("Unexpected op");
MOZ_ASSUME_UNREACHABLE("Unexpected op");
}
EmitReturnFromIC(masm);

4
js/src/ion/x86/CodeGenerator-x86.cpp
View File

@ -423,7 +423,7 @@ CodeGeneratorX86::loadViewTypeElement(ArrayBufferView::ViewType vt, const Addres
case ArrayBufferView::TYPE_INT32: masm.movlWithPatch(srcAddr, ToRegister(out)); break;
case ArrayBufferView::TYPE_UINT32: masm.movlWithPatch(srcAddr, ToRegister(out)); break;
case ArrayBufferView::TYPE_FLOAT64: masm.movsdWithPatch(srcAddr, ToFloatRegister(out)); break;
default: MOZ_ASSUME_NOT_REACHED("unexpected array type");
default: MOZ_ASSUME_UNREACHABLE("unexpected array type");
}
}
@ -526,7 +526,7 @@ CodeGeneratorX86::storeViewTypeElement(ArrayBufferView::ViewType vt, const LAllo
case ArrayBufferView::TYPE_INT32: masm.movlWithPatch(ToRegister(value), dstAddr); break;
case ArrayBufferView::TYPE_UINT32: masm.movlWithPatch(ToRegister(value), dstAddr); break;
case ArrayBufferView::TYPE_FLOAT64: masm.movsdWithPatch(ToFloatRegister(value), dstAddr); break;
default: MOZ_ASSUME_NOT_REACHED("unexpected array type");
default: MOZ_ASSUME_UNREACHABLE("unexpected array type");
}
}

4
js/src/ion/x86/Lowering-x86.cpp
View File

@ -237,7 +237,7 @@ LIRGeneratorX86::visitAsmJSStoreHeap(MAsmJSStoreHeap *ins)
lir = new LAsmJSStoreHeap(useRegisterAtStart(ins->ptr()),
useRegisterAtStart(ins->value()));
break;
default: MOZ_ASSUME_NOT_REACHED("unexpected array type");
default: MOZ_ASSUME_UNREACHABLE("unexpected array type");
}
return add(lir, ins);
@ -261,7 +261,7 @@ LIRGeneratorX86::visitStoreTypedArrayElementStatic(MStoreTypedArrayElementStatic
lir = new LStoreTypedArrayElementStatic(useRegisterAtStart(ins->ptr()),
useRegisterAtStart(ins->value()));
break;
default: MOZ_ASSUME_NOT_REACHED("unexpected array type");
default: MOZ_ASSUME_UNREACHABLE("unexpected array type");
}
return add(lir, ins);

2
js/src/ion/x86/MacroAssembler-x86.h
View File

@ -98,7 +98,7 @@ class MacroAssemblerX86 : public MacroAssemblerX86Shared
base.scale(), base.disp() + sizeof(void *));
default:
MOZ_ASSUME_NOT_REACHED("unexpected operand kind");
MOZ_ASSUME_UNREACHABLE("unexpected operand kind");
}
}
void moveValue(const Value &val, Register type, Register data) {

2
js/src/ion/x86/Trampoline-x86.cpp
View File

@ -609,7 +609,7 @@ IonRuntime::generateVMWrapper(JSContext *cx, const VMFunction &f)
masm.branchPtr(Assembler::NotEqual, eax, Imm32(TP_SUCCESS), &failure);
break;
default:
MOZ_ASSUME_NOT_REACHED("unknown failure kind");
MOZ_ASSUME_UNREACHABLE("unknown failure kind");
}
// Load the outparam and free any allocated stack.

2
js/src/jsanalyze.cpp
View File

@ -2022,7 +2022,7 @@ SSAValue::print() const
break;
default:
MOZ_ASSUME_NOT_REACHED("Bad kind");
MOZ_ASSUME_UNREACHABLE("Bad kind");
}
}

6
js/src/jsanalyze.h
View File

@ -206,7 +206,7 @@ ReverseCompareOp(JSOp op)
case JSOP_STRICTNE:
return op;
default:
MOZ_ASSUME_NOT_REACHED("unrecognized op");
MOZ_ASSUME_UNREACHABLE("unrecognized op");
}
}
@ -231,7 +231,7 @@ NegateCompareOp(JSOp op)
case JSOP_STRICTEQ:
return JSOP_STRICTNE;
default:
MOZ_ASSUME_NOT_REACHED("unrecognized op");
MOZ_ASSUME_UNREACHABLE("unrecognized op");
}
}
@ -293,7 +293,7 @@ static inline uint32_t GetBytecodeSlot(JSScript *script, jsbytecode *pc)
return ThisSlot();
default:
MOZ_ASSUME_NOT_REACHED("Bad slot opcode");
MOZ_ASSUME_UNREACHABLE("Bad slot opcode");
}
}

2
js/src/jsanalyzeinlines.h
View File

@ -71,7 +71,7 @@ ScriptAnalysis::getValueTypes(const SSAValue &v)
return &v.phiNode()->types;
default:
/* Cannot compute types for empty SSA values. */
MOZ_ASSUME_NOT_REACHED("Bad SSA value");
MOZ_ASSUME_UNREACHABLE("Bad SSA value");
}
}

6
js/src/jsclone.cpp
View File

@ -927,7 +927,7 @@ JSStructuredCloneReader::readTypedArray(uint32_t arrayType, uint32_t nelems, Val
obj = JS_NewUint8ClampedArrayWithBuffer(context(), buffer, byteOffset, nelems);
break;
default:
MOZ_ASSUME_NOT_REACHED("unknown TypedArray type");
MOZ_ASSUME_UNREACHABLE("unknown TypedArray type");
}
if (!obj)
@ -969,7 +969,7 @@ bytesPerTypedArrayElement(uint32_t arrayType)
case TypedArray::TYPE_FLOAT64:
return sizeof(uint64_t);
default:
MOZ_ASSUME_NOT_REACHED("unknown TypedArray type");
MOZ_ASSUME_UNREACHABLE("unknown TypedArray type");
}
}
@ -1005,7 +1005,7 @@ JSStructuredCloneReader::readV1ArrayBuffer(uint32_t arrayType, uint32_t nelems,
case TypedArray::TYPE_FLOAT64:
return in.readArray((uint64_t*) buffer.dataPointer(), nelems);
default:
MOZ_ASSUME_NOT_REACHED("unknown TypedArray type");
MOZ_ASSUME_UNREACHABLE("unknown TypedArray type");
}
}

2
js/src/jscntxtinlines.h
View File

@ -616,7 +616,7 @@ js::ThreadSafeContext::allowGC() const
return NoGC;
default:
/* Silence warnings. */
MOZ_ASSUME_NOT_REACHED("Bad context kind");
MOZ_ASSUME_UNREACHABLE("Bad context kind");
}
}

4
js/src/jsdbgapi.cpp
View File

@ -105,7 +105,7 @@ js::ScriptDebugPrologue(JSContext *cx, AbstractFramePtr frame)
frame.setReturnValue(rval);
break;
default:
MOZ_ASSUME_NOT_REACHED("bad Debugger::onEnterFrame JSTrapStatus value");
MOZ_ASSUME_UNREACHABLE("bad Debugger::onEnterFrame JSTrapStatus value");
}
return status;
}
@ -167,7 +167,7 @@ js::DebugExceptionUnwind(JSContext *cx, AbstractFramePtr frame, jsbytecode *pc)
break;
default:
MOZ_ASSUME_NOT_REACHED("Invalid trap status");
MOZ_ASSUME_UNREACHABLE("Invalid trap status");
}
return status;

2
js/src/jsfriendapi.cpp
View File

@ -948,7 +948,7 @@ JS::IncrementalReferenceBarrier(void *ptr, JSGCTraceKind kind)
else if (kind == JSTRACE_TYPE_OBJECT)
types::TypeObject::writeBarrierPre((types::TypeObject *) ptr);
else
MOZ_ASSUME_NOT_REACHED("invalid trace kind");
MOZ_ASSUME_UNREACHABLE("invalid trace kind");
}
JS_FRIEND_API(void)

4
js/src/jsfun.cpp
View File

@ -143,7 +143,7 @@ fun_getProperty(JSContext *cx, HandleObject obj_, HandleId id, MutableHandleValu
return true;
}
MOZ_ASSUME_NOT_REACHED("fun_getProperty");
MOZ_ASSUME_UNREACHABLE("fun_getProperty");
}
@ -1750,6 +1750,6 @@ JSObject::hasIdempotentProtoChain() const
return true;
}
MOZ_ASSUME_NOT_REACHED("Should not get here");
MOZ_ASSUME_UNREACHABLE("Should not get here");
}

10
js/src/jsgc.cpp
View File

@ -459,7 +459,7 @@ FinalizeArenas(FreeOp *fop,
return FinalizeTypedArenas<ion::IonCode>(fop, src, dest, thingKind, budget);
#endif
default:
MOZ_ASSUME_NOT_REACHED("Invalid alloc kind");
MOZ_ASSUME_UNREACHABLE("Invalid alloc kind");
}
}
@ -724,7 +724,7 @@ Chunk::findDecommittedArenaOffset()
for (unsigned i = 0; i < info.lastDecommittedArenaOffset; i++)
if (decommittedArenas.get(i))
return i;
MOZ_ASSUME_NOT_REACHED("No decommitted arenas found.");
MOZ_ASSUME_UNREACHABLE("No decommitted arenas found.");
}
ArenaHeader *
@ -2348,7 +2348,7 @@ GCHelperThread::startBackgroundShrink()
*/
break;
case SHUTDOWN:
MOZ_ASSUME_NOT_REACHED("No shrink on shutdown");
MOZ_ASSUME_UNREACHABLE("No shrink on shutdown");
}
#endif /* JS_THREADSAFE */
}
@ -3508,7 +3508,7 @@ RemoveFromGrayList(JSObject *wrapper)
obj = next;
}
MOZ_ASSUME_NOT_REACHED("object not found in gray link list");
MOZ_ASSUME_UNREACHABLE("object not found in gray link list");
}
static void
@ -4110,7 +4110,7 @@ ResetIncrementalGC(JSRuntime *rt, const char *reason)
break;
default:
MOZ_ASSUME_NOT_REACHED("Invalid incremental GC state");
MOZ_ASSUME_UNREACHABLE("Invalid incremental GC state");
}
rt->gcStats.reset(reason);

2
js/src/jsgcinlines.h
View File

@ -151,7 +151,7 @@ GetGCKindSlots(AllocKind thingKind)
case FINALIZE_OBJECT16_BACKGROUND:
return 16;
default:
MOZ_ASSUME_NOT_REACHED("Bad object finalize kind");
MOZ_ASSUME_UNREACHABLE("Bad object finalize kind");
}
}

2
js/src/jsinfer.cpp
View File

@ -190,7 +190,7 @@ types::TypeString(Type type)
case JSVAL_TYPE_MAGIC:
return "lazyargs";
default:
MOZ_ASSUME_NOT_REACHED("Bad type");
MOZ_ASSUME_UNREACHABLE("Bad type");
}
}
if (type.isUnknown())

10
js/src/jsinferinlines.h
View File

@ -113,7 +113,7 @@ CompilerOutput::ion() const
case ParallelIon: return script->parallelIonScript();
}
#endif
MOZ_ASSUME_NOT_REACHED("Invalid kind of CompilerOutput");
MOZ_ASSUME_UNREACHABLE("Invalid kind of CompilerOutput");
}
inline bool
@ -222,7 +222,7 @@ PrimitiveTypeFlag(JSValueType type)
case JSVAL_TYPE_MAGIC:
return TYPE_FLAG_LAZYARGS;
default:
MOZ_ASSUME_NOT_REACHED("Bad type");
MOZ_ASSUME_UNREACHABLE("Bad type");
}
}
@ -245,7 +245,7 @@ TypeFlagPrimitive(TypeFlags flags)
case TYPE_FLAG_LAZYARGS:
return JSVAL_TYPE_MAGIC;
default:
MOZ_ASSUME_NOT_REACHED("Bad type");
MOZ_ASSUME_UNREACHABLE("Bad type");
}
}
@ -495,7 +495,7 @@ GetClassForProtoKey(JSProtoKey key)
return &ParallelArrayObject::class_;
default:
MOZ_ASSUME_NOT_REACHED("Bad proto key");
MOZ_ASSUME_UNREACHABLE("Bad proto key");
}
}
@ -1587,7 +1587,7 @@ TypeObject::getProperty(JSContext *cx, jsid id, bool own)
return &prop->types;
}
MOZ_ASSUME_NOT_REACHED("Missing property");
MOZ_ASSUME_UNREACHABLE("Missing property");
}
}

2
js/src/jsobjinlines.h
View File

@ -1266,7 +1266,7 @@ ObjectClassIs(HandleObject obj, ESClassValue classValue, JSContext *cx)
case ESClass_ArrayBuffer: return obj->is<ArrayBufferObject>();
case ESClass_Date: return obj->is<DateObject>();
}
MOZ_ASSUME_NOT_REACHED("bad classValue");
MOZ_ASSUME_UNREACHABLE("bad classValue");
}
inline bool

10
js/src/jsopcode.cpp
View File

@ -117,7 +117,7 @@ js_GetVariableBytecodeLength(jsbytecode *pc)
return 1 + 3 * JUMP_OFFSET_LEN + ncases * JUMP_OFFSET_LEN;
}
default:
MOZ_ASSUME_NOT_REACHED("Unexpected op");
MOZ_ASSUME_UNREACHABLE("Unexpected op");
}
}
@ -249,13 +249,13 @@ PCCounts::countName(JSOp op, size_t which)
return countElementNames[which - ACCESS_LIMIT];
if (propertyOp(op))
return countPropertyNames[which - ACCESS_LIMIT];
MOZ_ASSUME_NOT_REACHED("bad op");
MOZ_ASSUME_UNREACHABLE("bad op");
}
if (arithOp(op))
return countArithNames[which - BASE_LIMIT];
MOZ_ASSUME_NOT_REACHED("bad op");
MOZ_ASSUME_UNREACHABLE("bad op");
}
#ifdef DEBUG
@ -2163,11 +2163,11 @@ js::GetPCCountScriptSummary(JSContext *cx, size_t index)
else if (PCCounts::propertyOp(op))
propertyTotals[j - PCCounts::ACCESS_LIMIT] += value;
else
MOZ_ASSUME_NOT_REACHED("Bad opcode");
MOZ_ASSUME_UNREACHABLE("Bad opcode");
} else if (PCCounts::arithOp(op)) {
arithTotals[j - PCCounts::BASE_LIMIT] += value;
} else {
MOZ_ASSUME_NOT_REACHED("Bad opcode");
MOZ_ASSUME_UNREACHABLE("Bad opcode");
}
}
}

2
js/src/jsopcode.h
View File

@ -515,7 +515,7 @@ GetBytecodeInteger(jsbytecode *pc)
case JSOP_INT8: return GET_INT8(pc);
case JSOP_INT32: return GET_INT32(pc);
default:
MOZ_ASSUME_NOT_REACHED("Bad op");
MOZ_ASSUME_UNREACHABLE("Bad op");
}
}

8
js/src/jsproxy.cpp
View File

@ -309,13 +309,13 @@ BaseProxyHandler::iterate(JSContext *cx, HandleObject proxy, unsigned flags, Mut
bool
BaseProxyHandler::call(JSContext *cx, HandleObject proxy, const CallArgs &args)
{
MOZ_ASSUME_NOT_REACHED("callable proxies should implement call trap");
MOZ_ASSUME_UNREACHABLE("callable proxies should implement call trap");
}
bool
BaseProxyHandler::construct(JSContext *cx, HandleObject proxy, const CallArgs &args)
{
MOZ_ASSUME_NOT_REACHED("callable proxies should implement construct trap");
MOZ_ASSUME_UNREACHABLE("callable proxies should implement construct trap");
}
const char *
@ -327,14 +327,14 @@ BaseProxyHandler::className(JSContext *cx, HandleObject proxy)
JSString *
BaseProxyHandler::fun_toString(JSContext *cx, HandleObject proxy, unsigned indent)
{
MOZ_ASSUME_NOT_REACHED("callable proxies should implement fun_toString trap");
MOZ_ASSUME_UNREACHABLE("callable proxies should implement fun_toString trap");
}
bool
BaseProxyHandler::regexp_toShared(JSContext *cx, HandleObject proxy,
RegExpGuard *g)
{
MOZ_ASSUME_NOT_REACHED("This should have been a wrapped regexp");
MOZ_ASSUME_UNREACHABLE("This should have been a wrapped regexp");
}
bool

2
js/src/jsscript.cpp
View File

@ -380,7 +380,7 @@ FindBlockIndex(JSScript *script, StaticBlockObject &block)
return i;
}
MOZ_ASSUME_NOT_REACHED("Block not found");
MOZ_ASSUME_UNREACHABLE("Block not found");
}
template<XDRMode mode>

8
js/src/jstypedarray.cpp
View File

@ -2452,7 +2452,7 @@ class TypedArrayTemplate
break;
}
default:
MOZ_ASSUME_NOT_REACHED("copyFrom with a TypedArray of unknown type");
MOZ_ASSUME_UNREACHABLE("copyFrom with a TypedArray of unknown type");
}
return true;
@ -2529,7 +2529,7 @@ class TypedArrayTemplate
break;
}
default:
MOZ_ASSUME_NOT_REACHED("copyFromWithOverlap with a TypedArray of unknown type");
MOZ_ASSUME_UNREACHABLE("copyFromWithOverlap with a TypedArray of unknown type");
}
js_free(srcbuf);
@ -3872,7 +3872,7 @@ js::IsTypedArrayConstructor(const Value &v, uint32_t type)
case TypedArray::TYPE_UINT8_CLAMPED:
return IsNativeFunction(v, Uint8ClampedArray::class_constructor);
}
MOZ_ASSUME_NOT_REACHED("unexpected typed array type");
MOZ_ASSUME_UNREACHABLE("unexpected typed array type");
}
bool
@ -4029,7 +4029,7 @@ JS_GetArrayBufferViewType(JSObject *obj)
return static_cast<JSArrayBufferViewType>(TypedArray::type(obj));
else if (obj->is<DataViewObject>())
return ArrayBufferView::TYPE_DATAVIEW;
MOZ_ASSUME_NOT_REACHED("invalid ArrayBufferView type");
MOZ_ASSUME_UNREACHABLE("invalid ArrayBufferView type");
}
JS_FRIEND_API(int8_t *)

2
js/src/jstypedarray.h
View File

@ -337,7 +337,7 @@ TypedArrayShift(ArrayBufferView::ViewType viewType)
return 3;
default:;
}
MOZ_ASSUME_NOT_REACHED("Unexpected array type");
MOZ_ASSUME_UNREACHABLE("Unexpected array type");
}
class DataViewObject : public JSObject, public BufferView

Some files were not shown because too many files have changed in this diff Show More