[runtime] Remove the very dangerous %_CallFunction intrinsic.

src/js/messages.js

 // Copyright 2012 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) {
 
 %CheckIsBootstrapping();
 
@@ skipping 73 matching lines @@
 }
 
 
 function NoSideEffectToString(obj) {
   if (IS_STRING(obj)) return obj;
   if (IS_NUMBER(obj)) return %_NumberToString(obj);
   if (IS_BOOLEAN(obj)) return obj ? 'true' : 'false';
   if (IS_UNDEFINED(obj)) return 'undefined';
   if (IS_NULL(obj)) return 'null';
   if (IS_FUNCTION(obj)) {
-    var str = %_CallFunction(obj, obj, FunctionSourceString);
+    var str = %_Call(FunctionSourceString, obj, obj);
     if (str.length > 128) {
       str = %_SubString(str, 0, 111) + "...<omitted>..." +
             %_SubString(str, str.length - 2, str.length);
     }
     return str;
   }
-  if (IS_SYMBOL(obj)) return %_CallFunction(obj, SymbolToString);
+  if (IS_SYMBOL(obj)) return %_Call(SymbolToString, obj);
   if (IS_SIMD_VALUE(obj)) {
     switch (typeof(obj)) {
-      case 'float32x4': return %_CallFunction(obj, Float32x4ToString);
-      case 'int32x4':   return %_CallFunction(obj, Int32x4ToString);
-      case 'int16x8':   return %_CallFunction(obj, Int16x8ToString);
-      case 'int8x16':   return %_CallFunction(obj, Int8x16ToString);
-      case 'uint32x4':   return %_CallFunction(obj, Uint32x4ToString);
-      case 'uint16x8':   return %_CallFunction(obj, Uint16x8ToString);
-      case 'uint8x16':   return %_CallFunction(obj, Uint8x16ToString);
-      case 'bool32x4':  return %_CallFunction(obj, Bool32x4ToString);
-      case 'bool16x8':  return %_CallFunction(obj, Bool16x8ToString);
-      case 'bool8x16':  return %_CallFunction(obj, Bool8x16ToString);
+      case 'float32x4': return %_Call(Float32x4ToString, obj);
+      case 'int32x4':   return %_Call(Int32x4ToString, obj);
+      case 'int16x8':   return %_Call(Int16x8ToString, obj);
+      case 'int8x16':   return %_Call(Int8x16ToString, obj);
+      case 'uint32x4':   return %_Call(Uint32x4ToString, obj);
+      case 'uint16x8':   return %_Call(Uint16x8ToString, obj);
+      case 'uint8x16':   return %_Call(Uint8x16ToString, obj);
+      case 'bool32x4':  return %_Call(Bool32x4ToString, obj);
+      case 'bool16x8':  return %_Call(Bool16x8ToString, obj);
+      case 'bool8x16':  return %_Call(Bool8x16ToString, obj);
     }
   }
   if (IS_OBJECT(obj)
       && %GetDataProperty(obj, "toString") === ObjectToString) {
     var constructor = %GetDataProperty(obj, "constructor");
     if (typeof constructor == "function") {
       var constructorName = constructor.name;
       if (IS_STRING(constructorName) && constructorName !== "") {
         return "#<" + constructorName + ">";
       }
     }
   }
   if (CanBeSafelyTreatedAsAnErrorObject(obj)) {
-    return %_CallFunction(obj, ErrorToString);
+    return %_Call(ErrorToString, obj);
   }
 
-  return %_CallFunction(obj, NoSideEffectsObjectToString);
+  return %_Call(NoSideEffectsObjectToString, obj);
 }
 
 // To determine whether we can safely stringify an object using ErrorToString
 // without the risk of side-effects, we need to check whether the object is
 // either an instance of a native error type (via '%_ClassOf'), or has Error
 // in its prototype chain and hasn't overwritten 'toString' with something
 // strange and unusual.
 function CanBeSafelyTreatedAsAnErrorObject(obj) {
   switch (%_ClassOf(obj)) {
     case 'Error':
@@ skipping 10 matching lines @@
   return obj instanceof GlobalError && objToString === ErrorToString;
 }
 
 
 // When formatting internally created error messages, do not
 // invoke overwritten error toString methods but explicitly use
 // the error to string method. This is to avoid leaking error
 // objects between script tags in a browser setting.
 function ToStringCheckErrorObject(obj) {
   if (CanBeSafelyTreatedAsAnErrorObject(obj)) {
-    return %_CallFunction(obj, ErrorToString);
+    return %_Call(ErrorToString, obj);
   } else {
     return TO_STRING(obj);
   }
 }
 
 
 function ToDetailString(obj) {
   if (obj != null && IS_OBJECT(obj) && obj.toString === ObjectToString) {
     var constructor = obj.constructor;
     if (typeof constructor == "function") {
@@ skipping 117 matching lines @@
  */
 function ScriptLocationFromPosition(position,
                                     include_resource_offset) {
   var line = this.lineFromPosition(position);
   if (line == -1) return null;
 
   // Determine start, end and column.
   var line_ends = this.line_ends;
   var start = line == 0 ? 0 : line_ends[line - 1] + 1;
   var end = line_ends[line];
-  if (end > 0 && %_CallFunction(this.source, end - 1, StringCharAt) == '\r') {
+  if (end > 0 && %_Call(StringCharAt, this.source, end - 1) == '\r') {
     end--;
   }
   var column = position - start;
 
   // Adjust according to the offset within the resource.
   if (include_resource_offset) {
     line += this.line_offset;
     if (line == this.line_offset) {
       column += this.column_offset;
     }
@@ skipping 102 matching lines @@
 
   // Check parameter.
   if (line < 0 || this.lineCount() <= line) {
     return null;
   }
 
   // Return the source line.
   var line_ends = this.line_ends;
   var start = line == 0 ? 0 : line_ends[line - 1] + 1;
   var end = line_ends[line];
-  return %_CallFunction(this.source, start, end, StringSubstring);
+  return %_Call(StringSubstring, this.source, start, end);
 }
 
 
 /**
  * Returns the number of source lines.
  * @return {number}
  *     Number of source lines.
  */
 function ScriptLineCount() {
   // Return number of source lines.
@@ skipping 78 matching lines @@
   this.end = end;
 }
 
 
 /**
  * Get the source text for a SourceLocation
  * @return {String}
  *     Source text for this location.
  */
 function SourceLocationSourceText() {
-  return %_CallFunction(this.script.source,
-                        this.start,
-                        this.end,
-                        StringSubstring);
+  return %_Call(StringSubstring, this.script.source, this.start, this.end);
 }
 
 
 utils.SetUpLockedPrototype(SourceLocation,
   ["script", "position", "line", "column", "start", "end"],
   ["sourceText", SourceLocationSourceText]
 );
 
 
 /**
@@ skipping 21 matching lines @@
   this.from_position = from_position;
   this.to_position = to_position;
 }
 
 /**
  * Get the source text for a SourceSlice
  * @return {String} Source text for this slice. The last line will include
  *     the line terminating characters (if any)
  */
 function SourceSliceSourceText() {
-  return %_CallFunction(this.script.source,
-                        this.from_position,
-                        this.to_position,
-                        StringSubstring);
+  return %_Call(StringSubstring,
+                this.script.source,
+                this.from_position,
+                this.to_position);
 }
 
 utils.SetUpLockedPrototype(SourceSlice,
   ["script", "from_line", "to_line", "from_position", "to_position"],
   ["sourceText", SourceSliceSourceText]
 );
 
 
 function GetStackTraceLine(recv, fun, pos, isGlobal) {
   return new CallSite(recv, fun, pos, false).toString();
@@ skipping 107 matching lines @@
 
   var line = "";
   var functionName = this.getFunctionName();
   var addSuffix = true;
   var isConstructor = this.isConstructor();
   var isMethodCall = !(this.isToplevel() || isConstructor);
   if (isMethodCall) {
     var typeName = GetTypeName(GET_PRIVATE(this, callSiteReceiverSymbol), true);
     var methodName = this.getMethodName();
     if (functionName) {
-      if (typeName &&
-          %_CallFunction(functionName, typeName, StringIndexOf) != 0) {
+      if (typeName && %_Call(StringIndexOf, functionName, typeName) != 0) {
         line += typeName + ".";
       }
       line += functionName;
       if (methodName &&
-          (%_CallFunction(functionName, "." + methodName, StringIndexOf) !=
+          (%_Call(StringIndexOf, functionName, "." + methodName) !=
            functionName.length - methodName.length - 1)) {
         line += " [as " + methodName + "]";
       }
     } else {
       line += typeName + "." + (methodName || "<anonymous>");
     }
   } else if (isConstructor) {
     line += "new " + (functionName || "<anonymous>");
   } else if (functionName) {
     line += functionName;
@@ skipping 61 matching lines @@
       }
     }
   }
 
   return eval_origin;
 }
 
 
 function FormatErrorString(error) {
   try {
-    return %_CallFunction(error, ErrorToString);
+    return %_Call(ErrorToString, error);
   } catch (e) {
     try {
       return "<error: " + e + ">";
     } catch (ee) {
       return "<error>";
     }
   }
 }
 
 
@@ skipping 45 matching lines @@
     } catch (e) {
       try {
         line = "<error: " + e + ">";
       } catch (ee) {
         // Any code that reaches this point is seriously nasty!
         line = "<error>";
       }
     }
     lines.push("    at " + line);
   }
-  return %_CallFunction(lines, "\n", ArrayJoin);
+  return %_Call(ArrayJoin, lines, "\n");
 }
 
 
 function GetTypeName(receiver, requireConstructor) {
   if (IS_NULL_OR_UNDEFINED(receiver)) return null;
   var constructor = receiver.constructor;
   if (!constructor) {
     return requireConstructor ? null :
-        %_CallFunction(receiver, NoSideEffectsObjectToString);
+        %_Call(NoSideEffectsObjectToString, receiver);
   }
   var constructorName = constructor.name;
   if (!constructorName) {
     return requireConstructor ? null :
-        %_CallFunction(receiver, NoSideEffectsObjectToString);
+        %_Call(NoSideEffectsObjectToString, receiver);
   }
   return constructorName;
 }
 
 
 // Format the stack trace if not yet done, and return it.
 // Cache the formatted stack trace on the holder.
 var StackTraceGetter = function() {
   var formatted_stack_trace = UNDEFINED;
   var holder = this;
@@ skipping 160 matching lines @@
 utils.Export(function(to) {
   to.ErrorToString = ErrorToString;
   to.MakeError = MakeError;
   to.MakeRangeError = MakeRangeError;
   to.MakeSyntaxError = MakeSyntaxError;
   to.MakeTypeError = MakeTypeError;
   to.MakeURIError = MakeURIError;
 });
 
 });