Move family of MakeError functions to C++

src/js/typedarray.js

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 (function(global, utils) {
 
 "use strict";
 
 %CheckIsBootstrapping();
 
@@ skipping 20 matching lines @@
 var InnerArrayIndexOf;
 var InnerArrayJoin;
 var InnerArrayLastIndexOf;
 var InnerArrayReduce;
 var InnerArrayReduceRight;
 var InnerArraySome;
 var InnerArraySort;
 var InnerArrayToLocaleString;
 var InternalArray = utils.InternalArray;
 var IsNaN;
-var MakeRangeError;
-var MakeTypeError;
 var MaxSimple;
 var MinSimple;
 var PackedArrayReverse;
 var SpeciesConstructor;
 var ToPositiveInteger;
 var iteratorSymbol = utils.ImportNow("iterator_symbol");
 var speciesSymbol = utils.ImportNow("species_symbol");
 var toStringTagSymbol = utils.ImportNow("to_string_tag_symbol");
 
 macro TYPED_ARRAYS(FUNCTION)
@@ skipping 30 matching lines @@
   InnerArrayForEach = from.InnerArrayForEach;
   InnerArrayIndexOf = from.InnerArrayIndexOf;
   InnerArrayJoin = from.InnerArrayJoin;
   InnerArrayLastIndexOf = from.InnerArrayLastIndexOf;
   InnerArrayReduce = from.InnerArrayReduce;
   InnerArrayReduceRight = from.InnerArrayReduceRight;
   InnerArraySome = from.InnerArraySome;
   InnerArraySort = from.InnerArraySort;
   InnerArrayToLocaleString = from.InnerArrayToLocaleString;
   IsNaN = from.IsNaN;
-  MakeRangeError = from.MakeRangeError;
-  MakeTypeError = from.MakeTypeError;
   MaxSimple = from.MaxSimple;
   MinSimple = from.MinSimple;
   PackedArrayReverse = from.PackedArrayReverse;
   SpeciesConstructor = from.SpeciesConstructor;
   ToPositiveInteger = from.ToPositiveInteger;
 });
 
 // --------------- Typed Arrays ---------------------
 
 function TypedArrayDefaultConstructor(typedArray) {
   switch (%_ClassOf(typedArray)) {
 macro TYPED_ARRAY_CONSTRUCTOR_CASE(ARRAY_ID, NAME, ELEMENT_SIZE)
     case "NAME":
       return GlobalNAME;
 endmacro
 TYPED_ARRAYS(TYPED_ARRAY_CONSTRUCTOR_CASE)
   }
   // The TypeError should not be generated since all callers should
   // have already called ValidateTypedArray.
-  throw MakeTypeError(kIncompatibleMethodReceiver,
+  throw %make_type_error(kIncompatibleMethodReceiver,
                       "TypedArrayDefaultConstructor", this);
 }
 
 function TypedArrayCreate(constructor, arg0, arg1, arg2) {
   if (IS_UNDEFINED(arg1)) {
     var newTypedArray = new constructor(arg0);
   } else {
     var newTypedArray = new constructor(arg0, arg1, arg2);
   }
-  if (!IS_TYPEDARRAY(newTypedArray)) throw MakeTypeError(kNotTypedArray);
+  if (!IS_TYPEDARRAY(newTypedArray)) throw %make_type_error(kNotTypedArray);
   // TODO(littledan): Check for being detached, here and elsewhere
   // All callers where the first argument is a Number have no additional
   // arguments.
   if (IS_NUMBER(arg0) && %_TypedArrayGetLength(newTypedArray) < arg0) {
-    throw MakeTypeError(kTypedArrayTooShort);
+    throw %make_type_error(kTypedArrayTooShort);
   }
   return newTypedArray;
 }
 
 function TypedArraySpeciesCreate(exemplar, arg0, arg1, arg2, conservative) {
   var defaultConstructor = TypedArrayDefaultConstructor(exemplar);
   var constructor = SpeciesConstructor(exemplar, defaultConstructor,
                                        conservative);
   return TypedArrayCreate(constructor, arg0, arg1, arg2);
 }
 
 macro TYPED_ARRAY_CONSTRUCTOR(ARRAY_ID, NAME, ELEMENT_SIZE)
 function NAMEConstructByArrayBuffer(obj, buffer, byteOffset, length) {
   if (!IS_UNDEFINED(byteOffset)) {
     byteOffset = ToPositiveInteger(byteOffset, kInvalidTypedArrayLength);
   }
   if (!IS_UNDEFINED(length)) {
     length = ToPositiveInteger(length, kInvalidTypedArrayLength);
   }
 
   var bufferByteLength = %_ArrayBufferGetByteLength(buffer);
   var offset;
   if (IS_UNDEFINED(byteOffset)) {
     offset = 0;
   } else {
     offset = byteOffset;
 
     if (offset % ELEMENT_SIZE !== 0) {
-      throw MakeRangeError(kInvalidTypedArrayAlignment,
+      throw %make_range_error(kInvalidTypedArrayAlignment,
                            "start offset", "NAME", ELEMENT_SIZE);
     }
     if (offset > bufferByteLength) {
-      throw MakeRangeError(kInvalidTypedArrayOffset);
+      throw %make_range_error(kInvalidTypedArrayOffset);
     }
   }
 
   var newByteLength;
   var newLength;
   if (IS_UNDEFINED(length)) {
     if (bufferByteLength % ELEMENT_SIZE !== 0) {
-      throw MakeRangeError(kInvalidTypedArrayAlignment,
+      throw %make_range_error(kInvalidTypedArrayAlignment,
                            "byte length", "NAME", ELEMENT_SIZE);
     }
     newByteLength = bufferByteLength - offset;
     newLength = newByteLength / ELEMENT_SIZE;
   } else {
     var newLength = length;
     newByteLength = newLength * ELEMENT_SIZE;
   }
   if ((offset + newByteLength > bufferByteLength)
       || (newLength > %_MaxSmi())) {
-    throw MakeRangeError(kInvalidTypedArrayLength);
+    throw %make_range_error(kInvalidTypedArrayLength);
   }
   %_TypedArrayInitialize(obj, ARRAY_ID, buffer, offset, newByteLength, true);
 }
 
 function NAMEConstructByLength(obj, length) {
   var l = IS_UNDEFINED(length) ?
     0 : ToPositiveInteger(length, kInvalidTypedArrayLength);
   if (l > %_MaxSmi()) {
-    throw MakeRangeError(kInvalidTypedArrayLength);
+    throw %make_range_error(kInvalidTypedArrayLength);
   }
   var byteLength = l * ELEMENT_SIZE;
   if (byteLength > %_TypedArrayMaxSizeInHeap()) {
     var buffer = new GlobalArrayBuffer(byteLength);
     %_TypedArrayInitialize(obj, ARRAY_ID, buffer, 0, byteLength, true);
   } else {
     %_TypedArrayInitialize(obj, ARRAY_ID, null, 0, byteLength, true);
   }
 }
 
 function NAMEConstructByArrayLike(obj, arrayLike, length) {
   var l = ToPositiveInteger(length, kInvalidTypedArrayLength);
 
   if (l > %_MaxSmi()) {
-    throw MakeRangeError(kInvalidTypedArrayLength);
+    throw %make_range_error(kInvalidTypedArrayLength);
   }
   var initialized = false;
   var byteLength = l * ELEMENT_SIZE;
   if (byteLength <= %_TypedArrayMaxSizeInHeap()) {
     %_TypedArrayInitialize(obj, ARRAY_ID, null, 0, byteLength, false);
   } else {
     initialized =
         %TypedArrayInitializeFromArrayLike(obj, ARRAY_ID, arrayLike, l);
   }
   if (!initialized) {
@@ skipping 52 matching lines @@
       NAMEConstructByTypedArray(this, arg1);
     } else {
       var iteratorFn = arg1[iteratorSymbol];
       if (IS_UNDEFINED(iteratorFn) || iteratorFn === ArrayValues) {
         NAMEConstructByArrayLike(this, arg1, arg1.length);
       } else {
         NAMEConstructByIterable(this, arg1, iteratorFn);
       }
     }
   } else {
-    throw MakeTypeError(kConstructorNotFunction, "NAME")
+    throw %make_type_error(kConstructorNotFunction, "NAME")
   }
 }
 
 function NAMESubArray(begin, end) {
   var beginInt = TO_INTEGER(begin);
   if (!IS_UNDEFINED(end)) {
     var endInt = TO_INTEGER(end);
     var srcLength = %_TypedArrayGetLength(this);
   } else {
     var srcLength = %_TypedArrayGetLength(this);
@@ skipping 29 matching lines @@
 TYPED_ARRAYS(TYPED_ARRAY_CONSTRUCTOR)
 
 function TypedArraySubArray(begin, end) {
   switch (%_ClassOf(this)) {
 macro TYPED_ARRAY_SUBARRAY_CASE(ARRAY_ID, NAME, ELEMENT_SIZE)
     case "NAME":
       return %_Call(NAMESubArray, this, begin, end);
 endmacro
 TYPED_ARRAYS(TYPED_ARRAY_SUBARRAY_CASE)
   }
-  throw MakeTypeError(kIncompatibleMethodReceiver,
+  throw %make_type_error(kIncompatibleMethodReceiver,
                       "get TypedArray.prototype.subarray", this);
 }
 %SetForceInlineFlag(TypedArraySubArray);
 
 
 
 function TypedArraySetFromArrayLike(target, source, sourceLength, offset) {
   if (offset > 0) {
     for (var i = 0; i < sourceLength; i++) {
       target[offset + i] = source[i];
@@ skipping 53 matching lines @@
   for (var i = leftIndex; i <= rightIndex; i++) {
     temp[i - leftIndex] = source[i];
   }
   for (i = leftIndex; i <= rightIndex; i++) {
     target[offset + i] = temp[i - leftIndex];
   }
 }
 
 function TypedArraySet(obj, offset) {
   var intOffset = IS_UNDEFINED(offset) ? 0 : TO_INTEGER(offset);
-  if (intOffset < 0) throw MakeTypeError(kTypedArraySetNegativeOffset);
+  if (intOffset < 0) throw %make_type_error(kTypedArraySetNegativeOffset);
 
   if (intOffset > %_MaxSmi()) {
-    throw MakeRangeError(kTypedArraySetSourceTooLarge);
+    throw %make_range_error(kTypedArraySetSourceTooLarge);
   }
   switch (%TypedArraySetFastCases(this, obj, intOffset)) {
     // These numbers should be synchronized with runtime.cc.
     case 0: // TYPED_ARRAY_SET_TYPED_ARRAY_SAME_TYPE
       return;
     case 1: // TYPED_ARRAY_SET_TYPED_ARRAY_OVERLAPPING
       TypedArraySetFromOverlappingTypedArray(this, obj, intOffset);
       return;
     case 2: // TYPED_ARRAY_SET_TYPED_ARRAY_NONOVERLAPPING
       TypedArraySetFromArrayLike(this,
           obj, %_TypedArrayGetLength(obj), intOffset);
       return;
     case 3: // TYPED_ARRAY_SET_NON_TYPED_ARRAY
       var l = obj.length;
       if (IS_UNDEFINED(l)) {
         if (IS_NUMBER(obj)) {
             // For number as a first argument, throw TypeError
             // instead of silently ignoring the call, so that
             // the user knows (s)he did something wrong.
             // (Consistent with Firefox and Blink/WebKit)
-            throw MakeTypeError(kInvalidArgument);
+            throw %make_type_error(kInvalidArgument);
         }
         return;
       }
       l = TO_LENGTH(l);
       if (intOffset + l > %_TypedArrayGetLength(this)) {
-        throw MakeRangeError(kTypedArraySetSourceTooLarge);
+        throw %make_range_error(kTypedArraySetSourceTooLarge);
       }
       TypedArraySetFromArrayLike(this, obj, l, intOffset);
       return;
   }
 }
 %FunctionSetLength(TypedArraySet, 1);
 
 function TypedArrayGetToStringTag() {
   if (!IS_TYPEDARRAY(this)) return;
   var name = %_ClassOf(this);
   if (IS_UNDEFINED(name)) return;
   return name;
 }
 
 
 function TypedArrayCopyWithin(target, start, end) {
-  if (!IS_TYPEDARRAY(this)) throw MakeTypeError(kNotTypedArray);
+  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
 
   var length = %_TypedArrayGetLength(this);
 
   // TODO(littledan): Replace with a memcpy for better performance
   return InnerArrayCopyWithin(target, start, end, this, length);
 }
 %FunctionSetLength(TypedArrayCopyWithin, 2);
 
 
 // ES6 draft 05-05-15, section 22.2.3.7
 function TypedArrayEvery(f, receiver) {
-  if (!IS_TYPEDARRAY(this)) throw MakeTypeError(kNotTypedArray);
+  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
 
   var length = %_TypedArrayGetLength(this);
 
   return InnerArrayEvery(f, receiver, this, length);
 }
 %FunctionSetLength(TypedArrayEvery, 1);
 
 
 // ES6 draft 08-24-14, section 22.2.3.12
 function TypedArrayForEach(f, receiver) {
-  if (!IS_TYPEDARRAY(this)) throw MakeTypeError(kNotTypedArray);
+  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
 
   var length = %_TypedArrayGetLength(this);
 
   InnerArrayForEach(f, receiver, this, length);
 }
 %FunctionSetLength(TypedArrayForEach, 1);
 
 
 // ES6 draft 04-05-14 section 22.2.3.8
 function TypedArrayFill(value, start, end) {
-  if (!IS_TYPEDARRAY(this)) throw MakeTypeError(kNotTypedArray);
+  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
 
   var length = %_TypedArrayGetLength(this);
 
   return InnerArrayFill(value, start, end, this, length);
 }
 %FunctionSetLength(TypedArrayFill, 1);
 
 
 // ES6 draft 07-15-13, section 22.2.3.9
 function TypedArrayFilter(f, thisArg) {
-  if (!IS_TYPEDARRAY(this)) throw MakeTypeError(kNotTypedArray);
+  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
 
   var length = %_TypedArrayGetLength(this);
-  if (!IS_CALLABLE(f)) throw MakeTypeError(kCalledNonCallable, f);
+  if (!IS_CALLABLE(f)) throw %make_type_error(kCalledNonCallable, f);
   var result = new InternalArray();
   InnerArrayFilter(f, thisArg, this, length, result);
   var captured = result.length;
   var output = TypedArraySpeciesCreate(this, captured);
   for (var i = 0; i < captured; i++) {
     output[i] = result[i];
   }
   return output;
 }
 %FunctionSetLength(TypedArrayFilter, 1);
 
 
 // ES6 draft 07-15-13, section 22.2.3.10
 function TypedArrayFind(predicate, thisArg) {
-  if (!IS_TYPEDARRAY(this)) throw MakeTypeError(kNotTypedArray);
+  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
 
   var length = %_TypedArrayGetLength(this);
 
   return InnerArrayFind(predicate, thisArg, this, length);
 }
 %FunctionSetLength(TypedArrayFind, 1);
 
 
 // ES6 draft 07-15-13, section 22.2.3.11
 function TypedArrayFindIndex(predicate, thisArg) {
-  if (!IS_TYPEDARRAY(this)) throw MakeTypeError(kNotTypedArray);
+  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
 
   var length = %_TypedArrayGetLength(this);
 
   return InnerArrayFindIndex(predicate, thisArg, this, length);
 }
 %FunctionSetLength(TypedArrayFindIndex, 1);
 
 
 // ES6 draft 05-18-15, section 22.2.3.21
 function TypedArrayReverse() {
-  if (!IS_TYPEDARRAY(this)) throw MakeTypeError(kNotTypedArray);
+  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
 
   var length = %_TypedArrayGetLength(this);
 
   return PackedArrayReverse(this, length);
 }
 
 
 function TypedArrayComparefn(x, y) {
   if (x === 0 && x === y) {
     x = 1 / x;
     y = 1 / y;
   }
   if (x < y) {
     return -1;
   } else if (x > y) {
     return 1;
   } else if (IsNaN(x) && IsNaN(y)) {
     return IsNaN(y) ? 0 : 1;
   } else if (IsNaN(x)) {
     return 1;
   }
   return 0;
 }
 
 
 // ES6 draft 05-18-15, section 22.2.3.25
 function TypedArraySort(comparefn) {
-  if (!IS_TYPEDARRAY(this)) throw MakeTypeError(kNotTypedArray);
+  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
 
   var length = %_TypedArrayGetLength(this);
 
   if (IS_UNDEFINED(comparefn)) {
     comparefn = TypedArrayComparefn;
   }
 
   return InnerArraySort(this, length, comparefn);
 }
 
 
 // ES6 section 22.2.3.13
 function TypedArrayIndexOf(element, index) {
-  if (!IS_TYPEDARRAY(this)) throw MakeTypeError(kNotTypedArray);
+  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
 
   var length = %_TypedArrayGetLength(this);
   return InnerArrayIndexOf(this, element, index, length);
 }
 %FunctionSetLength(TypedArrayIndexOf, 1);
 
 
 // ES6 section 22.2.3.16
 function TypedArrayLastIndexOf(element, index) {
-  if (!IS_TYPEDARRAY(this)) throw MakeTypeError(kNotTypedArray);
+  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
 
   var length = %_TypedArrayGetLength(this);
 
   return InnerArrayLastIndexOf(this, element, index, length,
                                arguments.length);
 }
 %FunctionSetLength(TypedArrayLastIndexOf, 1);
 
 
 // ES6 draft 07-15-13, section 22.2.3.18
 function TypedArrayMap(f, thisArg) {
-  if (!IS_TYPEDARRAY(this)) throw MakeTypeError(kNotTypedArray);
+  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
 
   var length = %_TypedArrayGetLength(this);
   var result = TypedArraySpeciesCreate(this, length);
-  if (!IS_CALLABLE(f)) throw MakeTypeError(kCalledNonCallable, f);
+  if (!IS_CALLABLE(f)) throw %make_type_error(kCalledNonCallable, f);
   for (var i = 0; i < length; i++) {
     var element = this[i];
     result[i] = %_Call(f, thisArg, element, i, this);
   }
   return result;
 }
 %FunctionSetLength(TypedArrayMap, 1);
 
 
 // ES6 draft 05-05-15, section 22.2.3.24
 function TypedArraySome(f, receiver) {
-  if (!IS_TYPEDARRAY(this)) throw MakeTypeError(kNotTypedArray);
+  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
 
   var length = %_TypedArrayGetLength(this);
 
   return InnerArraySome(f, receiver, this, length);
 }
 %FunctionSetLength(TypedArraySome, 1);
 
 
 // ES6 section 22.2.3.27
 function TypedArrayToLocaleString() {
-  if (!IS_TYPEDARRAY(this)) throw MakeTypeError(kNotTypedArray);
+  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
 
   var length = %_TypedArrayGetLength(this);
 
   return InnerArrayToLocaleString(this, length);
 }
 
 
 // ES6 section 22.2.3.14
 function TypedArrayJoin(separator) {
-  if (!IS_TYPEDARRAY(this)) throw MakeTypeError(kNotTypedArray);
+  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
 
   var length = %_TypedArrayGetLength(this);
 
   return InnerArrayJoin(separator, this, length);
 }
 
 
 // ES6 draft 07-15-13, section 22.2.3.19
 function TypedArrayReduce(callback, current) {
-  if (!IS_TYPEDARRAY(this)) throw MakeTypeError(kNotTypedArray);
+  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
 
   var length = %_TypedArrayGetLength(this);
   return InnerArrayReduce(callback, current, this, length,
                           arguments.length);
 }
 %FunctionSetLength(TypedArrayReduce, 1);
 
 
 // ES6 draft 07-15-13, section 22.2.3.19
 function TypedArrayReduceRight(callback, current) {
-  if (!IS_TYPEDARRAY(this)) throw MakeTypeError(kNotTypedArray);
+  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
 
   var length = %_TypedArrayGetLength(this);
   return InnerArrayReduceRight(callback, current, this, length,
                                arguments.length);
 }
 %FunctionSetLength(TypedArrayReduceRight, 1);
 
 
 function TypedArraySlice(start, end) {
-  if (!IS_TYPEDARRAY(this)) throw MakeTypeError(kNotTypedArray);
+  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
   var len = %_TypedArrayGetLength(this);
 
   var relativeStart = TO_INTEGER(start);
 
   var k;
   if (relativeStart < 0) {
     k = MaxSimple(len + relativeStart, 0);
   } else {
     k = MinSimple(relativeStart, len);
   }
@@ skipping 23 matching lines @@
     array[n] = kValue;
     k++;
     n++;
   }
   return array;
 }
 
 
 // ES2016 draft, section 22.2.3.14
 function TypedArrayIncludes(searchElement, fromIndex) {
-  if (!IS_TYPEDARRAY(this)) throw MakeTypeError(kNotTypedArray);
+  if (!IS_TYPEDARRAY(this)) throw %make_type_error(kNotTypedArray);
 
   var length = %_TypedArrayGetLength(this);
 
   if (length === 0) return false;
   var n = TO_INTEGER(fromIndex);
 
   var k;
   if (n >= 0) {
     k = n;
   } else {
@@ skipping 43 matching lines @@
     %MoveArrayContents(internal_array, array);
     return array;
   }
   return TO_OBJECT(items);
 }
 
 
 // ES#sec-%typedarray%.from
 // %TypedArray%.from ( source [ , mapfn [ , thisArg ] ] )
 function TypedArrayFrom(source, mapfn, thisArg) {
-  if (!%IsConstructor(this)) throw MakeTypeError(kNotConstructor, this);
+  if (!%IsConstructor(this)) throw %make_type_error(kNotConstructor, this);
   var mapping;
   if (!IS_UNDEFINED(mapfn)) {
-    if (!IS_CALLABLE(mapfn)) throw MakeTypeError(kCalledNonCallable, this);
+    if (!IS_CALLABLE(mapfn)) throw %make_type_error(kCalledNonCallable, this);
     mapping = true;
   } else {
     mapping = false;
   }
   var arrayLike = IterableToArrayLike(source);
   var length = TO_LENGTH(arrayLike.length);
   var targetObject = TypedArrayCreate(this, length);
   var value, mappedValue;
   for (var i = 0; i < length; i++) {
     value = arrayLike[i];
     if (mapping) {
       mappedValue = %_Call(mapfn, thisArg, value, i);
     } else {
       mappedValue = value;
     }
     targetObject[i] = mappedValue;
   }
   return targetObject;
 }
 %FunctionSetLength(TypedArrayFrom, 1);
 
 // TODO(bmeurer): Migrate this to a proper builtin.
 function TypedArrayConstructor() {
   if (IS_UNDEFINED(new.target)) {
-    throw MakeTypeError(kConstructorNonCallable, "TypedArray");
+    throw %make_type_error(kConstructorNonCallable, "TypedArray");
   }
   if (new.target === GlobalTypedArray) {
-    throw MakeTypeError(kConstructAbstractClass, "TypedArray");
+    throw %make_type_error(kConstructAbstractClass, "TypedArray");
   }
 }
 
 function TypedArraySpecies() {
   return this;
 }
 
 // -------------------------------------------------------------------
 
 %SetCode(GlobalTypedArray, TypedArrayConstructor);
@@ skipping 60 matching lines @@
   FUNCTION(Int32)
   FUNCTION(Uint32)
   FUNCTION(Float32)
   FUNCTION(Float64)
 endmacro
 
 
 macro DATA_VIEW_GETTER_SETTER(TYPENAME)
 function DataViewGetTYPENAMEJS(offset, little_endian) {
   if (!IS_DATAVIEW(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
+    throw %make_type_error(kIncompatibleMethodReceiver,
                         'DataView.getTYPENAME', this);
   }
-  if (arguments.length < 1) throw MakeTypeError(kInvalidArgument);
+  if (arguments.length < 1) throw %make_type_error(kInvalidArgument);
   offset = ToPositiveInteger(offset, kInvalidDataViewAccessorOffset);
   return %DataViewGetTYPENAME(this, offset, !!little_endian);
 }
 %FunctionSetLength(DataViewGetTYPENAMEJS, 1);
 
 function DataViewSetTYPENAMEJS(offset, value, little_endian) {
   if (!IS_DATAVIEW(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
+    throw %make_type_error(kIncompatibleMethodReceiver,
                         'DataView.setTYPENAME', this);
   }
-  if (arguments.length < 2) throw MakeTypeError(kInvalidArgument);
+  if (arguments.length < 2) throw %make_type_error(kInvalidArgument);
   offset = ToPositiveInteger(offset, kInvalidDataViewAccessorOffset);
   %DataViewSetTYPENAME(this, offset, TO_NUMBER(value), !!little_endian);
 }
 %FunctionSetLength(DataViewSetTYPENAMEJS, 2);
 endmacro
 
 DATA_VIEW_TYPES(DATA_VIEW_GETTER_SETTER)
 
 utils.InstallFunctions(GlobalDataView.prototype, DONT_ENUM, [
   "getInt8", DataViewGetInt8JS,
@@ skipping 15 matching lines @@
   "setUint32", DataViewSetUint32JS,
 
   "getFloat32", DataViewGetFloat32JS,
   "setFloat32", DataViewSetFloat32JS,
 
   "getFloat64", DataViewGetFloat64JS,
   "setFloat64", DataViewSetFloat64JS
 ]);
 
 })