SIMD.js Add the other SIMD Phase 1 types.

src/macros.py

 # Copyright 2006-2009 the V8 project authors. All rights reserved.
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 #       notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 #       copyright notice, this list of conditions and the following
 #       disclaimer in the documentation and/or other materials provided
@@ skipping 73 matching lines @@
 # Type query macros.
 #
 # Note: We have special support for typeof(foo) === 'bar' in the compiler.
 #       It will *not* generate a runtime typeof call for the most important
 #       values of 'bar'.
 macro IS_NULL(arg)              = (arg === null);
 macro IS_NULL_OR_UNDEFINED(arg) = (arg == null);
 macro IS_UNDEFINED(arg)         = (arg === (void 0));
 macro IS_NUMBER(arg)            = (typeof(arg) === 'number');
 macro IS_FLOAT32X4(arg)         = (typeof(arg) === 'float32x4');
+macro IS_INT32X4(arg)           = (typeof(arg) === 'int32x4');
+macro IS_BOOL32X4(arg)          = (typeof(arg) === 'bool32x4');
+macro IS_INT16X8(arg)           = (typeof(arg) === 'int16x8');
+macro IS_BOOL16X8(arg)          = (typeof(arg) === 'bool16x8');
+macro IS_INT8X16(arg)           = (typeof(arg) === 'int8x16');
+macro IS_BOOL8X16(arg)          = (typeof(arg) === 'bool8x16');
 macro IS_STRING(arg)            = (typeof(arg) === 'string');
 macro IS_BOOLEAN(arg)           = (typeof(arg) === 'boolean');
 macro IS_SYMBOL(arg)            = (typeof(arg) === 'symbol');
 macro IS_OBJECT(arg)            = (%_IsObject(arg));
 macro IS_ARRAY(arg)             = (%_IsArray(arg));
 macro IS_DATE(arg)              = (%_IsDate(arg));
 macro IS_FUNCTION(arg)          = (%_IsFunction(arg));
 macro IS_REGEXP(arg)            = (%_IsRegExp(arg));
 macro IS_SET(arg)               = (%_ClassOf(arg) === 'Set');
 macro IS_MAP(arg)               = (%_ClassOf(arg) === 'Map');
 macro IS_WEAKMAP(arg)           = (%_ClassOf(arg) === 'WeakMap');
 macro IS_WEAKSET(arg)           = (%_ClassOf(arg) === 'WeakSet');
 macro IS_NUMBER_WRAPPER(arg)    = (%_ClassOf(arg) === 'Number');
 macro IS_FLOAT32X4_WRAPPER(arg) = (%_ClassOf(arg) === 'Float32x4');
+macro IS_INT32X4_WRAPPER(arg)   = (%_ClassOf(arg) === 'Int32x4');
+macro IS_BOOL32X4_WRAPPER(arg)  = (%_ClassOf(arg) === 'Bool32x4');
+macro IS_INT16X8_WRAPPER(arg)   = (%_ClassOf(arg) === 'Int16x8');
+macro IS_BOOL16X8_WRAPPER(arg)  = (%_ClassOf(arg) === 'Bool16x8');
+macro IS_INT8X16_WRAPPER(arg)   = (%_ClassOf(arg) === 'Int8x16');
+macro IS_BOOL8X16_WRAPPER(arg)  = (%_ClassOf(arg) === 'Bool8x16');
 macro IS_STRING_WRAPPER(arg)    = (%_ClassOf(arg) === 'String');
 macro IS_SYMBOL_WRAPPER(arg)    = (%_ClassOf(arg) === 'Symbol');
 macro IS_BOOLEAN_WRAPPER(arg)   = (%_ClassOf(arg) === 'Boolean');
 macro IS_ERROR(arg)             = (%_ClassOf(arg) === 'Error');
 macro IS_SCRIPT(arg)            = (%_ClassOf(arg) === 'Script');
 macro IS_ARGUMENTS(arg)         = (%_ClassOf(arg) === 'Arguments');
 macro IS_GLOBAL(arg)            = (%_ClassOf(arg) === 'global');
 macro IS_ARRAYBUFFER(arg)       = (%_ClassOf(arg) === 'ArrayBuffer');
 macro IS_DATAVIEW(arg)          = (%_ClassOf(arg) === 'DataView');
 macro IS_SHAREDARRAYBUFFER(arg) = (%_ClassOf(arg) === 'SharedArrayBuffer');
 macro IS_GENERATOR(arg)         = (%_ClassOf(arg) === 'Generator');
 macro IS_SET_ITERATOR(arg)      = (%_ClassOf(arg) === 'Set Iterator');
 macro IS_MAP_ITERATOR(arg)      = (%_ClassOf(arg) === 'Map Iterator');
 macro IS_UNDETECTABLE(arg)      = (%_IsUndetectableObject(arg));
 macro IS_STRONG(arg)            = (%IsStrong(arg));
 
+macro IS_SIMD_VALUE(arg)         = (IS_FLOAT32X4(arg) || IS_INT32X4(arg) || IS_BOOL32X4(arg) || IS_INT16X8(arg) || IS_BOOL16X8(arg) || IS_INT8X16(arg) || IS_BOOL8X16(arg));

[rossberg, 2015/07/29 14:37:55]

Hm, this seems rather expensive. It is used on some potentially
performance-relevant paths, so there should probably be a %_IsSimdValue
intrinsic to make it efficient. I'm fine with doing that in a follow-up CL, but
better be prepared that landing the CL as is might affect some benchmarks.

[bbudge, 2015/07/30 13:46:58]

I don't like those perf bugs, so I'll use your suggestion now. Done.

[rossberg, 2015/07/30 15:12:24]

Ah, note the difference between assembly intrinsics (%_XY) and C intrinsics
(%XY). The former are recognised as distinguished AST nodes for which code
generators generate inline assembly directly. The latter create runtime calls,
which are expensive. I actually had the former in mind, but that involves some
work. I doubt the latter will perform much better than the multi-disjunction.
But I guess we'll find out. :)

+macro IS_SIMD_VALUE_WRAPPER(arg) = (IS_FLOAT32X4_WRAPPER(arg) || IS_INT32X4_WRAPPER(arg) || IS_BOOL32X4_WRAPPER(arg) || IS_INT16X8_WRAPPER(arg) || IS_BOOL16X8_WRAPPER(arg) || IS_INT8X16_WRAPPER(arg) || IS_BOOL8X16_WRAPPER(arg));

[rossberg, 2015/07/29 14:37:55]

Is this actually used?

[bbudge, 2015/07/30 13:46:58]

Nope. Deleted.

+
 # Macro for ECMAScript 5 queries of the type:
 # "Type(O) is object."
 # This is the same as being either a function or an object in V8 terminology
 # (including proxies).
 # In addition, an undetectable object is also included by this.
 macro IS_SPEC_OBJECT(arg)   = (%_IsSpecObject(arg));
 
 # Macro for ECMAScript 5 queries of the type:
 # "IsCallable(O)"
 # We assume here that this is the same as being either a function or a function
@@ skipping 172 matching lines @@
 define NOT_FOUND = -1;
 
 # Check whether debug is active.
 define DEBUG_IS_ACTIVE = (%_DebugIsActive() != 0);
 macro DEBUG_IS_STEPPING(function) = (%_DebugIsActive() != 0 && %DebugCallbackSupportsStepping(function));
 macro DEBUG_PREPARE_STEP_IN_IF_STEPPING(function) = if (DEBUG_IS_STEPPING(function)) %DebugPrepareStepInIfStepping(function);
 
 # SharedFlag equivalents
 define kNotShared = false;
 define kShared = true;