%define _binary_payload w3.gzdio
Name: crosswalk
-Version: 11.39.256.0
+Version: 11.39.258.0
Release: 0
Summary: Chromium-based app runtime
License: (BSD-3-Clause and LGPL-2.1+)
}
+void Deoptimizer::CopyDoubleRegisters(FrameDescription* output_frame) {
+}
+
+
void Deoptimizer::CopySIMD128Registers(FrameDescription* output_frame) {
for (int i = 0; i < DwVfpRegister::kMaxNumRegisters; ++i) {
double double_value = input_->GetDoubleRegister(i);
}
+simd128_value_t FrameDescription::GetSIMD128Register(unsigned n) const {
+ DCHECK(n < arraysize(simd128_registers_));
+ return simd128_registers_[n];
+}
+
+
+void FrameDescription::SetSIMD128Register(unsigned n, simd128_value_t value) {
+ DCHECK(n < arraysize(simd128_registers_));
+ simd128_registers_[n] = value;
+}
+
+
+int FrameDescription::double_registers_offset() {
+ return OFFSET_OF(FrameDescription, simd128_registers_);
+}
+
+
+int FrameDescription::simd128_registers_offset() {
+ return OFFSET_OF(FrameDescription, simd128_registers_);
+}
+
+
#undef __
} } // namespace v8::internal
bool CpuFeatures::SupportsCrankshaft() { return true; }
+bool CpuFeatures::SupportsSIMD128InCrankshaft() { return false; }
void RelocInfo::apply(intptr_t delta, ICacheFlushMode icache_flush_mode) {
// End of V8 compatibility section -----------------------
};
+struct SIMD128Register {
+ static const int kMaxNumRegisters = 0;
+
+ static int ToAllocationIndex(SIMD128Register reg) {
+ UNIMPLEMENTED();
+ return -1;
+ }
+
+ static const char* AllocationIndexToString(int index) {
+ UNIMPLEMENTED();
+ return NULL;
+ }
+};
+
STATIC_ASSERT(sizeof(CPURegister) == sizeof(Register));
STATIC_ASSERT(sizeof(CPURegister) == sizeof(FPRegister));
}
+void Deoptimizer::CopySIMD128Registers(FrameDescription* output_frame) {
+}
+
#define __ masm()->
}
+double FrameDescription::GetDoubleRegister(unsigned n) const {
+ DCHECK(n < arraysize(double_registers_));
+ return double_registers_[n];
+}
+
+
+void FrameDescription::SetDoubleRegister(unsigned n, double value) {
+ DCHECK(n < arraysize(double_registers_));
+ double_registers_[n] = value;
+}
+
+
+simd128_value_t FrameDescription::GetSIMD128Register(unsigned n) const {
+ UNREACHABLE();
+ simd128_value_t value;
+ return value;
+}
+
+
+void FrameDescription::SetSIMD128Register(unsigned n, simd128_value_t value) {
+ UNREACHABLE();
+}
+
+
+int FrameDescription::double_registers_offset() {
+ return OFFSET_OF(FrameDescription, double_registers_);
+}
+
+
+int FrameDescription::simd128_registers_offset() {
+ UNREACHABLE();
+ return -1;
+}
+
+
#undef __
} } // namespace v8::internal
}
+LInstruction* LChunkBuilder::DoNullarySIMDOperation(
+ HNullarySIMDOperation* instr) {
+ UNIMPLEMENTED();
+ return NULL;
+}
+
+
+LInstruction* LChunkBuilder::DoUnarySIMDOperation(
+ HUnarySIMDOperation* instr) {
+ UNIMPLEMENTED();
+ return NULL;
+}
+
+
+LInstruction* LChunkBuilder::DoBinarySIMDOperation(
+ HBinarySIMDOperation* instr) {
+ UNIMPLEMENTED();
+ return NULL;
+}
+
+
+LInstruction* LChunkBuilder::DoTernarySIMDOperation(
+ HTernarySIMDOperation* instr) {
+ UNIMPLEMENTED();
+ return NULL;
+}
+
+
+LInstruction* LChunkBuilder::DoQuarternarySIMDOperation(
+ HQuarternarySIMDOperation* instr) {
+ UNIMPLEMENTED();
+ return NULL;
+}
+
+
} } // namespace v8::internal
break;
case FLOAT32_ELEMENTS:
case FLOAT64_ELEMENTS:
+ case INT32x4_ELEMENTS:
+ case FLOAT32x4_ELEMENTS:
+ case FLOAT64x2_ELEMENTS:
case EXTERNAL_FLOAT32_ELEMENTS:
case EXTERNAL_FLOAT64_ELEMENTS:
+ case EXTERNAL_INT32x4_ELEMENTS:
+ case EXTERNAL_FLOAT32x4_ELEMENTS:
+ case EXTERNAL_FLOAT64x2_ELEMENTS:
case FAST_HOLEY_DOUBLE_ELEMENTS:
case FAST_HOLEY_ELEMENTS:
case FAST_HOLEY_SMI_ELEMENTS:
break;
case FLOAT32_ELEMENTS:
case FLOAT64_ELEMENTS:
+ case INT32x4_ELEMENTS:
+ case FLOAT32x4_ELEMENTS:
+ case FLOAT64x2_ELEMENTS:
case EXTERNAL_FLOAT32_ELEMENTS:
case EXTERNAL_FLOAT64_ELEMENTS:
+ case EXTERNAL_INT32x4_ELEMENTS:
+ case EXTERNAL_FLOAT32x4_ELEMENTS:
+ case EXTERNAL_FLOAT64x2_ELEMENTS:
case FAST_DOUBLE_ELEMENTS:
case FAST_ELEMENTS:
case FAST_SMI_ELEMENTS:
InstallBuiltinFunctionId(holder, #fun_name, id); \
}
SIMD_ARRAY_OPERATIONS(INSTALL_BUILTIN_ID)
+ TYPED_ARRAYS_SIMD_LOAD_OPERATIONS(INSTALL_BUILTIN_ID)
+ TYPED_ARRAYS_SIMD_STORE_OPERATIONS(INSTALL_BUILTIN_ID)
#define INSTALL_SIMD_NULLARY_FUNCTION_ID(p1, p2, p3, p4) \
INSTALL_BUILTIN_ID(p1, p2, p3)
SIMD_NULLARY_OPERATIONS(INSTALL_SIMD_NULLARY_FUNCTION_ID)
}
// Copy the double registers from the input into the output frame.
+ CopyDoubleRegisters(output_frame);
+
+ // Copy the simd128 registers from the input into the output frame.
CopySIMD128Registers(output_frame);
// Fill registers containing handler and number of parameters.
void SetPlatformCompiledStubRegisters(FrameDescription* output_frame,
CodeStubDescriptor* desc);
+ // Fill the given output frame's double registers with the original values
+ // from the input frame's double registers.
+ void CopyDoubleRegisters(FrameDescription* output_frame);
+
// Fill the given output frame's simd128 registers with the original values
// from the input frame's simd128 registers.
void CopySIMD128Registers(FrameDescription* output_frame);
// This convoluted DCHECK is needed to work around a gcc problem that
// improperly detects an array bounds overflow in optimized debug builds
// when using a plain DCHECK.
- if (n >= arraysize(registers_)) {
+ if (n >= arraysize(registers_) {
DCHECK(false);
return 0;
}
double GetDoubleRegister(unsigned n) const;
- simd128_value_t GetSIMD128Register(unsigned n) const {
- DCHECK(n < arraysize(simd128_registers_));
- return simd128_registers_[n];
- }
+ simd128_value_t GetSIMD128Register(unsigned n) const;
void SetRegister(unsigned n, intptr_t value) {
DCHECK(n < arraysize(registers_));
void SetDoubleRegister(unsigned n, double value);
- void SetSIMD128Register(unsigned n, simd128_value_t value) {
- DCHECK(n < arraysize(simd128_registers_));
- simd128_registers_[n] = value;
- }
+ void SetSIMD128Register(unsigned n, simd128_value_t value);
intptr_t GetTop() const { return top_; }
void SetTop(intptr_t top) { top_ = top; }
return OFFSET_OF(FrameDescription, registers_);
}
- static int simd128_registers_offset() {
- return OFFSET_OF(FrameDescription, simd128_registers_);
- }
+ static int double_registers_offset();
+
+ static int simd128_registers_offset();
static int frame_size_offset() {
return OFFSET_OF(FrameDescription, frame_size_);
uintptr_t frame_size_; // Number of bytes.
JSFunction* function_;
intptr_t registers_[Register::kNumRegisters];
+#if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X64 || V8_TARGET_ARCH_ARM
+ // For these architectures, the simd128 registers cover the double registers.
simd128_value_t simd128_registers_[SIMD128Register::kMaxNumRegisters];
+#else
+ double double_registers_[DoubleRegister::kMaxNumRegisters];
+#endif
intptr_t top_;
intptr_t pc_;
intptr_t fp_;
// Returns a shared ElementsAccessor for the specified ElementsKind.
static ElementsAccessor* ForKind(ElementsKind elements_kind) {
- DCHECK(elements_kind < kElementsKindCount);
+ DCHECK(static_cast<int>(elements_kind) < kElementsKindCount);
return elements_accessors_[elements_kind];
}
return new(zone) I(p1, p2, p3, p4, p5, p6); \
}
+#define DECLARE_INSTRUCTION_FACTORY_P7(I, P1, P2, P3, P4, P5, P6, P7) \
+ static I* New(Zone* zone, \
+ HValue* context, \
+ P1 p1, \
+ P2 p2, \
+ P3 p3, \
+ P4 p4, \
+ P5 p5, \
+ P6 p6, \
+ P7 p7) { \
+ return new(zone) I(p1, p2, p3, p4, p5, p6, p7); \
+ }
+
#define DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P0(I) \
static I* New(Zone* zone, HValue* context) { \
return new(zone) I(context); \
class HBoundsCheck FINAL : public HTemplateInstruction<2> {
public:
DECLARE_INSTRUCTION_FACTORY_P2(HBoundsCheck, HValue*, HValue*);
+ DECLARE_INSTRUCTION_FACTORY_P4(HBoundsCheck, HValue*, HValue*,
+ BuiltinFunctionId, ElementsKind);
bool skip_check() const { return skip_check_; }
void set_skip_check() { skip_check_ = true; }
HValue* length() const { return OperandAt(1); }
bool allow_equality() const { return allow_equality_; }
void set_allow_equality(bool v) { allow_equality_ = v; }
+ BuiltinFunctionId op() const { return op_; }
+ ElementsKind element_kind() const { return element_kind_; }
virtual int RedefinedOperandIndex() OVERRIDE { return 0; }
virtual bool IsPurelyInformativeDefinition() OVERRIDE {
int offset_;
int scale_;
bool allow_equality_;
+ BuiltinFunctionId op_;
+ ElementsKind element_kind_;
private:
// Normally HBoundsCheck should be created using the
// HGraphBuilder::AddBoundsCheck() helper.
// However when building stubs, where we know that the arguments are Int32,
// it makes sense to invoke this constructor directly.
- HBoundsCheck(HValue* index, HValue* length)
+ HBoundsCheck(HValue* index, HValue* length,
+ BuiltinFunctionId op = kNumberOfBuiltinFunction,
+ ElementsKind element_kind = EXTERNAL_INT8_ELEMENTS)
: skip_check_(false),
base_(NULL), offset_(0), scale_(0),
- allow_equality_(false) {
+ allow_equality_(false), op_(op),
+ element_kind_(element_kind) {
SetOperandAt(0, index);
SetOperandAt(1, length);
SetFlag(kFlexibleRepresentation);
ElementsKind, LoadKeyedHoleMode);
DECLARE_INSTRUCTION_FACTORY_P6(HLoadKeyed, HValue*, HValue*, HValue*,
ElementsKind, LoadKeyedHoleMode, int);
+ DECLARE_INSTRUCTION_FACTORY_P7(HLoadKeyed, HValue*, HValue*, HValue*,
+ ElementsKind, LoadKeyedHoleMode, int,
+ BuiltinFunctionId);
bool is_external() const {
return IsExternalArrayElementsKind(elements_kind());
bool HasDependency() const { return OperandAt(0) != OperandAt(2); }
uint32_t base_offset() const { return BaseOffsetField::decode(bit_field_); }
bool TryIncreaseBaseOffset(uint32_t increase_by_value);
+ BuiltinFunctionId op() {return op_;}
HValue* GetKey() { return key(); }
void SetKey(HValue* key) { SetOperandAt(1, key); }
bool IsDehoisted() const { return IsDehoistedField::decode(bit_field_); }
HValue* dependency,
ElementsKind elements_kind,
LoadKeyedHoleMode mode = NEVER_RETURN_HOLE,
- int offset = kDefaultKeyedHeaderOffsetSentinel)
- : bit_field_(0) {
+ int offset = kDefaultKeyedHeaderOffsetSentinel,
+ BuiltinFunctionId op = kNumberOfBuiltinFunction)
+ : bit_field_(0), op_(op) {
offset = offset == kDefaultKeyedHeaderOffsetSentinel
? GetDefaultHeaderSizeForElementsKind(elements_kind)
: offset;
SetDependsOnFlag(kDoubleArrayElements);
}
} else {
- if (elements_kind == EXTERNAL_FLOAT32_ELEMENTS ||
+ if (op_ == kFloat32ArrayGetFloat32x4XYZW ||
+ op_ == kFloat32ArrayGetFloat32x4X ||
+ op_ == kFloat32ArrayGetFloat32x4XY ||
+ op_ == kFloat32ArrayGetFloat32x4XYZ ||
+ op_ == kInt8ArrayGetFloat32x4XYZW ||
+ op_ == kInt8ArrayGetFloat32x4X ||
+ op_ == kInt8ArrayGetFloat32x4XY ||
+ op_ == kInt8ArrayGetFloat32x4XYZ) {
+ set_representation(Representation::Float32x4());
+ } else if (op_ == kFloat64ArrayGetFloat64x2XY ||
+ op_ == kFloat64ArrayGetFloat64x2X ||
+ op_ == kInt8ArrayGetFloat64x2XY ||
+ op_ == kInt8ArrayGetFloat64x2X) {
+ set_representation(Representation::Float64x2());
+ } else if (op_ == kInt32ArrayGetInt32x4XYZW ||
+ op_ == kInt32ArrayGetInt32x4X ||
+ op_ == kInt32ArrayGetInt32x4XY ||
+ op_ == kInt32ArrayGetInt32x4XYZ ||
+ op_ == kInt8ArrayGetInt32x4XYZW ||
+ op_ == kInt8ArrayGetInt32x4X ||
+ op_ == kInt8ArrayGetInt32x4XY ||
+ op_ == kInt8ArrayGetInt32x4XYZ) {
+ set_representation(Representation::Int32x4());
+ } else if (elements_kind == EXTERNAL_FLOAT32_ELEMENTS ||
elements_kind == EXTERNAL_FLOAT64_ELEMENTS ||
elements_kind == FLOAT32_ELEMENTS ||
elements_kind == FLOAT64_ELEMENTS) {
public BitField<bool, kStartIsDehoisted, kBitsForIsDehoisted>
{}; // NOLINT
uint32_t bit_field_;
+ BuiltinFunctionId op_;
};
ElementsKind, StoreFieldOrKeyedMode);
DECLARE_INSTRUCTION_FACTORY_P6(HStoreKeyed, HValue*, HValue*, HValue*,
ElementsKind, StoreFieldOrKeyedMode, int);
+ DECLARE_INSTRUCTION_FACTORY_P7(HStoreKeyed, HValue*, HValue*, HValue*,
+ ElementsKind, StoreFieldOrKeyedMode, int,
+ BuiltinFunctionId);
virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
// kind_fast: tagged[int32] = tagged
}
DCHECK_EQ(index, 2);
+ if (op_ == kFloat32ArraySetFloat32x4XYZW ||
+ op_ == kFloat32ArraySetFloat32x4X ||
+ op_ == kFloat32ArraySetFloat32x4XY ||
+ op_ == kFloat32ArraySetFloat32x4XYZ ||
+ op_ == kInt8ArraySetFloat32x4XYZW ||
+ op_ == kInt8ArraySetFloat32x4X ||
+ op_ == kInt8ArraySetFloat32x4XY ||
+ op_ == kInt8ArraySetFloat32x4XYZ) {
+ return Representation::Float32x4();
+ } else if (op_ == kFloat64ArraySetFloat64x2XY ||
+ op_ == kFloat64ArraySetFloat64x2X ||
+ op_ == kInt8ArraySetFloat64x2XY ||
+ op_ == kInt8ArraySetFloat64x2X) {
+ return Representation::Float64x2();
+ } else if (op_ == kInt32ArraySetInt32x4XYZW ||
+ op_ == kInt32ArraySetInt32x4X ||
+ op_ == kInt32ArraySetInt32x4XY ||
+ op_ == kInt32ArraySetInt32x4XYZ ||
+ op_ == kInt8ArraySetInt32x4XYZW ||
+ op_ == kInt8ArraySetInt32x4X ||
+ op_ == kInt8ArraySetInt32x4XY ||
+ op_ == kInt8ArraySetInt32x4XYZ) {
+ return Representation::Int32x4();
+ }
return RequiredValueRepresentation(elements_kind_, store_mode_);
}
if (IsUninitialized()) {
return Representation::None();
}
+ if (op_ == kFloat32ArraySetFloat32x4XYZW ||
+ op_ == kFloat32ArraySetFloat32x4X ||
+ op_ == kFloat32ArraySetFloat32x4XY ||
+ op_ == kFloat32ArraySetFloat32x4XYZ ||
+ op_ == kInt8ArraySetFloat32x4XYZW ||
+ op_ == kInt8ArraySetFloat32x4X ||
+ op_ == kInt8ArraySetFloat32x4XY ||
+ op_ == kInt8ArraySetFloat32x4XYZ) {
+ return Representation::Float32x4();
+ } else if (op_ == kFloat64ArraySetFloat64x2XY ||
+ op_ == kFloat64ArraySetFloat64x2X ||
+ op_ == kInt8ArraySetFloat64x2XY ||
+ op_ == kInt8ArraySetFloat64x2X) {
+ return Representation::Float64x2();
+ } else if (op_ == kInt32ArraySetInt32x4XYZW ||
+ op_ == kInt32ArraySetInt32x4X ||
+ op_ == kInt32ArraySetInt32x4XY ||
+ op_ == kInt32ArraySetInt32x4XYZ ||
+ op_ == kInt8ArraySetInt32x4XYZW ||
+ op_ == kInt8ArraySetInt32x4X ||
+ op_ == kInt8ArraySetInt32x4XY ||
+ op_ == kInt8ArraySetInt32x4XYZ) {
+ return Representation::Int32x4();
+ }
Representation r = RequiredValueRepresentation(elements_kind_, store_mode_);
// For fast object elements kinds, don't assume anything.
if (r.IsTagged()) return Representation::None();
return r;
}
+ BuiltinFunctionId op() const { return op_; }
HValue* elements() const { return OperandAt(0); }
HValue* key() const { return OperandAt(1); }
HValue* value() const { return OperandAt(2); }
HStoreKeyed(HValue* obj, HValue* key, HValue* val,
ElementsKind elements_kind,
StoreFieldOrKeyedMode store_mode = INITIALIZING_STORE,
- int offset = kDefaultKeyedHeaderOffsetSentinel)
+ int offset = kDefaultKeyedHeaderOffsetSentinel,
+ BuiltinFunctionId op = kNumberOfBuiltinFunction)
: elements_kind_(elements_kind),
base_offset_(offset == kDefaultKeyedHeaderOffsetSentinel
? GetDefaultHeaderSizeForElementsKind(elements_kind)
is_dehoisted_(false),
is_uninitialized_(false),
store_mode_(store_mode),
- dominator_(NULL) {
+ dominator_(NULL),
+ op_(op) {
SetOperandAt(0, obj);
SetOperandAt(1, key);
SetOperandAt(2, val);
bool is_uninitialized_ : 1;
StoreFieldOrKeyedMode store_mode_: 1;
HValue* dominator_;
+ BuiltinFunctionId op_;
};
ElementsKind elements_kind,
PropertyAccessType access_type,
LoadKeyedHoleMode load_mode,
- KeyedAccessStoreMode store_mode) {
+ KeyedAccessStoreMode store_mode,
+ BuiltinFunctionId op) {
DCHECK((!IsExternalArrayElementsKind(elements_kind) &&
!IsFixedTypedArrayElementsKind(elements_kind)) ||
!is_js_array);
return result;
} else {
DCHECK(store_mode == STANDARD_STORE);
- checked_key = Add<HBoundsCheck>(key, length);
+ checked_key = Add<HBoundsCheck>(key, length, op, elements_kind);
return AddElementAccess(
backing_store, checked_key, val,
- checked_object, elements_kind, access_type);
+ checked_object, elements_kind, access_type, NEVER_RETURN_HOLE, op);
}
}
DCHECK(fast_smi_only_elements ||
}
}
return AddElementAccess(elements, checked_key, val, checked_object,
- elements_kind, access_type, load_mode);
+ elements_kind, access_type, load_mode, op);
}
HValue* dependency,
ElementsKind elements_kind,
PropertyAccessType access_type,
- LoadKeyedHoleMode load_mode) {
+ LoadKeyedHoleMode load_mode,
+ BuiltinFunctionId op) {
if (access_type == STORE) {
DCHECK(val != NULL);
if (elements_kind == EXTERNAL_UINT8_CLAMPED_ELEMENTS ||
val = Add<HClampToUint8>(val);
}
return Add<HStoreKeyed>(elements, checked_key, val, elements_kind,
- STORE_TO_INITIALIZED_ENTRY);
+ STORE_TO_INITIALIZED_ENTRY,
+ kDefaultKeyedHeaderOffsetSentinel, op);
}
DCHECK(access_type == LOAD);
DCHECK(val == NULL);
HLoadKeyed* load = Add<HLoadKeyed>(
- elements, checked_key, dependency, elements_kind, load_mode);
+ elements, checked_key, dependency, elements_kind, load_mode,
+ kDefaultKeyedHeaderOffsetSentinel, op);
if (FLAG_opt_safe_uint32_operations &&
(elements_kind == EXTERNAL_UINT32_ELEMENTS ||
elements_kind == UINT32_ELEMENTS)) {
}
}
break;
+#define TYPED_ARRAY_SIMD_LOAD_OPERATION_CASE_ITEM(p1, p2, name) \
+ case k##name:
+TYPED_ARRAYS_SIMD_LOAD_OPERATIONS(TYPED_ARRAY_SIMD_LOAD_OPERATION_CASE_ITEM)
+#undef TYPED_ARRAY_SIMD_LOAD_OPERATION_CASE_ITEM
+ if (receiver_map.is_null()) return false;
+ if (CpuFeatures::SupportsSIMD128InCrankshaft() && argument_count == 2) {
+#if V8_TARGET_ARCH_X64
+ // TODO(nhu): support x64.
+ return false;
+#else
+ HValue* key = Pop();
+ HValue* tarray = Pop();
+ DCHECK(tarray == receiver);
+ Drop(1); // Drop function.
+ HInstruction* instr = BuildUncheckedMonomorphicElementAccess(
+ tarray, key, NULL,
+ receiver_map->instance_type() == JS_ARRAY_TYPE,
+ receiver_map->elements_kind(),
+ LOAD, // is_store.
+ NEVER_RETURN_HOLE, // load_mode.
+ STANDARD_STORE,
+ id);
+ ast_context()->ReturnValue(instr);
+ return true;
+#endif
+ }
+ break;
+#define TYPED_ARRAY_SIMD_STORE_OPERATION_CASE_ITEM(p1, p2, name) \
+ case k##name:
+TYPED_ARRAYS_SIMD_STORE_OPERATIONS(TYPED_ARRAY_SIMD_STORE_OPERATION_CASE_ITEM)
+#undef TYPED_ARRAY_SIMD_STORE_OPERATION_CASE_ITEM
+ if (receiver_map.is_null()) return false;
+ if (CpuFeatures::SupportsSIMD128InCrankshaft() && argument_count == 3) {
+#if V8_TARGET_ARCH_X64
+ // TODO(nhu): support x64.
+ return false;
+#else
+ HValue* value = Pop();
+ HValue* key = Pop();
+ HValue* tarray = Pop();
+ Drop(1); // Drop function.
+ DCHECK(tarray == receiver);
+ BuildUncheckedMonomorphicElementAccess(
+ tarray, key, value,
+ receiver_map->instance_type() == JS_ARRAY_TYPE,
+ receiver_map->elements_kind(),
+ STORE, // is_store.
+ NEVER_RETURN_HOLE, // load_mode.
+ STANDARD_STORE,
+ id);
+ Push(value);
+ Add<HSimulate>(expr->id(), REMOVABLE_SIMULATE);
+ ast_context()->ReturnValue(Pop());
+ return true;
+#endif
+ }
+ break;
case kFloat32x4ArrayGetAt:
case kFloat64x2ArrayGetAt:
case kInt32x4ArrayGetAt:
ElementsKind elements_kind,
PropertyAccessType access_type,
LoadKeyedHoleMode load_mode,
- KeyedAccessStoreMode store_mode);
+ KeyedAccessStoreMode store_mode,
+ BuiltinFunctionId id = kNumberOfBuiltinFunction);
HInstruction* AddElementAccess(
HValue* elements,
HValue* dependency,
ElementsKind elements_kind,
PropertyAccessType access_type,
- LoadKeyedHoleMode load_mode = NEVER_RETURN_HOLE);
+ LoadKeyedHoleMode load_mode = NEVER_RETURN_HOLE,
+ BuiltinFunctionId id = kNumberOfBuiltinFunction);
HInstruction* AddLoadStringInstanceType(HValue* string);
HInstruction* AddLoadStringLength(HValue* string);
}
+void Assembler::movlhps(XMMRegister dst, XMMRegister src) {
+ EnsureSpace ensure_space(this);
+ EMIT(0x0F);
+ EMIT(0x16);
+ emit_sse_operand(dst, src);
+}
+
+
+void Assembler::movhlps(XMMRegister dst, XMMRegister src) {
+ EnsureSpace ensure_space(this);
+ EMIT(0x0F);
+ EMIT(0x12);
+ emit_sse_operand(dst, src);
+}
+
+
void Assembler::movups(XMMRegister dst, const Operand& src) {
EnsureSpace ensure_space(this);
EMIT(0x0F);
}
+void Assembler::movq(const Operand& dst, XMMRegister src ) {
+ EnsureSpace ensure_space(this);
+ EMIT(0x66);
+ EMIT(0x0F);
+ EMIT(0xD6); // store
+ emit_sse_operand(src, dst);
+}
+
+
+void Assembler::movq(XMMRegister dst, const Operand& src) {
+ EnsureSpace ensure_space(this);
+ EMIT(0xF3);
+ EMIT(0x0F);
+ EMIT(0x7E); // load
+ emit_sse_operand(dst, src);
+}
+
+
void Assembler::movd(XMMRegister dst, const Operand& src) {
EnsureSpace ensure_space(this);
EMIT(0x66);
// SSE instructions
void movaps(XMMRegister dst, XMMRegister src);
+ void movlhps(XMMRegister dst, XMMRegister src);
+ void movhlps(XMMRegister dst, XMMRegister src);
void movups(XMMRegister dst, const Operand& src);
void movups(const Operand& dst, XMMRegister src);
void shufps(XMMRegister dst, XMMRegister src, byte imm8);
void movss(XMMRegister dst, const Operand& src);
void movss(const Operand& dst, XMMRegister src);
void movss(XMMRegister dst, XMMRegister src) { movss(dst, Operand(src)); }
+ void movq(XMMRegister dst, const Operand& src);
+ void movq(const Operand& dst, XMMRegister src);
void extractps(Register dst, XMMRegister src, byte imm8);
void pand(XMMRegister dst, XMMRegister src);
}
+void Deoptimizer::CopyDoubleRegisters(FrameDescription* output_frame) {
+}
+
+
void Deoptimizer::CopySIMD128Registers(FrameDescription* output_frame) {
for (int i = 0; i < XMMRegister::kMaxNumAllocatableRegisters; ++i) {
simd128_value_t xmm_value = input_->GetSIMD128Register(i);
}
+simd128_value_t FrameDescription::GetSIMD128Register(unsigned n) const {
+ DCHECK(n < arraysize(simd128_registers_));
+ return simd128_registers_[n];
+}
+
+
+void FrameDescription::SetSIMD128Register(unsigned n, simd128_value_t value) {
+ DCHECK(n < arraysize(simd128_registers_));
+ simd128_registers_[n] = value;
+}
+
+
+int FrameDescription::double_registers_offset() {
+ return OFFSET_OF(FrameDescription, simd128_registers_);
+}
+
+
+int FrameDescription::simd128_registers_offset() {
+ return OFFSET_OF(FrameDescription, simd128_registers_);
+}
+
+
#undef __
NameOfXMMRegister(regop),
NameOfXMMRegister(rm));
data++;
+ } else if (f0byte == 0x12) {
+ data += 2;
+ int mod, regop, rm;
+ get_modrm(*data, &mod, ®op, &rm);
+ AppendToBuffer("movhlps %s,%s",
+ NameOfXMMRegister(regop),
+ NameOfXMMRegister(rm));
+ data++;
+ } else if (f0byte == 0x16) {
+ data += 2;
+ int mod, regop, rm;
+ get_modrm(*data, &mod, ®op, &rm);
+ AppendToBuffer("movlhps %s,%s",
+ NameOfXMMRegister(regop),
+ NameOfXMMRegister(rm));
+ data++;
} else if (f0byte == 0x10) {
data += 2;
int mod, regop, rm;
AppendToBuffer("punpackldq %s,",
NameOfXMMRegister(regop));
data += PrintRightXMMOperand(data);
+ } else if (*data == 0xD6) {
+ AppendToBuffer("movq ");
+ data += 3;
+ int mod, regop, rm;
+ get_modrm(*data, &mod, ®op, &rm);
+ data += PrintRightXMMOperand(data);
+ AppendToBuffer(",%s", NameOfXMMRegister(regop));
} else if (*data == 0xF4) {
data++;
int mod, regop, rm;
get_modrm(*data, &mod, ®op, &rm);
data += PrintRightXMMOperand(data);
AppendToBuffer(",%s", NameOfXMMRegister(regop));
+ } else if (b2 == 0x7E) {
+ data += 3;
+ int mod, regop, rm;
+ get_modrm(*data, &mod, ®op, &rm);
+ AppendToBuffer("movq %s,", NameOfXMMRegister(regop));
+ data += PrintRightXMMOperand(data);
} else {
UnimplementedInstruction();
}
namespace v8 {
namespace internal {
+inline bool IsSIMD128LoadStoreOp(BuiltinFunctionId op) {
+ return (op == kFloat32ArrayGetFloat32x4XYZW ||
+ op == kFloat32ArrayGetFloat32x4X ||
+ op == kFloat32ArrayGetFloat32x4XY ||
+ op == kFloat32ArrayGetFloat32x4XYZ ||
+ op == kFloat64ArrayGetFloat64x2XY ||
+ op == kFloat64ArrayGetFloat64x2X ||
+ op == kInt32ArrayGetInt32x4XYZW ||
+ op == kInt32ArrayGetInt32x4X ||
+ op == kInt32ArrayGetInt32x4XY ||
+ op == kInt32ArrayGetInt32x4XYZ ||
+ op == kInt8ArrayGetFloat32x4XYZW ||
+ op == kInt8ArrayGetFloat32x4X ||
+ op == kInt8ArrayGetFloat32x4XY ||
+ op == kInt8ArrayGetFloat32x4XYZ ||
+ op == kInt8ArrayGetFloat64x2XY ||
+ op == kInt8ArrayGetFloat64x2X ||
+ op == kInt8ArrayGetInt32x4XYZW ||
+ op == kInt8ArrayGetInt32x4X ||
+ op == kInt8ArrayGetInt32x4XY ||
+ op == kInt8ArrayGetInt32x4XYZ ||
+ op == kFloat32ArraySetFloat32x4XYZW ||
+ op == kFloat32ArraySetFloat32x4X ||
+ op == kFloat32ArraySetFloat32x4XY ||
+ op == kFloat32ArraySetFloat32x4XYZ ||
+ op == kFloat64ArraySetFloat64x2XY ||
+ op == kFloat64ArraySetFloat64x2X ||
+ op == kInt32ArraySetInt32x4XYZW ||
+ op == kInt32ArraySetInt32x4X ||
+ op == kInt32ArraySetInt32x4XY ||
+ op == kInt32ArraySetInt32x4XYZ ||
+ op == kInt8ArraySetFloat32x4XYZW ||
+ op == kInt8ArraySetFloat32x4X ||
+ op == kInt8ArraySetFloat32x4XY ||
+ op == kInt8ArraySetFloat32x4XYZ ||
+ op == kInt8ArraySetFloat64x2XY ||
+ op == kInt8ArraySetFloat64x2X ||
+ op == kInt8ArraySetInt32x4XYZW ||
+ op == kInt8ArraySetInt32x4X ||
+ op == kInt8ArraySetInt32x4XY ||
+ op == kInt8ArraySetInt32x4XYZ);
+}
+
+
+int GetSIMD128LoadStoreBytes(BuiltinFunctionId op) {
+ if (op == kFloat32ArrayGetFloat32x4XYZW ||
+ op == kFloat64ArrayGetFloat64x2XY ||
+ op == kInt32ArrayGetInt32x4XYZW ||
+ op == kInt8ArrayGetFloat32x4XYZW ||
+ op == kInt8ArrayGetFloat64x2XY ||
+ op == kInt8ArrayGetInt32x4XYZW ||
+ op == kFloat32ArraySetFloat32x4XYZW ||
+ op == kFloat64ArraySetFloat64x2XY ||
+ op == kInt32ArraySetInt32x4XYZW ||
+ op == kInt8ArraySetFloat32x4XYZW ||
+ op == kInt8ArraySetFloat64x2XY ||
+ op == kInt8ArraySetInt32x4XYZW) {
+ return 16;
+ } else if (op == kFloat32ArrayGetFloat32x4X ||
+ op == kInt32ArrayGetInt32x4X ||
+ op == kInt8ArrayGetFloat32x4X ||
+ op == kInt8ArrayGetInt32x4X ||
+ op == kFloat32ArraySetFloat32x4X ||
+ op == kInt32ArraySetInt32x4X ||
+ op == kInt8ArraySetFloat32x4X ||
+ op == kInt8ArraySetInt32x4X) {
+ return 4;
+ } else if (op == kFloat32ArrayGetFloat32x4XY ||
+ op == kFloat64ArrayGetFloat64x2X ||
+ op == kInt32ArrayGetInt32x4XY ||
+ op == kInt8ArrayGetFloat32x4XY ||
+ op == kInt8ArrayGetFloat64x2X ||
+ op == kInt8ArrayGetInt32x4XY ||
+ op == kFloat32ArraySetFloat32x4XY ||
+ op == kFloat64ArraySetFloat64x2X ||
+ op == kInt32ArraySetInt32x4XY ||
+ op == kInt8ArraySetFloat32x4XY ||
+ op == kInt8ArraySetFloat64x2X ||
+ op == kInt8ArraySetInt32x4XY) {
+ return 8;
+ } else if (op == kFloat32ArrayGetFloat32x4XYZ ||
+ op == kInt32ArrayGetInt32x4XYZ ||
+ op == kInt8ArrayGetFloat32x4XYZ ||
+ op == kInt8ArrayGetInt32x4XYZ ||
+ op == kFloat32ArraySetFloat32x4XYZ ||
+ op == kInt32ArraySetInt32x4XYZ ||
+ op == kInt8ArraySetFloat32x4XYZ ||
+ op == kInt8ArraySetInt32x4XYZ) {
+ return 12;
+ } else {
+ UNREACHABLE();
+ return -1;
+ }
+}
+
+
// When invoking builtins, we need to record the safepoint in the middle of
// the invoke instruction sequence generated by the macro assembler.
class SafepointGenerator FINAL : public CallWrapper {
instr->hydrogen()->key()->representation(),
elements_kind,
instr->base_offset()));
- if (elements_kind == EXTERNAL_FLOAT32_ELEMENTS ||
+ BuiltinFunctionId op = instr->hydrogen()->op();
+ if (IsSIMD128LoadStoreOp(op)) {
+ if (GetSIMD128LoadStoreBytes(op) == 16) {
+ __ movups(ToSIMD128Register(instr->result()), operand);
+ } else if (GetSIMD128LoadStoreBytes(op) == 4) {
+ __ movss(ToSIMD128Register(instr->result()), operand);
+ } else if (GetSIMD128LoadStoreBytes(op) == 8) {
+ __ movq(ToSIMD128Register(instr->result()), operand);
+ } else if (GetSIMD128LoadStoreBytes(op) == 12) {
+ XMMRegister result(ToSIMD128Register(instr->result()));
+ XMMRegister xmm_scratch = double_scratch0();
+ __ movq(result, operand);
+ Operand operand2(BuildFastArrayOperand(
+ instr->elements(),
+ key,
+ instr->hydrogen()->key()->representation(),
+ elements_kind,
+ instr->base_offset() + 8));
+ __ movss(xmm_scratch, operand2);
+ __ movlhps(result, xmm_scratch);
+ }
+ } else if (elements_kind == EXTERNAL_FLOAT32_ELEMENTS ||
elements_kind == FLOAT32_ELEMENTS) {
XMMRegister result(ToDoubleRegister(instr->result()));
__ movss(result, operand);
void LCodeGen::DoBoundsCheck(LBoundsCheck* instr) {
Condition cc = instr->hydrogen()->allow_equality() ? above : above_equal;
- if (instr->index()->IsConstantOperand()) {
- __ cmp(ToOperand(instr->length()),
- ToImmediate(LConstantOperand::cast(instr->index()),
- instr->hydrogen()->length()->representation()));
- cc = CommuteCondition(cc);
- } else if (instr->length()->IsConstantOperand()) {
- __ cmp(ToOperand(instr->index()),
- ToImmediate(LConstantOperand::cast(instr->length()),
- instr->hydrogen()->index()->representation()));
+ BuiltinFunctionId op = instr->hydrogen()->op();
+ if (IsSIMD128LoadStoreOp(op)) {
+ cc = above;
+ Register index_in_bytes = ToRegister(instr->temp0());
+ Register length_in_bytes = ToRegister(instr->temp1());
+ if (instr->index()->IsConstantOperand())
+ __ mov(index_in_bytes, ToImmediate(LConstantOperand::cast(instr->index()),
+ instr->hydrogen()->index()->representation()));
+ else
+ __ mov(index_in_bytes, ToOperand(instr->index()));
+ int index_shift_size =
+ ElementsKindToShiftSize(instr->hydrogen()->element_kind());
+ DCHECK(index_shift_size >= 0);
+ if (index_shift_size > 0)
+ __ shl(index_in_bytes, index_shift_size);
+ int bytes = GetSIMD128LoadStoreBytes(op);
+ __ add(index_in_bytes, Immediate(bytes));
+ if (instr->length()->IsConstantOperand())
+ __ mov(length_in_bytes,
+ ToImmediate(LConstantOperand::cast(instr->length()),
+ instr->hydrogen()->length()->representation()));
+ else
+ __ mov(length_in_bytes, ToOperand(instr->length()));
+ int length_shift_size =
+ ElementsKindToShiftSize(instr->hydrogen()->element_kind());
+ DCHECK(length_shift_size >= 0);
+ if (length_shift_size > 0)
+ __ shl(length_in_bytes, length_shift_size);
+ __ cmp(index_in_bytes, length_in_bytes);
} else {
- __ cmp(ToRegister(instr->index()), ToOperand(instr->length()));
+ if (instr->index()->IsConstantOperand()) {
+ __ cmp(ToOperand(instr->length()),
+ ToImmediate(LConstantOperand::cast(instr->index()),
+ instr->hydrogen()->length()->representation()));
+ cc = CommuteCondition(cc);
+ } else if (instr->length()->IsConstantOperand()) {
+ __ cmp(ToOperand(instr->index()),
+ ToImmediate(LConstantOperand::cast(instr->length()),
+ instr->hydrogen()->index()->representation()));
+ } else {
+ __ cmp(ToRegister(instr->index()), ToOperand(instr->length()));
+ }
}
if (FLAG_debug_code && instr->hydrogen()->skip_check()) {
Label done;
instr->hydrogen()->key()->representation(),
elements_kind,
instr->base_offset()));
- if (elements_kind == EXTERNAL_FLOAT32_ELEMENTS ||
+ BuiltinFunctionId op = instr->hydrogen()->op();
+ if (IsSIMD128LoadStoreOp(op)) {
+ if (GetSIMD128LoadStoreBytes(op) == 16) {
+ __ movups(operand, ToSIMD128Register(instr->value()));
+ } else if (GetSIMD128LoadStoreBytes(op) == 4) {
+ __ movss(operand, ToSIMD128Register(instr->value()));
+ } else if (GetSIMD128LoadStoreBytes(op) == 8) {
+ __ movq(operand, ToSIMD128Register(instr->value()));
+ } else if (GetSIMD128LoadStoreBytes(op) == 12) {
+ XMMRegister value(ToSIMD128Register(instr->value()));
+ XMMRegister xmm_scratch = double_scratch0();
+ __ movq(operand, value);
+ Operand operand2(BuildFastArrayOperand(
+ instr->elements(),
+ key,
+ instr->hydrogen()->key()->representation(),
+ elements_kind,
+ instr->base_offset() + 8));
+ __ movhlps(xmm_scratch, value);
+ __ movss(operand2, xmm_scratch);
+ }
+ } else if (elements_kind == EXTERNAL_FLOAT32_ELEMENTS ||
elements_kind == FLOAT32_ELEMENTS) {
XMMRegister xmm_scratch = double_scratch0();
__ cvtsd2ss(xmm_scratch, ToDoubleRegister(instr->value()));
LOperand* length = !index->IsConstantOperand()
? UseOrConstantAtStart(instr->length())
: UseAtStart(instr->length());
- LInstruction* result = new(zone()) LBoundsCheck(index, length);
+ LOperand* temp0 = TempRegister();
+ LOperand* temp1 = TempRegister();
+ LInstruction* result = new(zone()) LBoundsCheck(index, length, temp0, temp1);
if (!FLAG_debug_code || !instr->skip_check()) {
result = AssignEnvironment(result);
}
LOperand* LChunkBuilder::GetStoreKeyedValueOperand(HStoreKeyed* instr) {
ElementsKind elements_kind = instr->elements_kind();
+ BuiltinFunctionId op = instr->op();
// Determine if we need a byte register in this case for the value.
bool val_is_fixed_register =
- elements_kind == EXTERNAL_INT8_ELEMENTS ||
+ (elements_kind == EXTERNAL_INT8_ELEMENTS ||
elements_kind == EXTERNAL_UINT8_ELEMENTS ||
elements_kind == EXTERNAL_UINT8_CLAMPED_ELEMENTS ||
elements_kind == UINT8_ELEMENTS ||
elements_kind == INT8_ELEMENTS ||
- elements_kind == UINT8_CLAMPED_ELEMENTS;
+ elements_kind == UINT8_CLAMPED_ELEMENTS) &&
+ (op != kInt8ArraySetFloat32x4XYZW &&
+ op != kInt8ArraySetFloat32x4X &&
+ op != kInt8ArraySetFloat32x4XY &&
+ op != kInt8ArraySetFloat32x4XYZ &&
+ op != kInt8ArraySetInt32x4XYZW &&
+ op != kInt8ArraySetInt32x4X &&
+ op != kInt8ArraySetInt32x4XY &&
+ op != kInt8ArraySetInt32x4XYZ &&
+ op != kInt8ArraySetFloat64x2XY &&
+ op != kInt8ArraySetFloat64x2X);
if (val_is_fixed_register) {
return UseFixed(instr->value(), eax);
}
};
-class LBoundsCheck FINAL : public LTemplateInstruction<0, 2, 0> {
+class LBoundsCheck FINAL : public LTemplateInstruction<0, 2, 2> {
public:
- LBoundsCheck(LOperand* index, LOperand* length) {
+ LBoundsCheck(LOperand* index, LOperand* length,
+ LOperand* temp0, LOperand* temp1) {
inputs_[0] = index;
inputs_[1] = length;
+ temps_[0] = temp0;
+ temps_[1] = temp1;
}
LOperand* index() { return inputs_[0]; }
LOperand* length() { return inputs_[1]; }
+ LOperand* temp0() { return temps_[0]; }
+ LOperand* temp1() { return temps_[1]; }
DECLARE_CONCRETE_INSTRUCTION(BoundsCheck, "bounds-check")
DECLARE_HYDROGEN_ACCESSOR(BoundsCheck)
bool CpuFeatures::SupportsCrankshaft() { return IsSupported(FPU); }
+bool CpuFeatures::SupportsSIMD128InCrankshaft() { return false; }
// -----------------------------------------------------------------------------
const FPUControlRegister no_fpucreg = { kInvalidFPUControlRegister };
const FPUControlRegister FCSR = { kFCSRRegister };
-
// -----------------------------------------------------------------------------
// Machine instruction Operands.
}
+void Deoptimizer::CopySIMD128Registers(FrameDescription* output_frame) {
+}
+
+
bool Deoptimizer::HasAlignmentPadding(JSFunction* function) {
// There is no dynamic alignment padding on MIPS in the input frame.
return false;
}
+double FrameDescription::GetDoubleRegister(unsigned n) const {
+ DCHECK(n < arraysize(double_registers_));
+ return double_registers_[n];
+}
+
+
+void FrameDescription::SetDoubleRegister(unsigned n, double value) {
+ DCHECK(n < arraysize(double_registers_));
+ double_registers_[n] = value;
+}
+
+
+simd128_value_t FrameDescription::GetSIMD128Register(unsigned n) const {
+ UNREACHABLE();
+ simd128_value_t value;
+ return value;
+}
+
+
+void FrameDescription::SetSIMD128Register(unsigned n, simd128_value_t value) {
+ UNREACHABLE();
+}
+
+
+int FrameDescription::double_registers_offset() {
+ return OFFSET_OF(FrameDescription, double_registers_);
+}
+
+
+int FrameDescription::simd128_registers_offset() {
+ UNREACHABLE();
+ return -1;
+}
+
+
#undef __
DeoptimizeIf(Ugreater_equal, instr, result, Operand(0x80000000));
}
break;
+ case INT32x4_ELEMENTS:
case FLOAT32_ELEMENTS:
+ case FLOAT32x4_ELEMENTS:
case FLOAT64_ELEMENTS:
+ case FLOAT64x2_ELEMENTS:
+ case EXTERNAL_INT32x4_ELEMENTS:
case EXTERNAL_FLOAT32_ELEMENTS:
+ case EXTERNAL_FLOAT32x4_ELEMENTS:
case EXTERNAL_FLOAT64_ELEMENTS:
+ case EXTERNAL_FLOAT64x2_ELEMENTS:
case FAST_DOUBLE_ELEMENTS:
case FAST_ELEMENTS:
case FAST_SMI_ELEMENTS:
case UINT32_ELEMENTS:
__ sw(value, mem_operand);
break;
+ case INT32x4_ELEMENTS:
case FLOAT32_ELEMENTS:
+ case FLOAT32x4_ELEMENTS:
case FLOAT64_ELEMENTS:
+ case FLOAT64x2_ELEMENTS:
+ case EXTERNAL_INT32x4_ELEMENTS:
case EXTERNAL_FLOAT32_ELEMENTS:
+ case EXTERNAL_FLOAT32x4_ELEMENTS:
case EXTERNAL_FLOAT64_ELEMENTS:
+ case EXTERNAL_FLOAT64x2_ELEMENTS:
case FAST_DOUBLE_ELEMENTS:
case FAST_ELEMENTS:
case FAST_SMI_ELEMENTS:
}
+LInstruction* LChunkBuilder::DoNullarySIMDOperation(
+ HNullarySIMDOperation* instr) {
+ UNIMPLEMENTED();
+ return NULL;
+}
+
+
+LInstruction* LChunkBuilder::DoUnarySIMDOperation(
+ HUnarySIMDOperation* instr) {
+ UNIMPLEMENTED();
+ return NULL;
+}
+
+
+LInstruction* LChunkBuilder::DoBinarySIMDOperation(
+ HBinarySIMDOperation* instr) {
+ UNIMPLEMENTED();
+ return NULL;
+}
+
+
+LInstruction* LChunkBuilder::DoTernarySIMDOperation(
+ HTernarySIMDOperation* instr) {
+ UNIMPLEMENTED();
+ return NULL;
+}
+
+
+LInstruction* LChunkBuilder::DoQuarternarySIMDOperation(
+ HQuarternarySIMDOperation* instr) {
+ UNIMPLEMENTED();
+ return NULL;
+}
+
+
LInstruction* LChunkBuilder::DoCallNew(HCallNew* instr) {
LOperand* context = UseFixed(instr->context(), cp);
LOperand* constructor = UseFixed(instr->constructor(), a1);
inline bool is_prototype_map();
inline void set_elements_kind(ElementsKind elements_kind) {
- DCHECK(elements_kind < kElementsKindCount);
+ DCHECK(static_cast<int>(elements_kind) < kElementsKindCount);
DCHECK(kElementsKindCount <= (1 << Map::ElementsKindBits::kSize));
set_bit_field2(Map::ElementsKindBits::update(bit_field2(), elements_kind));
DCHECK(this->elements_kind() == elements_kind);
V(Int32x4Array.prototype, getAt, Int32x4ArrayGetAt) \
V(Int32x4Array.prototype, setAt, Int32x4ArraySetAt)
+#define TYPED_ARRAYS_SIMD_LOAD_OPERATIONS(V) \
+ V(Float32Array.prototype, _getFloat32x4XYZW, Float32ArrayGetFloat32x4XYZW) \
+ V(Float32Array.prototype, _getFloat32x4XYZ, Float32ArrayGetFloat32x4XYZ) \
+ V(Float32Array.prototype, _getFloat32x4XY, Float32ArrayGetFloat32x4XY) \
+ V(Float32Array.prototype, _getFloat32x4X, Float32ArrayGetFloat32x4X) \
+ V(Float64Array.prototype, _getFloat64x2XY, Float64ArrayGetFloat64x2XY) \
+ V(Float64Array.prototype, _getFloat64x2X, Float64ArrayGetFloat64x2X) \
+ V(Int32Array.prototype, _getInt32x4XYZW, Int32ArrayGetInt32x4XYZW) \
+ V(Int32Array.prototype, _getInt32x4XYZ, Int32ArrayGetInt32x4XYZ) \
+ V(Int32Array.prototype, _getInt32x4XY, Int32ArrayGetInt32x4XY) \
+ V(Int32Array.prototype, _getInt32x4X, Int32ArrayGetInt32x4X) \
+ V(Int8Array.prototype, _getFloat32x4XYZW, Int8ArrayGetFloat32x4XYZW) \
+ V(Int8Array.prototype, _getFloat32x4XYZ, Int8ArrayGetFloat32x4XYZ) \
+ V(Int8Array.prototype, _getFloat32x4XY, Int8ArrayGetFloat32x4XY) \
+ V(Int8Array.prototype, _getFloat32x4X, Int8ArrayGetFloat32x4X) \
+ V(Int8Array.prototype, _getFloat64x2XY, Int8ArrayGetFloat64x2XY) \
+ V(Int8Array.prototype, _getFloat64x2X, Int8ArrayGetFloat64x2X) \
+ V(Int8Array.prototype, _getInt32x4XYZW, Int8ArrayGetInt32x4XYZW) \
+ V(Int8Array.prototype, _getInt32x4XYZ, Int8ArrayGetInt32x4XYZ) \
+ V(Int8Array.prototype, _getInt32x4XY, Int8ArrayGetInt32x4XY) \
+ V(Int8Array.prototype, _getInt32x4X, Int8ArrayGetInt32x4X)
+
+#define TYPED_ARRAYS_SIMD_STORE_OPERATIONS(V) \
+ V(Float32Array.prototype, _setFloat32x4XYZW, Float32ArraySetFloat32x4XYZW) \
+ V(Float32Array.prototype, _setFloat32x4XYZ, Float32ArraySetFloat32x4XYZ) \
+ V(Float32Array.prototype, _setFloat32x4XY, Float32ArraySetFloat32x4XY) \
+ V(Float32Array.prototype, _setFloat32x4X, Float32ArraySetFloat32x4X) \
+ V(Float64Array.prototype, _setFloat64x2XY, Float64ArraySetFloat64x2XY) \
+ V(Float64Array.prototype, _setFloat64x2X, Float64ArraySetFloat64x2X) \
+ V(Int32Array.prototype, _setInt32x4XYZW, Int32ArraySetInt32x4XYZW) \
+ V(Int32Array.prototype, _setInt32x4XYZ, Int32ArraySetInt32x4XYZ) \
+ V(Int32Array.prototype, _setInt32x4XY, Int32ArraySetInt32x4XY) \
+ V(Int32Array.prototype, _setInt32x4X, Int32ArraySetInt32x4X) \
+ V(Int8Array.prototype, _setFloat32x4XYZW, Int8ArraySetFloat32x4XYZW) \
+ V(Int8Array.prototype, _setFloat32x4XYZ, Int8ArraySetFloat32x4XYZ) \
+ V(Int8Array.prototype, _setFloat32x4XY, Int8ArraySetFloat32x4XY) \
+ V(Int8Array.prototype, _setFloat32x4X, Int8ArraySetFloat32x4X) \
+ V(Int8Array.prototype, _setFloat64x2XY, Int8ArraySetFloat64x2XY) \
+ V(Int8Array.prototype, _setFloat64x2X, Int8ArraySetFloat64x2X) \
+ V(Int8Array.prototype, _setInt32x4XYZW, Int8ArraySetInt32x4XYZW) \
+ V(Int8Array.prototype, _setInt32x4XYZ, Int8ArraySetInt32x4XYZ) \
+ V(Int8Array.prototype, _setInt32x4XY, Int8ArraySetInt32x4XY) \
+ V(Int8Array.prototype, _setInt32x4X, Int8ArraySetInt32x4X)
+
// Do not need to install them in InstallExperimentalSIMDBuiltinFunctionIds.
#define SIMD_FAKE_ID_LISTS(V) \
V(SIMD, unreachable, SIMD128Unreachable) \
kMathPowHalf,
SIMD_FAKE_ID_LISTS(DECLARE_FUNCTION_ID)
SIMD_ARRAY_OPERATIONS(DECLARE_FUNCTION_ID)
+ TYPED_ARRAYS_SIMD_LOAD_OPERATIONS(DECLARE_FUNCTION_ID)
+ TYPED_ARRAYS_SIMD_STORE_OPERATIONS(DECLARE_FUNCTION_ID)
#undef DECLARE_FUNCTION_ID
#define DECLARE_SIMD_NULLARY_FUNCTION_ID(i1, i2, name, i3) \
k##name,
}
+bool ParserTraits::BuildSIMD128LoadStoreExpression(
+ Expression** expression, ZoneList<Expression*>* arguments, int pos,
+ AstNodeFactory<AstConstructionVisitor>* factory) {
+ Property* prop = (*expression)->AsProperty();
+ Expression* tarray_op_literal = NULL;
+
+ if (prop) {
+ Property* simd_type_prop = prop->obj()->AsProperty();
+ if (simd_type_prop) {
+ VariableProxy* simd_var = simd_type_prop->obj()->AsVariableProxy();
+ if (simd_var && simd_var->raw_name() &&
+ simd_var->raw_name()->IsOneByteEqualTo("SIMD")) {
+ Literal* type_literal = simd_type_prop->key()->AsLiteral();
+ if (type_literal && type_literal->raw_value() &&
+ type_literal->raw_value()->AsString()) {
+ const AstRawString* type_literal_raw_string =
+ type_literal->raw_value()->AsString();
+ if (type_literal_raw_string->IsOneByteEqualTo("float32x4")) {
+ Literal* op_literal = prop->key()->AsLiteral();
+ if (op_literal && op_literal->raw_value() &&
+ op_literal->raw_value()->AsString()) {
+ const AstRawString* op_raw_string =
+ op_literal->raw_value()->AsString();
+ AstValueFactory* ast_factory = parser_->ast_value_factory();
+ if (op_raw_string->IsOneByteEqualTo("load")) {
+ const AstRawString* op_str =
+ ast_factory->GetOneByteString("_getFloat32x4XYZW");
+ tarray_op_literal =
+ factory->NewStringLiteral(op_str, RelocInfo::kNoPosition);
+ } else if (op_raw_string->IsOneByteEqualTo("loadX")) {
+ const AstRawString* op_str =
+ ast_factory->GetOneByteString("_getFloat32x4X");
+ tarray_op_literal =
+ factory->NewStringLiteral(op_str, RelocInfo::kNoPosition);
+ } else if (op_raw_string->IsOneByteEqualTo("loadXY")) {
+ const AstRawString* op_str =
+ ast_factory->GetOneByteString("_getFloat32x4XY");
+ tarray_op_literal =
+ factory->NewStringLiteral(op_str, RelocInfo::kNoPosition);
+ } else if (op_raw_string->IsOneByteEqualTo("loadXYZ")) {
+ const AstRawString* op_str =
+ ast_factory->GetOneByteString("_getFloat32x4XYZ");
+ tarray_op_literal =
+ factory->NewStringLiteral(op_str, RelocInfo::kNoPosition);
+ } else if (op_raw_string->IsOneByteEqualTo("store")) {
+ const AstRawString* op_str =
+ ast_factory->GetOneByteString("_setFloat32x4XYZW");
+ tarray_op_literal =
+ factory->NewStringLiteral(op_str, RelocInfo::kNoPosition);
+ } else if (op_raw_string->IsOneByteEqualTo("storeX")) {
+ const AstRawString* op_str =
+ ast_factory->GetOneByteString("_setFloat32x4X");
+ tarray_op_literal =
+ factory->NewStringLiteral(op_str, RelocInfo::kNoPosition);
+ } else if (op_raw_string->IsOneByteEqualTo("storeXY")) {
+ const AstRawString* op_str =
+ ast_factory->GetOneByteString("_setFloat32x4XY");
+ tarray_op_literal =
+ factory->NewStringLiteral(op_str, RelocInfo::kNoPosition);
+ } else if (op_raw_string->IsOneByteEqualTo("storeXYZ")) {
+ const AstRawString* op_str =
+ ast_factory->GetOneByteString("_setFloat32x4XYZ");
+ tarray_op_literal =
+ factory->NewStringLiteral(op_str, RelocInfo::kNoPosition);
+ }
+ }
+ } else if (type_literal_raw_string->IsOneByteEqualTo("int32x4")) {
+ Literal* op_literal = prop->key()->AsLiteral();
+ if (op_literal && op_literal->raw_value() &&
+ op_literal->raw_value()->AsString()) {
+ const AstRawString* op_raw_string =
+ op_literal->raw_value()->AsString();
+ AstValueFactory* ast_factory = parser_->ast_value_factory();
+ if (op_raw_string->IsOneByteEqualTo("load")) {
+ const AstRawString* op_str =
+ ast_factory->GetOneByteString("_getInt32x4XYZW");
+ tarray_op_literal =
+ factory->NewStringLiteral(op_str, RelocInfo::kNoPosition);
+ } else if (op_raw_string->IsOneByteEqualTo("loadX")) {
+ const AstRawString* op_str =
+ ast_factory->GetOneByteString("_getInt32x4X");
+ tarray_op_literal =
+ factory->NewStringLiteral(op_str, RelocInfo::kNoPosition);
+ } else if (op_raw_string->IsOneByteEqualTo("loadXY")) {
+ const AstRawString* op_str =
+ ast_factory->GetOneByteString("_getInt32x4XY");
+ tarray_op_literal =
+ factory->NewStringLiteral(op_str, RelocInfo::kNoPosition);
+ } else if (op_raw_string->IsOneByteEqualTo("loadXYZ")) {
+ const AstRawString* op_str =
+ ast_factory->GetOneByteString("_getInt32x4XYZ");
+ tarray_op_literal =
+ factory->NewStringLiteral(op_str, RelocInfo::kNoPosition);
+ } else if (op_raw_string->IsOneByteEqualTo("store")) {
+ const AstRawString* op_str =
+ ast_factory->GetOneByteString("_setInt32x4XYZW");
+ tarray_op_literal =
+ factory->NewStringLiteral(op_str, RelocInfo::kNoPosition);
+ } else if (op_raw_string->IsOneByteEqualTo("storeX")) {
+ const AstRawString* op_str =
+ ast_factory->GetOneByteString("_setInt32x4X");
+ tarray_op_literal =
+ factory->NewStringLiteral(op_str, RelocInfo::kNoPosition);
+ } else if (op_raw_string->IsOneByteEqualTo("storeXY")) {
+ const AstRawString* op_str =
+ ast_factory->GetOneByteString("_setInt32x4XY");
+ tarray_op_literal =
+ factory->NewStringLiteral(op_str, RelocInfo::kNoPosition);
+ } else if (op_raw_string->IsOneByteEqualTo("storeXYZ")) {
+ const AstRawString* op_str =
+ ast_factory->GetOneByteString("_setInt32x4XYZ");
+ tarray_op_literal =
+ factory->NewStringLiteral(op_str, RelocInfo::kNoPosition);
+ }
+ }
+ } else if (type_literal_raw_string->IsOneByteEqualTo("float64x2")) {
+ Literal* op_literal = prop->key()->AsLiteral();
+ if (op_literal && op_literal->raw_value() &&
+ op_literal->raw_value()->AsString()) {
+ const AstRawString* op_raw_string =
+ op_literal->raw_value()->AsString();
+ AstValueFactory* ast_factory = parser_->ast_value_factory();
+ if (op_raw_string->IsOneByteEqualTo("load")) {
+ const AstRawString* op_str =
+ ast_factory->GetOneByteString("_getFloat64x2XY");
+ tarray_op_literal =
+ factory->NewStringLiteral(op_str, RelocInfo::kNoPosition);
+ } else if (op_raw_string->IsOneByteEqualTo("loadX")) {
+ const AstRawString* op_str =
+ ast_factory->GetOneByteString("_getFloat64x2X");
+ tarray_op_literal =
+ factory->NewStringLiteral(op_str, RelocInfo::kNoPosition);
+ } else if (op_raw_string->IsOneByteEqualTo("store")) {
+ const AstRawString* op_str =
+ ast_factory->GetOneByteString("_setFloat64x2XY");
+ tarray_op_literal =
+ factory->NewStringLiteral(op_str, RelocInfo::kNoPosition);
+ } else if (op_raw_string->IsOneByteEqualTo("storeX")) {
+ const AstRawString* op_str =
+ ast_factory->GetOneByteString("_setFloat64x2X");
+ tarray_op_literal =
+ factory->NewStringLiteral(op_str, RelocInfo::kNoPosition);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if (tarray_op_literal) {
+ if (arguments && arguments->length() == 2) {
+ Expression* tarray = arguments->at(0);
+ Expression* index = arguments->at(1);
+ Expression* tarray_op =
+ factory->NewProperty(tarray, tarray_op_literal, pos);
+ Zone* zone = parser_->zone();
+ ZoneList<Expression*>* tarray_op_args =
+ new (zone) ZoneList<Expression*>(1, zone);
+ tarray_op_args->Add(index, zone);
+ *expression = factory->NewCall(tarray_op, tarray_op_args, pos);
+ return true;
+ } else if (arguments && arguments->length() == 3) {
+ Expression* tarray = arguments->at(0);
+ Expression* index = arguments->at(1);
+ Expression* value = arguments->at(2);
+ Expression* tarray_op =
+ factory->NewProperty(tarray, tarray_op_literal, pos);
+ Zone* zone = parser_->zone();
+ ZoneList<Expression*>* tarray_op_args =
+ new (zone) ZoneList<Expression*>(1, zone);
+ tarray_op_args->Add(index, zone);
+ tarray_op_args->Add(value, zone);
+ *expression = factory->NewCall(tarray_op, tarray_op_args, pos);
+ return true;
+ }
+ }
+ return false;
+}
+
+
Expression* ParserTraits::BuildUnaryExpression(
Expression* expression, Token::Value op, int pos,
AstNodeFactory<AstConstructionVisitor>* factory) {
Expression** x, Expression* y, Token::Value op, int pos,
AstNodeFactory<AstConstructionVisitor>* factory);
+ // If we find a SIMD load or store call with array types
+ // and offset as arguments, we will return an expression
+ // calling array types load or store with offset as argument.
+ // Otherwise, returns NULL.
+ bool BuildSIMD128LoadStoreExpression(
+ Expression** expression, ZoneList<Expression*>* arguments, int pos,
+ AstNodeFactory<AstConstructionVisitor>* factory);
+
// Rewrites the following types of unary expressions:
// not <literal> -> true / false
// + <numeric literal> -> <numeric literal>
return false;
}
+ bool BuildSIMD128LoadStoreExpression(
+ PreParserExpression* expression,
+ PreParserExpressionList arguments,
+ int pos,
+ PreParserFactory* factory) {
+ return false;
+ }
+
PreParserExpression BuildUnaryExpression(PreParserExpression expression,
Token::Value op, int pos,
PreParserFactory* factory) {
}
typename Traits::Type::ExpressionList args = ParseArguments(CHECK_OK);
+ if (this->BuildSIMD128LoadStoreExpression(
+ &result, args, pos, factory()))
+ break;
+
// Keep track of eval() calls since they disable all local variable
// optimizations.
// The calls that need special treatment are the
}
+template<typename T, int Bytes>
+inline static bool SimdTypeLoadValue(
+ Isolate* isolate,
+ Handle<JSArrayBuffer> buffer,
+ Handle<Object> byte_offset_obj,
+ T* result) {
+ size_t byte_offset = 0;
+ if (!TryNumberToSize(isolate, *byte_offset_obj, &byte_offset)) {
+ return false;
+ }
+
+ size_t buffer_byte_length =
+ NumberToSize(isolate, buffer->byte_length());
+ if (byte_offset + Bytes > buffer_byte_length) { // overflow
+ return false;
+ }
+
+ union Value {
+ T data;
+ uint8_t bytes[sizeof(T)];
+ };
+
+ Value value;
+ memset(value.bytes, 0, sizeof(T));
+ uint8_t* source =
+ static_cast<uint8_t*>(buffer->backing_store()) + byte_offset;
+ DCHECK(Bytes <= sizeof(T));
+ CopyBytes<Bytes>(value.bytes, source);
+ *result = value.data;
+ return true;
+}
+
+
+template<typename T, int Bytes>
+static bool SimdTypeStoreValue(
+ Isolate* isolate,
+ Handle<JSArrayBuffer> buffer,
+ Handle<Object> byte_offset_obj,
+ T data) {
+ size_t byte_offset = 0;
+ if (!TryNumberToSize(isolate, *byte_offset_obj, &byte_offset)) {
+ return false;
+ }
+
+ size_t buffer_byte_length =
+ NumberToSize(isolate, buffer->byte_length());
+ if (byte_offset + Bytes > buffer_byte_length) { // overflow
+ return false;
+ }
+
+ union Value {
+ T data;
+ uint8_t bytes[sizeof(T)];
+ };
+
+ Value value;
+ value.data = data;
+
+ uint8_t* target =
+ static_cast<uint8_t*>(buffer->backing_store()) + byte_offset;
+ DCHECK(Bytes <= sizeof(T));
+ CopyBytes<Bytes>(target, value.bytes);
+ return true;
+}
+
+
+#define SIMD128_LOAD_RUNTIME_FUNCTION(Type, ValueType, Lanes, Bytes) \
+RUNTIME_FUNCTION(Runtime_##Type##Load##Lanes) { \
+ HandleScope scope(isolate); \
+ DCHECK(args.length() == 2); \
+ CONVERT_ARG_HANDLE_CHECKED(JSArrayBuffer, buffer, 0); \
+ CONVERT_NUMBER_ARG_HANDLE_CHECKED(offset, 1); \
+ ValueType result; \
+ if (SimdTypeLoadValue<ValueType, Bytes>( \
+ isolate, buffer, offset, &result)) { \
+ return *isolate->factory()->New##Type(result); \
+ } else { \
+ THROW_NEW_ERROR_RETURN_FAILURE( \
+ isolate, NewRangeError("invalid_offset", \
+ HandleVector<Object>(NULL, 0))); \
+ } \
+}
+
+
+SIMD128_LOAD_RUNTIME_FUNCTION(Float32x4, float32x4_value_t, XYZW, 16)
+SIMD128_LOAD_RUNTIME_FUNCTION(Float32x4, float32x4_value_t, XYZ, 12)
+SIMD128_LOAD_RUNTIME_FUNCTION(Float32x4, float32x4_value_t, XY, 8)
+SIMD128_LOAD_RUNTIME_FUNCTION(Float32x4, float32x4_value_t, X, 4)
+SIMD128_LOAD_RUNTIME_FUNCTION(Float64x2, float64x2_value_t, XY, 16)
+SIMD128_LOAD_RUNTIME_FUNCTION(Float64x2, float64x2_value_t, X, 8)
+SIMD128_LOAD_RUNTIME_FUNCTION(Int32x4, int32x4_value_t, XYZW, 16)
+SIMD128_LOAD_RUNTIME_FUNCTION(Int32x4, int32x4_value_t, XYZ, 12)
+SIMD128_LOAD_RUNTIME_FUNCTION(Int32x4, int32x4_value_t, XY, 8)
+SIMD128_LOAD_RUNTIME_FUNCTION(Int32x4, int32x4_value_t, X, 4)
+
+
+#define SIMD128_STORE_RUNTIME_FUNCTION(Type, ValueType, Lanes, Bytes) \
+RUNTIME_FUNCTION(Runtime_##Type##Store##Lanes) { \
+ HandleScope scope(isolate); \
+ DCHECK(args.length() == 3); \
+ CONVERT_ARG_HANDLE_CHECKED(JSArrayBuffer, buffer, 0); \
+ CONVERT_NUMBER_ARG_HANDLE_CHECKED(offset, 1); \
+ CONVERT_ARG_CHECKED(Type, value, 2); \
+ ValueType v = value->get(); \
+ if (SimdTypeStoreValue<ValueType, Bytes>(isolate, buffer, offset, v)) { \
+ return isolate->heap()->undefined_value(); \
+ } else { \
+ THROW_NEW_ERROR_RETURN_FAILURE( \
+ isolate, NewRangeError("invalid_offset", \
+ HandleVector<Object>(NULL, 0))); \
+ } \
+}
+
+
+SIMD128_STORE_RUNTIME_FUNCTION(Float32x4, float32x4_value_t, XYZW, 16)
+SIMD128_STORE_RUNTIME_FUNCTION(Float32x4, float32x4_value_t, XYZ, 12)
+SIMD128_STORE_RUNTIME_FUNCTION(Float32x4, float32x4_value_t, XY, 8)
+SIMD128_STORE_RUNTIME_FUNCTION(Float32x4, float32x4_value_t, X, 4)
+SIMD128_STORE_RUNTIME_FUNCTION(Float64x2, float64x2_value_t, XY, 16)
+SIMD128_STORE_RUNTIME_FUNCTION(Float64x2, float64x2_value_t, X, 8)
+SIMD128_STORE_RUNTIME_FUNCTION(Int32x4, int32x4_value_t, XYZW, 16)
+SIMD128_STORE_RUNTIME_FUNCTION(Int32x4, int32x4_value_t, XYZ, 12)
+SIMD128_STORE_RUNTIME_FUNCTION(Int32x4, int32x4_value_t, XY, 8)
+SIMD128_STORE_RUNTIME_FUNCTION(Int32x4, int32x4_value_t, X, 4)
+
+
#define RETURN_Float32x4_RESULT(value) \
return *isolate->factory()->NewFloat32x4(value);
F(AllocateInt32x4, 0, 1) \
\
/* SIMD */ \
+ F(Float32x4LoadX, 2, 1) \
+ F(Float32x4LoadXY, 2, 1) \
+ F(Float32x4LoadXYZ, 2, 1) \
+ F(Float32x4LoadXYZW, 2, 1) \
+ F(Float32x4StoreX, 3, 1) \
+ F(Float32x4StoreXY, 3, 1) \
+ F(Float32x4StoreXYZ, 3, 1) \
+ F(Float32x4StoreXYZW, 3, 1) \
F(Float32x4Abs, 1, 1) \
F(Float32x4BitsToInt32x4, 1, 1) \
F(Float32x4Neg, 1, 1) \
F(Float32x4Clamp, 3, 1) \
F(Float32x4ShuffleMix, 3, 1) \
F(Float32x4Select, 3, 1) \
+ F(Float64x2LoadX, 2, 1) \
+ F(Float64x2LoadXY, 2, 1) \
+ F(Float64x2StoreX, 3, 1) \
+ F(Float64x2StoreXY, 3, 1) \
F(Float64x2Abs, 1, 1) \
F(Float64x2Neg, 1, 1) \
F(Float64x2Sqrt, 1, 1) \
F(Float64x2WithX, 2, 1) \
F(Float64x2WithY, 2, 1) \
F(Float64x2Clamp, 3, 1) \
+ F(Int32x4LoadX, 2, 1) \
+ F(Int32x4LoadXY, 2, 1) \
+ F(Int32x4LoadXYZ, 2, 1) \
+ F(Int32x4LoadXYZW, 2, 1) \
+ F(Int32x4StoreX, 3, 1) \
+ F(Int32x4StoreXY, 3, 1) \
+ F(Int32x4StoreXYZ, 3, 1) \
+ F(Int32x4StoreXYZW, 3, 1) \
F(Int32x4BitsToFloat32x4, 1, 1) \
F(Int32x4Neg, 1, 1) \
F(Int32x4Not, 1, 1) \
INT32x4_BINARY_FUNCTIONS_WITH_INT32_PARAMETER(DECLARE_INT32x4_BINARY_FUNCTION_WITH_INT32_PARAMETER)
INT32x4_BINARY_FUNCTIONS_WITH_BOOLEAN_PARAMETER(DECLARE_INT32x4_BINARY_FUNCTION_WITH_BOOLEAN_PARAMETER)
+function NotImplementedJS() {
+ throw MakeTypeError("Not implemented.");
+}
+
function Float32x4SplatJS(f) {
f = TO_NUMBER_INLINE(f);
return %CreateFloat32x4(f, f, f, f);
// Set up non-enumerable properties of the SIMD float32x4 object.
InstallFunctions($SIMD.float32x4, DONT_ENUM, $Array(
// Float32x4 operations
+ "load", NotImplementedJS,
+ "loadX", NotImplementedJS,
+ "loadXY", NotImplementedJS,
+ "loadXYZ", NotImplementedJS,
+ "store", NotImplementedJS,
+ "storeX", NotImplementedJS,
+ "storeXY", NotImplementedJS,
+ "storeXYZ", NotImplementedJS,
"splat", Float32x4SplatJS,
"zero", Float32x4ZeroJS,
// Unary
// Set up non-enumerable properties of the SIMD float64x2 object.
InstallFunctions($SIMD.float64x2, DONT_ENUM, $Array(
// Float64x2 operations
+ "load", NotImplementedJS,
+ "loadX", NotImplementedJS,
+ "store", NotImplementedJS,
+ "storeX", NotImplementedJS,
"splat", Float64x2SplatJS,
"zero", Float64x2ZeroJS,
// Unary
// Set up non-enumerable properties of the SIMD int32x4 object.
InstallFunctions($SIMD.int32x4, DONT_ENUM, $Array(
// Int32x4 operations
+ "load", NotImplementedJS,
+ "loadX", NotImplementedJS,
+ "loadXY", NotImplementedJS,
+ "loadXYZ", NotImplementedJS,
+ "store", NotImplementedJS,
+ "storeX", NotImplementedJS,
+ "storeXY", NotImplementedJS,
+ "storeXYZ", NotImplementedJS,
"zero", Int32x4ZeroJS,
"splat", Int32x4SplatJS,
"bool", Int32x4BoolJS,
SetUpFloat32x4Array();
SetUpFloat64x2Array();
SetUpInt32x4Array();
+
+// --------------------SIMD128 Access in Typed Array -----------------
+var $Uint8Array = global.Uint8Array;
+var $Int8Array = global.Int8Array;
+var $Uint16Array = global.Uint16Array;
+var $Int16Array = global.Int16Array;
+var $Uint32Array = global.Uint32Array;
+var $Int32Array = global.Int32Array;
+var $Float32Array = global.Float32Array;
+var $Float64Array = global.Float64Array;
+
+macro DECLARE_TYPED_ARRAY_SIMD_LOAD_AND_STORE_FUNCTION(VIEW, TYPE, LANES, NBYTES)
+function VIEWGetTYPELANESJS(index) {
+ if (!(%_ClassOf(this) === 'VIEW')) {
+ throw MakeTypeError('incompatible_method_receiver',
+ ["VIEW._getTYPELANES", this]);
+ }
+ var tarray = this;
+ if (%_ArgumentsLength() < 1) {
+ throw MakeTypeError('invalid_argument');
+ }
+ if (!IS_NUMBER(index)) {
+ throw MakeTypeError('The 2nd argument must be a Number.');
+ }
+ var offset = TO_INTEGER(index) * tarray.BYTES_PER_ELEMENT;
+ if (offset < 0 || (offset + NBYTES) > tarray.byteLength)
+ throw MakeRangeError('The value of index is invalid.');
+ var arraybuffer = tarray.buffer;
+ return %TYPELoadLANES(arraybuffer, offset);
+}
+
+function VIEWSetTYPELANESJS(index, value) {
+ if (!(%_ClassOf(this) === 'VIEW')) {
+ throw MakeTypeError('incompatible_method_receiver',
+ ["VIEW._setTYPELANES", this]);
+ }
+ var tarray = this;
+ if (%_ArgumentsLength() < 2) {
+ throw MakeTypeError('invalid_argument');
+ }
+ if (!IS_NUMBER(index)) {
+ throw MakeTypeError('The 2nd argument must be a Number.');
+ }
+ CheckTYPE(value);
+ var offset = TO_INTEGER(index) * tarray.BYTES_PER_ELEMENT;
+ if (offset < 0 || (offset + NBYTES) > tarray.byteLength)
+ throw MakeRangeError('The value of index is invalid.');
+ var arraybuffer = tarray.buffer;
+ %TYPEStoreLANES(arraybuffer, offset, value);
+}
+endmacro
+
+macro DECLARE_VIEW_SIMD_LOAD_AND_STORE_FUNCTION(VIEW)
+DECLARE_TYPED_ARRAY_SIMD_LOAD_AND_STORE_FUNCTION(VIEW, Float32x4, XYZW, 12)
+DECLARE_TYPED_ARRAY_SIMD_LOAD_AND_STORE_FUNCTION(VIEW, Float32x4, XYZ, 12)
+DECLARE_TYPED_ARRAY_SIMD_LOAD_AND_STORE_FUNCTION(VIEW, Float32x4, XY, 8)
+DECLARE_TYPED_ARRAY_SIMD_LOAD_AND_STORE_FUNCTION(VIEW, Float32x4, X, 4)
+DECLARE_TYPED_ARRAY_SIMD_LOAD_AND_STORE_FUNCTION(VIEW, Float64x2, XY, 16)
+DECLARE_TYPED_ARRAY_SIMD_LOAD_AND_STORE_FUNCTION(VIEW, Float64x2, X, 8)
+DECLARE_TYPED_ARRAY_SIMD_LOAD_AND_STORE_FUNCTION(VIEW, Int32x4, XYZW, 16)
+DECLARE_TYPED_ARRAY_SIMD_LOAD_AND_STORE_FUNCTION(VIEW, Int32x4, XYZ, 12)
+DECLARE_TYPED_ARRAY_SIMD_LOAD_AND_STORE_FUNCTION(VIEW, Int32x4, XY, 8)
+DECLARE_TYPED_ARRAY_SIMD_LOAD_AND_STORE_FUNCTION(VIEW, Int32x4, X, 4)
+endmacro
+
+DECLARE_VIEW_SIMD_LOAD_AND_STORE_FUNCTION(Uint8Array)
+DECLARE_VIEW_SIMD_LOAD_AND_STORE_FUNCTION(Int8Array)
+DECLARE_VIEW_SIMD_LOAD_AND_STORE_FUNCTION(Uint16Array)
+DECLARE_VIEW_SIMD_LOAD_AND_STORE_FUNCTION(Int16Array)
+DECLARE_VIEW_SIMD_LOAD_AND_STORE_FUNCTION(Uint32Array)
+DECLARE_VIEW_SIMD_LOAD_AND_STORE_FUNCTION(Int32Array)
+DECLARE_VIEW_SIMD_LOAD_AND_STORE_FUNCTION(Float32Array)
+DECLARE_VIEW_SIMD_LOAD_AND_STORE_FUNCTION(Float64Array)
+
+function SetupTypedArraysSimdLoadStore() {
+ %CheckIsBootstrapping();
+
+macro DECLARE_INSTALL_SIMD_LOAD_AND_STORE_FUNCTION(VIEW)
+ InstallFunctions($VIEW.prototype, DONT_ENUM, $Array(
+ "_getFloat32x4X", VIEWGetFloat32x4XJS,
+ "_setFloat32x4X", VIEWSetFloat32x4XJS,
+ "_getFloat32x4XY", VIEWGetFloat32x4XYJS,
+ "_setFloat32x4XY", VIEWSetFloat32x4XYJS,
+ "_getFloat32x4XYZ", VIEWGetFloat32x4XYZJS,
+ "_setFloat32x4XYZ", VIEWSetFloat32x4XYZJS,
+ "_getFloat32x4XYZW", VIEWGetFloat32x4XYZWJS,
+ "_setFloat32x4XYZW", VIEWSetFloat32x4XYZWJS,
+ "_getFloat64x2X", VIEWGetFloat64x2XJS,
+ "_setFloat64x2X", VIEWSetFloat64x2XJS,
+ "_getFloat64x2XY", VIEWGetFloat64x2XYJS,
+ "_setFloat64x2XY", VIEWSetFloat64x2XYJS,
+ "_getInt32x4X", VIEWGetInt32x4XJS,
+ "_setInt32x4X", VIEWSetInt32x4XJS,
+ "_getInt32x4XY", VIEWGetInt32x4XYJS,
+ "_setInt32x4XY", VIEWSetInt32x4XYJS,
+ "_getInt32x4XYZ", VIEWGetInt32x4XYZJS,
+ "_setInt32x4XYZ", VIEWSetInt32x4XYZJS,
+ "_getInt32x4XYZW", VIEWGetInt32x4XYZWJS,
+ "_setInt32x4XYZW", VIEWSetInt32x4XYZWJS
+ ));
+endmacro
+
+DECLARE_INSTALL_SIMD_LOAD_AND_STORE_FUNCTION(Uint8Array)
+DECLARE_INSTALL_SIMD_LOAD_AND_STORE_FUNCTION(Int8Array)
+DECLARE_INSTALL_SIMD_LOAD_AND_STORE_FUNCTION(Uint16Array)
+DECLARE_INSTALL_SIMD_LOAD_AND_STORE_FUNCTION(Int16Array)
+DECLARE_INSTALL_SIMD_LOAD_AND_STORE_FUNCTION(Uint32Array)
+DECLARE_INSTALL_SIMD_LOAD_AND_STORE_FUNCTION(Int32Array)
+DECLARE_INSTALL_SIMD_LOAD_AND_STORE_FUNCTION(Float32Array)
+DECLARE_INSTALL_SIMD_LOAD_AND_STORE_FUNCTION(Float64Array)
+}
+
+SetupTypedArraysSimdLoadStore();
}
+void Deoptimizer::CopyDoubleRegisters(FrameDescription* output_frame) {
+}
+
+
void Deoptimizer::CopySIMD128Registers(FrameDescription* output_frame) {
for (int i = 0; i < XMMRegister::NumAllocatableRegisters(); ++i) {
simd128_value_t xmm_value = input_->GetSIMD128Register(i);
}
+simd128_value_t FrameDescription::GetSIMD128Register(unsigned n) const {
+ DCHECK(n < arraysize(simd128_registers_));
+ return simd128_registers_[n];
+}
+
+
+void FrameDescription::SetSIMD128Register(unsigned n, simd128_value_t value) {
+ DCHECK(n < arraysize(simd128_registers_));
+ simd128_registers_[n] = value;
+}
+
+
+int FrameDescription::double_registers_offset() {
+ return OFFSET_OF(FrameDescription, simd128_registers_);
+}
+
+
+int FrameDescription::simd128_registers_offset() {
+ return OFFSET_OF(FrameDescription, simd128_registers_);
+}
+
+
#undef __
--- /dev/null
+// Copyright 2014 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
+// with the distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived
+// from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Flags: --simd_object --allow-natives-syntax
+
+function testFloat32x4LoadAndStore() {
+ var f32_array = new Float32Array(12);
+ for (var i = 0; i < 12; ++i)
+ f32_array[i] = 1.0 + i;
+
+ var v1 = SIMD.float32x4.load(f32_array, 0);
+ var v2 = SIMD.float32x4.load(f32_array, 4);
+ var v3 = SIMD.float32x4.load(f32_array, 8);
+
+ assertEquals(1.0, v1.x);
+ assertEquals(2.0, v1.y);
+ assertEquals(3.0, v1.z);
+ assertEquals(4.0, v1.w);
+
+ assertEquals(5.0, v2.x);
+ assertEquals(6.0, v2.y);
+ assertEquals(7.0, v2.z);
+ assertEquals(8.0, v2.w);
+
+ assertEquals(9.0, v3.x);
+ assertEquals(10.0, v3.y);
+ assertEquals(11.0, v3.z);
+ assertEquals(12.0, v3.w);
+
+ SIMD.float32x4.store(f32_array, 0, SIMD.float32x4(12.0, 11.0, 10.0, 9.0));
+ SIMD.float32x4.store(f32_array, 4, SIMD.float32x4(8.0, 7.0, 6.0, 5.0));
+ SIMD.float32x4.store(f32_array, 8, SIMD.float32x4(4.0, 3.0, 2.0, 1.0));
+
+ for (var i = 0; i < 12; ++i)
+ assertEquals(12.0 - i, f32_array[i]);
+}
+
+testFloat32x4LoadAndStore();
+testFloat32x4LoadAndStore();
+%OptimizeFunctionOnNextCall(testFloat32x4LoadAndStore);
+testFloat32x4LoadAndStore();
+
+function testFloat32x4LoadXAndStoreX() {
+ var f32_array = new Float32Array(12);
+ for (var i = 0; i < 12; ++i)
+ f32_array[i] = 1.0 + i;
+
+ for (var i = 0; i < 12; ++i) {
+ var v = SIMD.float32x4.loadX(f32_array, i);
+
+ assertEquals(1.0 + i, v.x);
+ assertEquals(0.0, v.y);
+ assertEquals(0.0, v.z);
+ assertEquals(0.0, v.w);
+ }
+
+ for (var i = 0; i < 12; ++i) {
+ SIMD.float32x4.storeX(f32_array, i, SIMD.float32x4(12.0 - i, 0.0, 0.0, 0.0));
+ }
+
+ for (var i = 0; i < 12; ++i)
+ assertEquals(12.0 - i, f32_array[i]);
+}
+
+testFloat32x4LoadXAndStoreX();
+testFloat32x4LoadXAndStoreX();
+%OptimizeFunctionOnNextCall(testFloat32x4LoadXAndStoreX);
+testFloat32x4LoadXAndStoreX();
+
+function testFloat32x4LoadXYAndStoreXY() {
+ var f32_array = new Float32Array(12);
+ for (var i = 0; i < 12; ++i)
+ f32_array[i] = 1.0 + i;
+
+ for (var i = 0; i < 12; i += 2) {
+ var v = SIMD.float32x4.loadXY(f32_array, i);
+
+ assertEquals(1.0 + i, v.x);
+ assertEquals(2.0 + i, v.y);
+ assertEquals(0.0, v.z);
+ assertEquals(0.0, v.w);
+ }
+
+ for (var i = 0; i < 12; i += 2) {
+ SIMD.float32x4.storeXY(f32_array, i, SIMD.float32x4(12.0 - i, 11.0 - i, 0.0, 0.0));
+ }
+
+ for (var i = 0; i < 12; ++i)
+ assertEquals(12.0 - i, f32_array[i]);
+}
+
+testFloat32x4LoadXYAndStoreXY();
+testFloat32x4LoadXYAndStoreXY();
+%OptimizeFunctionOnNextCall(testFloat32x4LoadXYAndStoreXY);
+testFloat32x4LoadXYAndStoreXY();
+
+function testFloat32x4LoadXYZAndStoreXYZ() {
+ var f32_array = new Float32Array(12);
+ for (var i = 0; i < 12; ++i)
+ f32_array[i] = 1.0 + i;
+
+ for (var i = 0; i < 12; i += 3) {
+ var v = SIMD.float32x4.loadXYZ(f32_array, i);
+
+ assertEquals(1.0 + i, v.x);
+ assertEquals(2.0 + i, v.y);
+ assertEquals(3.0 + i, v.z);
+ assertEquals(0.0, v.w);
+ }
+
+ for (var i = 0; i < 12; i += 3) {
+ SIMD.float32x4.storeXYZ(f32_array, i, SIMD.float32x4(12.0 - i, 11.0 - i, 10.0 - i, 0.0));
+ }
+
+ for (var i = 0; i < 12; ++i)
+ assertEquals(12.0 - i, f32_array[i]);
+}
+
+testFloat32x4LoadXYZAndStoreXYZ();
+testFloat32x4LoadXYZAndStoreXYZ();
+%OptimizeFunctionOnNextCall(testFloat32x4LoadXYZAndStoreXYZ);
+testFloat32x4LoadXYZAndStoreXYZ();
+
+function testFloat32x4LoadAndStoreFromInt8Array() {
+ var f32_array = new Float32Array(12);
+ for (var i = 0; i < 12; ++i)
+ f32_array[i] = 1.0 + i;
+
+ var i8_array = new Int8Array(f32_array.buffer);
+
+ var v1 = SIMD.float32x4.load(i8_array, 0);
+ var v2 = SIMD.float32x4.load(i8_array, 16);
+ var v3 = SIMD.float32x4.load(i8_array, 32);
+
+ assertEquals(1.0, v1.x);
+ assertEquals(2.0, v1.y);
+ assertEquals(3.0, v1.z);
+ assertEquals(4.0, v1.w);
+
+ assertEquals(5.0, v2.x);
+ assertEquals(6.0, v2.y);
+ assertEquals(7.0, v2.z);
+ assertEquals(8.0, v2.w);
+
+ assertEquals(9.0, v3.x);
+ assertEquals(10.0, v3.y);
+ assertEquals(11.0, v3.z);
+ assertEquals(12.0, v3.w);
+
+ SIMD.float32x4.store(i8_array, 0, SIMD.float32x4(12.0, 11.0, 10.0, 9.0));
+ SIMD.float32x4.store(i8_array, 16, SIMD.float32x4(8.0, 7.0, 6.0, 5.0));
+ SIMD.float32x4.store(i8_array, 32, SIMD.float32x4(4.0, 3.0, 2.0, 1.0));
+
+ for (var i = 0; i < 12; ++i)
+ assertEquals(12.0 - i, f32_array[i]);
+}
+
+testFloat32x4LoadAndStoreFromInt8Array();
+testFloat32x4LoadAndStoreFromInt8Array();
+%OptimizeFunctionOnNextCall(testFloat32x4LoadAndStoreFromInt8Array);
+testFloat32x4LoadAndStoreFromInt8Array();
+
+function testFloat64x2LoadAndStore() {
+ var f64_array = new Float64Array(6);
+ for (var i = 0; i < 6; ++i)
+ f64_array[i] = 1.0 + i;
+
+ var v1 = SIMD.float64x2.load(f64_array, 0);
+ var v2 = SIMD.float64x2.load(f64_array, 2);
+ var v3 = SIMD.float64x2.load(f64_array, 4);
+
+ assertEquals(1.0, v1.x);
+ assertEquals(2.0, v1.y);
+
+ assertEquals(3.0, v2.x);
+ assertEquals(4.0, v2.y);
+
+ assertEquals(5.0, v3.x);
+ assertEquals(6.0, v3.y);
+
+ SIMD.float64x2.store(f64_array, 0, SIMD.float64x2(6.0, 5.0));
+ SIMD.float64x2.store(f64_array, 2, SIMD.float64x2(4.0, 3.0));
+ SIMD.float64x2.store(f64_array, 4, SIMD.float64x2(2.0, 1.0));
+
+ for (var i = 0; i < 6; ++i)
+ assertEquals(6.0 - i, f64_array[i]);
+}
+
+testFloat64x2LoadAndStore();
+testFloat64x2LoadAndStore();
+%OptimizeFunctionOnNextCall(testFloat64x2LoadAndStore);
+testFloat64x2LoadAndStore();
+
+function testInt32x4LoadAndStore() {
+ var i32_array = new Int32Array(12);
+ for (var i = 0; i < 12; ++i)
+ i32_array[i] = 1 + i;
+
+ var v1 = SIMD.int32x4.load(i32_array, 0);
+ var v2 = SIMD.int32x4.load(i32_array, 4);
+ var v3 = SIMD.int32x4.load(i32_array, 8);
+
+ assertEquals(1, v1.x);
+ assertEquals(2, v1.y);
+ assertEquals(3, v1.z);
+ assertEquals(4, v1.w);
+
+ assertEquals(5, v2.x);
+ assertEquals(6, v2.y);
+ assertEquals(7, v2.z);
+ assertEquals(8, v2.w);
+
+ assertEquals(9, v3.x);
+ assertEquals(10, v3.y);
+ assertEquals(11, v3.z);
+ assertEquals(12, v3.w);
+
+ SIMD.int32x4.store(i32_array, 0, SIMD.int32x4(12, 11, 10, 9));
+ SIMD.int32x4.store(i32_array, 4, SIMD.int32x4(8, 7, 6, 5));
+ SIMD.int32x4.store(i32_array, 8, SIMD.int32x4(4, 3, 2, 1));
+
+ for (var i = 0; i < 12; ++i)
+ assertEquals(12.0 - i, i32_array[i]);
+}
+
+testInt32x4LoadAndStore();
+testInt32x4LoadAndStore();
+%OptimizeFunctionOnNextCall(testInt32x4LoadAndStore);
+testInt32x4LoadAndStore();
# -----------------------------------
chromium_crosswalk_rev = 'ea46c0b6279a60b0173a092f0e9f0403a2a047a9'
-v8_crosswalk_rev = '5b2efeab77f1cda6d70f98f20b393fe40ea6898a'
+v8_crosswalk_rev = '825a59c274c95ce90ceab7234c8fa07ad52f7ae5'
ozone_wayland_rev = '6379cd118da098b55a5934ce1a90b377a177ed40'
# |blink_crosswalk_rev| specifies the SHA1 hash of the blink-crosswalk commit
MAJOR=11
MINOR=39
-BUILD=256
+BUILD=258
PATCH=0
'dependencies': [
'../../../base/base.gyp:base',
'../../../base/base.gyp:base_i18n',
- '../../../base/base.gyp:xdg_mime',
'../../../content/content.gyp:content_common',
'../../../crypto/crypto.gyp:crypto',
'../../../net/net.gyp:net',
'../../../sql/sql.gyp:sql',
'../../../url/url.gyp:url_lib',
'../../../third_party/libxml/libxml.gyp:libxml',
- '../../../third_party/re2/re2.gyp:re2',
'../../../third_party/zlib/google/zip.gyp:zip',
],
'sources': [
'conditions': [
['tizen==1', {
'dependencies': [
+ '../../../base/base.gyp:xdg_mime',
'../../build/system.gyp:tizen',
+ '../../build/system.gyp:xmlsec',
'../../tizen/xwalk_tizen.gypi:xwalk_tizen_lib',
'../../../third_party/re2/re2.gyp:re2',
'../../../net/net.gyp:net',
],
- 'cflags': [
- '<!@(pkg-config --cflags xmlsec1)',
- ],
- 'link_settings': {
- 'libraries': [
- '<!@(pkg-config --libs-only-l xmlsec1)',
- ],
- },
'sources': [
'manifest_handlers/tizen_app_control_handler.cc',
'manifest_handlers/tizen_app_control_handler.h',
{ "install", 'i', 0, G_OPTION_ARG_STRING, &install_path,
"Path of the application to be installed/updated", "PATH" },
{ "uninstall", 'd', 0, G_OPTION_ARG_STRING, &uninstall_id,
- "Uninstall the application with this appid/pkgid", "ID" },
+ "Uninstall the application with this pkgid", "ID" },
{ "continue", 'c' , 0, G_OPTION_ARG_NONE, &continue_tasks,
- "Continue the previous unfinished tasks.", NULL},
+ "Continue the previous unfinished tasks", NULL},
{ "reinstall", 'r', 0, G_OPTION_ARG_STRING, &reinstall_id,
"Reinstall the application with this pkgid "
"(This option is ONLY for SDK to support RDS mode"
- " (Rapid Development Support).", "ID" },
+ " (Rapid Development Support)", "ID" },
{ "key", 'k', 0, G_OPTION_ARG_STRING, &operation_key,
"Unique operation key", "KEY" },
{ "quiet", 'q', 0, G_OPTION_ARG_NONE, &quiet,
const base::FilePath& path =
base::MakeAbsoluteFilePath(base::FilePath(install_path));
success = installer->Install(path, &app_id);
- if (!success && storage->Contains(app_id)) {
+ if (!success && !app_id.empty() && storage->Contains(app_id)) {
g_print("trying to update %s\n", app_id.c_str());
success = installer->Update(app_id, path);
}
std::string app_id = PrepareUninstallationID(id);
if (!xwalk::application::IsValidApplicationID(app_id)) {
- LOG(ERROR) << "The given application id " << app_id << " is invalid.";
+ LOG(ERROR) << "The given application id '" << app_id << "' is invalid.";
return false;
}
}
bool PackageInstaller::Reinstall(const std::string& pkgid) {
- base::FilePath app_dir = xwalk::application::GetPackagePath(pkgid);
+ if (!xwalk::application::IsValidPkgID(pkgid)) {
+ LOG(ERROR) << "The given package id '" << pkgid << "' is invalid.";
+ return false;
+ }
+ base::FilePath app_dir = xwalk::application::GetPackagePath(pkgid);
if (!base::DirectoryExists(app_dir)) {
LOG(ERROR) << "Application directory " << app_dir.value()
<< " does not exist!";
'dependencies': [
'build/system.gyp:tizen',
'tizen/xwalk_tizen.gypi:xwalk_tizen_lib',
- '../third_party/re2/re2.gyp:re2',
'<(DEPTH)/ui/events/platform/events_platform.gyp:events_platform',
],
'sources': [
],
},
},
+ {
+ 'target_name': 'xmlsec',
+ 'type': 'none',
+ 'direct_dependent_settings': {
+ 'cflags': [
+ '<!@(pkg-config --cflags xmlsec1)',
+ ],
+ },
+ 'link_settings': {
+ 'ldflags': [
+ '<!@(pkg-config --libs-only-L --libs-only-other xmlsec1)',
+ ],
+ 'libraries': [
+ '<!@(pkg-config --libs-only-l xmlsec1)',
+ ],
+ },
+ }
], # targets
}],
], # conditions
%define _binary_payload w3.gzdio
Name: crosswalk
-Version: 11.39.256.0
+Version: 11.39.258.0
Release: 0
Summary: Chromium-based app runtime
License: (BSD-3-Clause and LGPL-2.1+)
const int kDefaultWidth = 840;
const int kDefaultHeight = 600;
-NativeAppWindow* CreateWindow(
+NativeAppWindow* RuntimeCreateWindow(
Runtime* runtime, const NativeAppWindow::CreateParams& params) {
NativeAppWindow* window = NativeAppWindow::Create(params);
// FIXME : Pass an App icon in params.
window_params_.bounds = gfx::Rect(0, 0, kDefaultWidth, kDefaultHeight);
window_params_.delegate = this;
window_params_.web_contents = runtime_->web_contents();
- window_ = CreateWindow(runtime_, window_params_);
+ window_ = RuntimeCreateWindow(runtime_, window_params_);
}
window_->Show();
#else
const std::string& pkg_id) {
for (PartitionPathContextGetterMap::iterator it = context_getters_.begin();
it != context_getters_.end(); ++it) {
+#if defined(OS_WIN)
+ if (it->first.find(base::UTF8ToWide(pkg_id)))
+#else
if (it->first.find(pkg_id))
+#endif
return it->second.get();
}
return 0;
projects / platform / framework / web / crosswalk.git / commitdiff