Node* AstGraphBuilder::GetFunctionClosure() {
if (!function_closure_.is_set()) {
// Parameter -1 is special for the function closure
- Operator* op = common()->Parameter(-1);
+ const Operator* op = common()->Parameter(-1);
Node* node = NewNode(op, graph()->start());
function_closure_.set(node);
}
Node* AstGraphBuilder::GetFunctionContext() {
if (!function_context_.is_set()) {
// Parameter (arity + 1) is special for the outer context of the function
- Operator* op = common()->Parameter(info()->num_parameters() + 1);
+ const Operator* op = common()->Parameter(info()->num_parameters() + 1);
Node* node = NewNode(op, graph()->start());
function_context_.set(node);
}
}
}
if (should_update) {
- Operator* op = common()->StateValues(count);
+ const Operator* op = common()->StateValues(count);
(*state_values) = graph()->NewNode(op, count, env_values);
}
}
UpdateStateValues(&stack_node_, parameters_count() + locals_count(),
stack_height());
- Operator* op = common()->FrameState(ast_id, combine);
+ const Operator* op = common()->FrameState(ast_id, combine);
return graph()->NewNode(op, parameters_node_, locals_node_, stack_node_,
GetContext(),
case Variable::CONTEXT:
if (hole_init) {
Node* value = jsgraph()->TheHoleConstant();
- Operator* op = javascript()->StoreContext(0, variable->index());
+ const Operator* op = javascript()->StoreContext(0, variable->index());
NewNode(op, current_context(), value);
}
break;
case Variable::CONTEXT: {
VisitForValue(decl->fun());
Node* value = environment()->Pop();
- Operator* op = javascript()->StoreContext(0, variable->index());
+ const Operator* op = javascript()->StoreContext(0, variable->index());
NewNode(op, current_context(), value);
break;
}
// Visit statements in the same scope, no declarations.
VisitStatements(stmt->statements());
} else {
- Operator* op = javascript()->CreateBlockContext();
+ const Operator* op = javascript()->CreateBlockContext();
Node* scope_info = jsgraph()->Constant(stmt->scope()->GetScopeInfo());
Node* context = NewNode(op, scope_info, GetFunctionClosure());
ContextScope scope(this, stmt->scope(), context);
void AstGraphBuilder::VisitWithStatement(WithStatement* stmt) {
VisitForValue(stmt->expression());
Node* value = environment()->Pop();
- Operator* op = javascript()->CreateWithContext();
+ const Operator* op = javascript()->CreateWithContext();
Node* context = NewNode(op, value, GetFunctionClosure());
ContextScope scope(this, stmt->scope(), context);
Visit(stmt->statement());
// value is still on the operand stack while the label is evaluated.
VisitForValue(clause->label());
Node* label = environment()->Pop();
- Operator* op = javascript()->StrictEqual();
+ const Operator* op = javascript()->StrictEqual();
Node* condition = NewNode(op, tag, label);
compare_switch.BeginLabel(i, condition);
Node* info = jsgraph()->Constant(shared_info);
Node* pretenure = expr->pretenure() ? jsgraph()->TrueConstant()
: jsgraph()->FalseConstant();
- Operator* op = javascript()->Runtime(Runtime::kNewClosure, 3);
+ const Operator* op = javascript()->Runtime(Runtime::kNewClosure, 3);
Node* value = NewNode(op, context, info, pretenure);
ast_context()->ProduceValue(value);
}
Node* literal_index = jsgraph()->Constant(expr->literal_index());
Node* pattern = jsgraph()->Constant(expr->pattern());
Node* flags = jsgraph()->Constant(expr->flags());
- Operator* op = javascript()->Runtime(Runtime::kMaterializeRegExpLiteral, 4);
+ const Operator* op =
+ javascript()->Runtime(Runtime::kMaterializeRegExpLiteral, 4);
Node* literal = NewNode(op, literals_array, literal_index, pattern, flags);
ast_context()->ProduceValue(literal);
}
Node* literal_index = jsgraph()->Constant(expr->literal_index());
Node* constants = jsgraph()->Constant(expr->constant_properties());
Node* flags = jsgraph()->Constant(expr->ComputeFlags());
- Operator* op = javascript()->Runtime(Runtime::kCreateObjectLiteral, 4);
+ const Operator* op = javascript()->Runtime(Runtime::kCreateObjectLiteral, 4);
Node* literal = NewNode(op, literals_array, literal_index, constants, flags);
// The object is expected on the operand stack during computation of the
Node* receiver = environment()->Pop();
if (property->emit_store()) {
Node* strict = jsgraph()->Constant(SLOPPY);
- Operator* op = javascript()->Runtime(Runtime::kSetProperty, 4);
+ const Operator* op = javascript()->Runtime(Runtime::kSetProperty, 4);
NewNode(op, receiver, key, value, strict);
}
break;
Node* value = environment()->Pop();
Node* receiver = environment()->Pop();
if (property->emit_store()) {
- Operator* op = javascript()->Runtime(Runtime::kSetPrototype, 2);
+ const Operator* op = javascript()->Runtime(Runtime::kSetPrototype, 2);
NewNode(op, receiver, value);
}
break;
Node* getter = environment()->Pop();
Node* name = environment()->Pop();
Node* attr = jsgraph()->Constant(NONE);
- Operator* op =
+ const Operator* op =
javascript()->Runtime(Runtime::kDefineAccessorPropertyUnchecked, 5);
NewNode(op, literal, name, getter, setter, attr);
}
// Transform literals that contain functions to fast properties.
if (expr->has_function()) {
- Operator* op = javascript()->Runtime(Runtime::kToFastProperties, 1);
+ const Operator* op = javascript()->Runtime(Runtime::kToFastProperties, 1);
NewNode(op, literal);
}
Node* literal_index = jsgraph()->Constant(expr->literal_index());
Node* constants = jsgraph()->Constant(expr->constant_elements());
Node* flags = jsgraph()->Constant(expr->ComputeFlags());
- Operator* op = javascript()->Runtime(Runtime::kCreateArrayLiteral, 4);
+ const Operator* op = javascript()->Runtime(Runtime::kCreateArrayLiteral, 4);
Node* literal = NewNode(op, literals_array, literal_index, constants, flags);
// The array and the literal index are both expected on the operand stack
void AstGraphBuilder::VisitThrow(Throw* expr) {
VisitForValue(expr->exception());
Node* exception = environment()->Pop();
- Operator* op = javascript()->Runtime(Runtime::kThrow, 1);
+ const Operator* op = javascript()->Runtime(Runtime::kThrow, 1);
Node* value = NewNode(op, exception);
ast_context()->ProduceValue(value);
}
Variable* variable = callee->AsVariableProxy()->var();
DCHECK(variable->location() == Variable::LOOKUP);
Node* name = jsgraph()->Constant(variable->name());
- Operator* op = javascript()->Runtime(Runtime::kLoadLookupSlot, 2);
+ const Operator* op = javascript()->Runtime(Runtime::kLoadLookupSlot, 2);
Node* pair = NewNode(op, current_context(), name);
callee_value = NewNode(common()->Projection(0), pair);
receiver_value = NewNode(common()->Projection(1), pair);
Node* receiver = environment()->Lookup(info()->scope()->receiver());
Node* strict = jsgraph()->Constant(strict_mode());
Node* position = jsgraph()->Constant(info()->scope()->start_position());
- Operator* op =
+ const Operator* op =
javascript()->Runtime(Runtime::kResolvePossiblyDirectEval, 5);
Node* pair = NewNode(op, callee, source, receiver, strict, position);
Node* new_callee = NewNode(common()->Projection(0), pair);
}
// Create node to perform the function call.
- Operator* call = javascript()->Call(args->length() + 2, flags);
+ const Operator* call = javascript()->Call(args->length() + 2, flags);
Node* value = ProcessArguments(call, args->length() + 2);
PrepareFrameState(value, expr->id(), ast_context()->GetStateCombine());
ast_context()->ProduceValue(value);
VisitForValues(args);
// Create node to perform the construct call.
- Operator* call = javascript()->CallNew(args->length() + 1);
+ const Operator* call = javascript()->CallNew(args->length() + 1);
Node* value = ProcessArguments(call, args->length() + 1);
PrepareFrameState(value, expr->id(), ast_context()->GetStateCombine());
ast_context()->ProduceValue(value);
VisitForValues(args);
// Create node to perform the JS runtime call.
- Operator* call = javascript()->Call(args->length() + 2, flags);
+ const Operator* call = javascript()->Call(args->length() + 2, flags);
Node* value = ProcessArguments(call, args->length() + 2);
PrepareFrameState(value, expr->id(), ast_context()->GetStateCombine());
ast_context()->ProduceValue(value);
// Create node to perform the runtime call.
Runtime::FunctionId functionId = function->function_id;
- Operator* call = javascript()->Runtime(functionId, args->length());
+ const Operator* call = javascript()->Runtime(functionId, args->length());
Node* value = ProcessArguments(call, args->length());
PrepareFrameState(value, expr->id(), ast_context()->GetStateCombine());
ast_context()->ProduceValue(value);
void AstGraphBuilder::VisitCompareOperation(CompareOperation* expr) {
- Operator* op;
+ const Operator* op;
switch (expr->op()) {
case Token::EQ:
op = javascript()->Equal();
DeclareGlobalsStrictMode::encode(strict_mode());
Node* flags = jsgraph()->Constant(encoded_flags);
Node* pairs = jsgraph()->Constant(data);
- Operator* op = javascript()->Runtime(Runtime::kDeclareGlobals, 3);
+ const Operator* op = javascript()->Runtime(Runtime::kDeclareGlobals, 3);
NewNode(op, current_context(), pairs, flags);
globals()->Rewind(0);
}
}
-Node* AstGraphBuilder::ProcessArguments(Operator* op, int arity) {
+Node* AstGraphBuilder::ProcessArguments(const Operator* op, int arity) {
DCHECK(environment()->stack_height() >= arity);
Node** all = info()->zone()->NewArray<Node*>(arity);
for (int i = arity - 1; i >= 0; --i) {
set_current_context(context);
// Allocate a new local context.
- Operator* op = javascript()->CreateFunctionContext();
+ const Operator* op = javascript()->CreateFunctionContext();
Node* local_context = NewNode(op, closure);
set_current_context(local_context);
Node* parameter = NewNode(common()->Parameter(i + 1), graph()->start());
// Context variable (at bottom of the context chain).
DCHECK_EQ(0, info()->scope()->ContextChainLength(variable->scope()));
- Operator* op = javascript()->StoreContext(0, variable->index());
+ const Operator* op = javascript()->StoreContext(0, variable->index());
NewNode(op, local_context, parameter);
}
// Allocate and initialize a new arguments object.
Node* callee = GetFunctionClosure();
- Operator* op = javascript()->Runtime(Runtime::kNewArguments, 1);
+ const Operator* op = javascript()->Runtime(Runtime::kNewArguments, 1);
Node* object = NewNode(op, callee);
// Assign the object to the arguments variable.
// Global var, const, or let variable.
Node* global = BuildLoadGlobalObject();
Unique<Name> name = MakeUnique(variable->name());
- Operator* op = javascript()->LoadNamed(name, contextual_mode);
+ const Operator* op = javascript()->LoadNamed(name, contextual_mode);
Node* node = NewNode(op, global);
PrepareFrameState(node, bailout_id, kPushOutput);
return node;
// Context variable (potentially up the context chain).
int depth = current_scope()->ContextChainLength(variable->scope());
bool immutable = variable->maybe_assigned() == kNotAssigned;
- Operator* op =
+ const Operator* op =
javascript()->LoadContext(depth, variable->index(), immutable);
Node* value = NewNode(op, current_context());
// TODO(titzer): initialization checks are redundant for already
(contextual_mode == CONTEXTUAL)
? Runtime::kLoadLookupSlot
: Runtime::kLoadLookupSlotNoReferenceError;
- Operator* op = javascript()->Runtime(function_id, 2);
+ const Operator* op = javascript()->Runtime(function_id, 2);
Node* pair = NewNode(op, current_context(), name);
return NewNode(common()->Projection(0), pair);
}
// Global var, const, or let variable.
Node* global = BuildLoadGlobalObject();
Node* name = jsgraph()->Constant(variable->name());
- Operator* op = javascript()->DeleteProperty(strict_mode());
+ const Operator* op = javascript()->DeleteProperty(strict_mode());
return NewNode(op, global, name);
}
case Variable::PARAMETER:
case Variable::LOOKUP: {
// Dynamic lookup of context variable (anywhere in the chain).
Node* name = jsgraph()->Constant(variable->name());
- Operator* op = javascript()->Runtime(Runtime::kDeleteLookupSlot, 2);
+ const Operator* op = javascript()->Runtime(Runtime::kDeleteLookupSlot, 2);
return NewNode(op, current_context(), name);
}
}
// Global var, const, or let variable.
Node* global = BuildLoadGlobalObject();
Unique<Name> name = MakeUnique(variable->name());
- Operator* op = javascript()->StoreNamed(strict_mode(), name);
+ const Operator* op = javascript()->StoreNamed(strict_mode(), name);
Node* store = NewNode(op, global, value);
PrepareFrameState(store, bailout_id);
return store;
int depth = current_scope()->ContextChainLength(variable->scope());
if (mode == CONST_LEGACY && op == Token::INIT_CONST_LEGACY) {
// Perform an initialization check for legacy const variables.
- Operator* op =
+ const Operator* op =
javascript()->LoadContext(depth, variable->index(), false);
Node* current = NewNode(op, current_context());
value = BuildHoleCheckSilent(current, value, current);
return value;
} else if (mode == LET && op != Token::INIT_LET) {
// Perform an initialization check for let declared variables.
- Operator* op =
+ const Operator* op =
javascript()->LoadContext(depth, variable->index(), false);
Node* current = NewNode(op, current_context());
value = BuildHoleCheckThrow(current, variable, value);
// All assignments to const variables are early errors.
UNREACHABLE();
}
- Operator* op = javascript()->StoreContext(depth, variable->index());
+ const Operator* op = javascript()->StoreContext(depth, variable->index());
return NewNode(op, current_context(), value);
}
case Variable::LOOKUP: {
Node* strict = jsgraph()->Constant(strict_mode());
// TODO(mstarzinger): Use Runtime::kInitializeLegacyConstLookupSlot for
// initializations of const declarations.
- Operator* op = javascript()->Runtime(Runtime::kStoreLookupSlot, 4);
+ const Operator* op = javascript()->Runtime(Runtime::kStoreLookupSlot, 4);
return NewNode(op, value, current_context(), name, strict);
}
}
Node* AstGraphBuilder::BuildLoadGlobalObject() {
Node* context = GetFunctionContext();
- Operator* load_op =
+ const Operator* load_op =
javascript()->LoadContext(0, Context::GLOBAL_OBJECT_INDEX, true);
return NewNode(load_op, context);
}
Node* AstGraphBuilder::BuildThrowReferenceError(Variable* variable) {
// TODO(mstarzinger): Should be unified with the VisitThrow implementation.
Node* variable_name = jsgraph()->Constant(variable->name());
- Operator* op = javascript()->Runtime(Runtime::kThrowReferenceError, 1);
+ const Operator* op = javascript()->Runtime(Runtime::kThrowReferenceError, 1);
return NewNode(op, variable_name);
}
Node* AstGraphBuilder::BuildBinaryOp(Node* left, Node* right, Token::Value op) {
- Operator* js_op;
+ const Operator* js_op;
switch (op) {
case Token::BIT_OR:
js_op = javascript()->BitwiseOr();
// Process arguments to a call by popping {arity} elements off the operand
// stack and build a call node using the given call operator.
- Node* ProcessArguments(Operator* op, int arity);
+ Node* ProcessArguments(const Operator* op, int arity);
// Visit statements.
void VisitIfNotNull(Statement* stmt);
Node* branch = graph()->NewNode(common()->Branch(), tag, control);
Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
- Operator* op = (signedness == kSigned) ? machine()->ChangeFloat64ToInt32()
- : machine()->ChangeFloat64ToUint32();
+ const Operator* op = (signedness == kSigned)
+ ? machine()->ChangeFloat64ToInt32()
+ : machine()->ChangeFloat64ToUint32();
Node* change = graph()->NewNode(op, LoadHeapNumberValue(val, if_true));
Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
TEST_F(CommonOperatorTest, ControlEffect) {
- Operator* op = common()->ControlEffect();
+ const Operator* op = common()->ControlEffect();
EXPECT_EQ(1, OperatorProperties::GetControlInputCount(op));
EXPECT_EQ(1, OperatorProperties::GetTotalInputCount(op));
EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
TEST_F(CommonOperatorTest, ValueEffect) {
TRACED_FOREACH(int, arguments, kArguments) {
- Operator* op = common()->ValueEffect(arguments);
+ const Operator* op = common()->ValueEffect(arguments);
EXPECT_EQ(arguments, OperatorProperties::GetValueInputCount(op));
EXPECT_EQ(arguments, OperatorProperties::GetTotalInputCount(op));
EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
TEST_F(CommonOperatorTest, Finish) {
TRACED_FOREACH(int, arguments, kArguments) {
- Operator* op = common()->Finish(arguments);
+ const Operator* op = common()->Finish(arguments);
EXPECT_EQ(1, OperatorProperties::GetValueInputCount(op));
EXPECT_EQ(arguments, OperatorProperties::GetEffectInputCount(op));
EXPECT_EQ(arguments + 1, OperatorProperties::GetTotalInputCount(op));
return new (zone_) ControlOperator(IrOpcode::k##name, Operator::kFoldable, \
inputs, 0, controls, #name);
- Operator* Start(int num_formal_parameters) {
+ const Operator* Start(int num_formal_parameters) {
// Outputs are formal parameters, plus context, receiver, and JSFunction.
int outputs = num_formal_parameters + 3;
return new (zone_) ControlOperator(IrOpcode::kStart, Operator::kFoldable, 0,
outputs, 0, "Start");
}
- Operator* Dead() { CONTROL_OP(Dead, 0, 0); }
- Operator* End() { CONTROL_OP(End, 0, 1); }
- Operator* Branch() { CONTROL_OP(Branch, 1, 1); }
- Operator* IfTrue() { CONTROL_OP(IfTrue, 0, 1); }
- Operator* IfFalse() { CONTROL_OP(IfFalse, 0, 1); }
- Operator* Throw() { CONTROL_OP(Throw, 1, 1); }
+ const Operator* Dead() { CONTROL_OP(Dead, 0, 0); }
+ const Operator* End() { CONTROL_OP(End, 0, 1); }
+ const Operator* Branch() { CONTROL_OP(Branch, 1, 1); }
+ const Operator* IfTrue() { CONTROL_OP(IfTrue, 0, 1); }
+ const Operator* IfFalse() { CONTROL_OP(IfFalse, 0, 1); }
+ const Operator* Throw() { CONTROL_OP(Throw, 1, 1); }
- Operator* Return() {
+ const Operator* Return() {
return new (zone_) ControlOperator(
IrOpcode::kReturn, Operator::kNoProperties, 1, 0, 1, "Return");
}
- Operator* Merge(int controls) {
+ const Operator* Merge(int controls) {
return new (zone_) ControlOperator(IrOpcode::kMerge, Operator::kFoldable, 0,
0, controls, "Merge");
}
- Operator* Loop(int controls) {
+ const Operator* Loop(int controls) {
return new (zone_) ControlOperator(IrOpcode::kLoop, Operator::kFoldable, 0,
0, controls, "Loop");
}
- Operator* Parameter(int index) {
+ const Operator* Parameter(int index) {
return new (zone_) Operator1<int>(IrOpcode::kParameter, Operator::kPure, 1,
1, "Parameter", index);
}
- Operator* Int32Constant(int32_t value) {
+ const Operator* Int32Constant(int32_t value) {
return new (zone_)
Operator1<int32_t>(IrOpcode::kInt32Constant, Operator::kPure, 0, 1,
"Int32Constant", value);
}
- Operator* Int64Constant(int64_t value) {
+ const Operator* Int64Constant(int64_t value) {
return new (zone_)
Operator1<int64_t>(IrOpcode::kInt64Constant, Operator::kPure, 0, 1,
"Int64Constant", value);
}
- Operator* Float64Constant(double value) {
+ const Operator* Float64Constant(double value) {
return new (zone_)
Operator1<double>(IrOpcode::kFloat64Constant, Operator::kPure, 0, 1,
"Float64Constant", value);
}
- Operator* ExternalConstant(ExternalReference value) {
+ const Operator* ExternalConstant(ExternalReference value) {
return new (zone_) Operator1<ExternalReference>(IrOpcode::kExternalConstant,
Operator::kPure, 0, 1,
"ExternalConstant", value);
}
- Operator* NumberConstant(double value) {
+ const Operator* NumberConstant(double value) {
return new (zone_)
Operator1<double>(IrOpcode::kNumberConstant, Operator::kPure, 0, 1,
"NumberConstant", value);
}
- Operator* HeapConstant(Unique<Object> value) {
+ const Operator* HeapConstant(Unique<Object> value) {
return new (zone_) Operator1<Unique<Object> >(
IrOpcode::kHeapConstant, Operator::kPure, 0, 1, "HeapConstant", value);
}
- Operator* Phi(MachineType type, int arguments) {
+ const Operator* Phi(MachineType type, int arguments) {
DCHECK(arguments > 0); // Disallow empty phis.
return new (zone_) Operator1<MachineType>(IrOpcode::kPhi, Operator::kPure,
arguments, 1, "Phi", type);
}
- Operator* EffectPhi(int arguments) {
+ const Operator* EffectPhi(int arguments) {
DCHECK(arguments > 0); // Disallow empty phis.
return new (zone_) Operator1<int>(IrOpcode::kEffectPhi, Operator::kPure, 0,
0, "EffectPhi", arguments);
}
- Operator* ControlEffect() {
+ const Operator* ControlEffect() {
return new (zone_) SimpleOperator(IrOpcode::kControlEffect, Operator::kPure,
0, 0, "ControlEffect");
}
- Operator* ValueEffect(int arguments) {
+ const Operator* ValueEffect(int arguments) {
DCHECK(arguments > 0); // Disallow empty value effects.
return new (zone_) SimpleOperator(IrOpcode::kValueEffect, Operator::kPure,
arguments, 0, "ValueEffect");
}
- Operator* Finish(int arguments) {
+ const Operator* Finish(int arguments) {
DCHECK(arguments > 0); // Disallow empty finishes.
return new (zone_) Operator1<int>(IrOpcode::kFinish, Operator::kPure, 1, 1,
"Finish", arguments);
}
- Operator* StateValues(int arguments) {
+ const Operator* StateValues(int arguments) {
return new (zone_) Operator1<int>(IrOpcode::kStateValues, Operator::kPure,
arguments, 1, "StateValues", arguments);
}
- Operator* FrameState(BailoutId bailout_id, OutputFrameStateCombine combine) {
+ const Operator* FrameState(BailoutId bailout_id,
+ OutputFrameStateCombine combine) {
return new (zone_) Operator1<FrameStateCallInfo>(
IrOpcode::kFrameState, Operator::kPure, 4, 1, "FrameState",
FrameStateCallInfo(bailout_id, combine));
}
- Operator* Call(CallDescriptor* descriptor) {
+ const Operator* Call(CallDescriptor* descriptor) {
return new (zone_) CallOperator(descriptor, "Call");
}
- Operator* Projection(size_t index) {
+ const Operator* Projection(size_t index) {
return new (zone_) Operator1<size_t>(IrOpcode::kProjection, Operator::kPure,
1, 1, "Projection", index);
}
exit_control_(NULL) {}
-Node* StructuredGraphBuilder::MakeNode(Operator* op, int value_input_count,
+Node* StructuredGraphBuilder::MakeNode(const Operator* op,
+ int value_input_count,
Node** value_inputs) {
DCHECK(op->InputCount() == value_input_count);
Node* StructuredGraphBuilder::NewPhi(int count, Node* input, Node* control) {
- Operator* phi_op = common()->Phi(kMachAnyTagged, count);
+ const Operator* phi_op = common()->Phi(kMachAnyTagged, count);
Node** buffer = zone()->NewArray<Node*>(count + 1);
MemsetPointer(buffer, input, count);
buffer[count] = control;
// TODO(mstarzinger): Revisit this once we have proper effect states.
Node* StructuredGraphBuilder::NewEffectPhi(int count, Node* input,
Node* control) {
- Operator* phi_op = common()->EffectPhi(count);
+ const Operator* phi_op = common()->EffectPhi(count);
Node** buffer = zone()->NewArray<Node*>(count + 1);
MemsetPointer(buffer, input, count);
buffer[count] = control;
int inputs = OperatorProperties::GetControlInputCount(control->op()) + 1;
if (control->opcode() == IrOpcode::kLoop) {
// Control node for loop exists, add input.
- Operator* op = common()->Loop(inputs);
+ const Operator* op = common()->Loop(inputs);
control->AppendInput(zone(), other);
control->set_op(op);
} else if (control->opcode() == IrOpcode::kMerge) {
// Control node for merge exists, add input.
- Operator* op = common()->Merge(inputs);
+ const Operator* op = common()->Merge(inputs);
control->AppendInput(zone(), other);
control->set_op(op);
} else {
// Control node is a singleton, introduce a merge.
- Operator* op = common()->Merge(inputs);
+ const Operator* op = common()->Merge(inputs);
control = graph()->NewNode(op, control, other);
}
return control;
explicit GraphBuilder(Graph* graph) : graph_(graph) {}
virtual ~GraphBuilder() {}
- Node* NewNode(Operator* op) {
+ Node* NewNode(const Operator* op) {
return MakeNode(op, 0, static_cast<Node**>(NULL));
}
- Node* NewNode(Operator* op, Node* n1) { return MakeNode(op, 1, &n1); }
+ Node* NewNode(const Operator* op, Node* n1) { return MakeNode(op, 1, &n1); }
- Node* NewNode(Operator* op, Node* n1, Node* n2) {
+ Node* NewNode(const Operator* op, Node* n1, Node* n2) {
Node* buffer[] = {n1, n2};
return MakeNode(op, arraysize(buffer), buffer);
}
- Node* NewNode(Operator* op, Node* n1, Node* n2, Node* n3) {
+ Node* NewNode(const Operator* op, Node* n1, Node* n2, Node* n3) {
Node* buffer[] = {n1, n2, n3};
return MakeNode(op, arraysize(buffer), buffer);
}
- Node* NewNode(Operator* op, Node* n1, Node* n2, Node* n3, Node* n4) {
+ Node* NewNode(const Operator* op, Node* n1, Node* n2, Node* n3, Node* n4) {
Node* buffer[] = {n1, n2, n3, n4};
return MakeNode(op, arraysize(buffer), buffer);
}
- Node* NewNode(Operator* op, Node* n1, Node* n2, Node* n3, Node* n4,
+ Node* NewNode(const Operator* op, Node* n1, Node* n2, Node* n3, Node* n4,
Node* n5) {
Node* buffer[] = {n1, n2, n3, n4, n5};
return MakeNode(op, arraysize(buffer), buffer);
}
- Node* NewNode(Operator* op, Node* n1, Node* n2, Node* n3, Node* n4, Node* n5,
- Node* n6) {
+ Node* NewNode(const Operator* op, Node* n1, Node* n2, Node* n3, Node* n4,
+ Node* n5, Node* n6) {
Node* nodes[] = {n1, n2, n3, n4, n5, n6};
return MakeNode(op, arraysize(nodes), nodes);
}
- Node* NewNode(Operator* op, int value_input_count, Node** value_inputs) {
+ Node* NewNode(const Operator* op, int value_input_count,
+ Node** value_inputs) {
return MakeNode(op, value_input_count, value_inputs);
}
protected:
// Base implementation used by all factory methods.
- virtual Node* MakeNode(Operator* op, int value_input_count,
+ virtual Node* MakeNode(const Operator* op, int value_input_count,
Node** value_inputs) = 0;
private:
// The following method creates a new node having the specified operator and
// ensures effect and control dependencies are wired up. The dependencies
// tracked by the environment might be mutated.
- virtual Node* MakeNode(Operator* op, int value_input_count,
- Node** value_inputs);
+ virtual Node* MakeNode(const Operator* op, int value_input_count,
+ Node** value_inputs) FINAL;
Environment* environment() const { return environment_; }
void set_environment(Environment* env) { environment_ = env; }
if (access.depth() == 0) {
return Reducer::NoChange();
}
- Operator* op = jsgraph_->javascript()->LoadContext(0, access.index(),
- access.immutable());
+ const Operator* op = jsgraph_->javascript()->LoadContext(
+ 0, access.index(), access.immutable());
node->set_op(op);
Handle<Object> context_handle = Handle<Object>(context, info_->isolate());
node->ReplaceInput(0, jsgraph_->Constant(context_handle));
context = context->previous();
}
- Operator* op = jsgraph_->javascript()->StoreContext(0, access.index());
+ const Operator* op = jsgraph_->javascript()->StoreContext(0, access.index());
node->set_op(op);
Handle<Object> new_context_handle = Handle<Object>(context, info_->isolate());
node->ReplaceInput(0, jsgraph_->Constant(new_context_handle));
return Reducer::Changed(node);
}
-}
-}
-} // namespace v8::internal::compiler
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
machine_(machine) {}
-void JSGenericLowering::PatchOperator(Node* node, Operator* op) {
+void JSGenericLowering::PatchOperator(Node* node, const Operator* op) {
node->set_op(op);
}
Node* ExternalConstant(ExternalReference ref);
// Helpers to patch existing nodes in the graph.
- void PatchOperator(Node* node, Operator* new_op);
+ void PatchOperator(Node* node, const Operator* new_op);
void PatchInsertInput(Node* node, int index, Node* input);
// Helpers to replace existing nodes with a generic call.
}
-Node* JSGraph::NewNode(Operator* op) {
+Node* JSGraph::NewNode(const Operator* op) {
Node* node = graph()->NewNode(op);
typer_->Init(node);
return node;
Node* ImmovableHeapConstant(Handle<Object> value);
Node* NumberConstant(double value);
- Node* NewNode(Operator* op);
+ Node* NewNode(const Operator* op);
Factory* factory() { return isolate()->factory(); }
};
int predecessors =
OperatorProperties::GetControlInputCount(final_merge->op());
- Operator* op_phi = jsgraph_->common()->Phi(kMachAnyTagged, predecessors);
- Operator* op_ephi = jsgraph_->common()->EffectPhi(predecessors);
+ const Operator* op_phi =
+ jsgraph_->common()->Phi(kMachAnyTagged, predecessors);
+ const Operator* op_ephi = jsgraph_->common()->EffectPhi(predecessors);
NodeVector values(jsgraph_->zone());
NodeVector effects(jsgraph_->zone());
#define PURE_BINOP(name) SIMPLE(name, Operator::kPure, 2, 1)
- Operator* Equal() { BINOP(JSEqual); }
- Operator* NotEqual() { BINOP(JSNotEqual); }
- Operator* StrictEqual() { PURE_BINOP(JSStrictEqual); }
- Operator* StrictNotEqual() { PURE_BINOP(JSStrictNotEqual); }
- Operator* LessThan() { BINOP(JSLessThan); }
- Operator* GreaterThan() { BINOP(JSGreaterThan); }
- Operator* LessThanOrEqual() { BINOP(JSLessThanOrEqual); }
- Operator* GreaterThanOrEqual() { BINOP(JSGreaterThanOrEqual); }
- Operator* BitwiseOr() { BINOP(JSBitwiseOr); }
- Operator* BitwiseXor() { BINOP(JSBitwiseXor); }
- Operator* BitwiseAnd() { BINOP(JSBitwiseAnd); }
- Operator* ShiftLeft() { BINOP(JSShiftLeft); }
- Operator* ShiftRight() { BINOP(JSShiftRight); }
- Operator* ShiftRightLogical() { BINOP(JSShiftRightLogical); }
- Operator* Add() { BINOP(JSAdd); }
- Operator* Subtract() { BINOP(JSSubtract); }
- Operator* Multiply() { BINOP(JSMultiply); }
- Operator* Divide() { BINOP(JSDivide); }
- Operator* Modulus() { BINOP(JSModulus); }
-
- Operator* UnaryNot() { UNOP(JSUnaryNot); }
- Operator* ToBoolean() { UNOP(JSToBoolean); }
- Operator* ToNumber() { UNOP(JSToNumber); }
- Operator* ToString() { UNOP(JSToString); }
- Operator* ToName() { UNOP(JSToName); }
- Operator* ToObject() { UNOP(JSToObject); }
- Operator* Yield() { UNOP(JSYield); }
-
- Operator* Create() { SIMPLE(JSCreate, Operator::kEliminatable, 0, 1); }
-
- Operator* Call(int arguments, CallFunctionFlags flags) {
+ const Operator* Equal() { BINOP(JSEqual); }
+ const Operator* NotEqual() { BINOP(JSNotEqual); }
+ const Operator* StrictEqual() { PURE_BINOP(JSStrictEqual); }
+ const Operator* StrictNotEqual() { PURE_BINOP(JSStrictNotEqual); }
+ const Operator* LessThan() { BINOP(JSLessThan); }
+ const Operator* GreaterThan() { BINOP(JSGreaterThan); }
+ const Operator* LessThanOrEqual() { BINOP(JSLessThanOrEqual); }
+ const Operator* GreaterThanOrEqual() { BINOP(JSGreaterThanOrEqual); }
+ const Operator* BitwiseOr() { BINOP(JSBitwiseOr); }
+ const Operator* BitwiseXor() { BINOP(JSBitwiseXor); }
+ const Operator* BitwiseAnd() { BINOP(JSBitwiseAnd); }
+ const Operator* ShiftLeft() { BINOP(JSShiftLeft); }
+ const Operator* ShiftRight() { BINOP(JSShiftRight); }
+ const Operator* ShiftRightLogical() { BINOP(JSShiftRightLogical); }
+ const Operator* Add() { BINOP(JSAdd); }
+ const Operator* Subtract() { BINOP(JSSubtract); }
+ const Operator* Multiply() { BINOP(JSMultiply); }
+ const Operator* Divide() { BINOP(JSDivide); }
+ const Operator* Modulus() { BINOP(JSModulus); }
+
+ const Operator* UnaryNot() { UNOP(JSUnaryNot); }
+ const Operator* ToBoolean() { UNOP(JSToBoolean); }
+ const Operator* ToNumber() { UNOP(JSToNumber); }
+ const Operator* ToString() { UNOP(JSToString); }
+ const Operator* ToName() { UNOP(JSToName); }
+ const Operator* ToObject() { UNOP(JSToObject); }
+ const Operator* Yield() { UNOP(JSYield); }
+
+ const Operator* Create() { SIMPLE(JSCreate, Operator::kEliminatable, 0, 1); }
+
+ const Operator* Call(int arguments, CallFunctionFlags flags) {
CallParameters parameters = {arguments, flags};
OP1(JSCallFunction, CallParameters, parameters, Operator::kNoProperties,
arguments, 1);
}
- Operator* CallNew(int arguments) {
+ const Operator* CallNew(int arguments) {
return new (zone_)
Operator1<int>(IrOpcode::kJSCallConstruct, Operator::kNoProperties,
arguments, 1, "JSCallConstruct", arguments);
}
- Operator* LoadProperty() { BINOP(JSLoadProperty); }
- Operator* LoadNamed(Unique<Name> name,
- ContextualMode contextual_mode = NOT_CONTEXTUAL) {
+ const Operator* LoadProperty() { BINOP(JSLoadProperty); }
+ const Operator* LoadNamed(Unique<Name> name,
+ ContextualMode contextual_mode = NOT_CONTEXTUAL) {
LoadNamedParameters parameters = {name, contextual_mode};
OP1(JSLoadNamed, LoadNamedParameters, parameters, Operator::kNoProperties,
1, 1);
}
- Operator* StoreProperty(StrictMode strict_mode) {
+ const Operator* StoreProperty(StrictMode strict_mode) {
OP1(JSStoreProperty, StrictMode, strict_mode, Operator::kNoProperties, 3,
0);
}
- Operator* StoreNamed(StrictMode strict_mode, Unique<Name> name) {
+ const Operator* StoreNamed(StrictMode strict_mode, Unique<Name> name) {
StoreNamedParameters parameters = {strict_mode, name};
OP1(JSStoreNamed, StoreNamedParameters, parameters, Operator::kNoProperties,
2, 0);
}
- Operator* DeleteProperty(StrictMode strict_mode) {
+ const Operator* DeleteProperty(StrictMode strict_mode) {
OP1(JSDeleteProperty, StrictMode, strict_mode, Operator::kNoProperties, 2,
1);
}
- Operator* HasProperty() { NOPROPS(JSHasProperty, 2, 1); }
+ const Operator* HasProperty() { NOPROPS(JSHasProperty, 2, 1); }
- Operator* LoadContext(uint16_t depth, uint32_t index, bool immutable) {
+ const Operator* LoadContext(uint16_t depth, uint32_t index, bool immutable) {
ContextAccess access(depth, index, immutable);
OP1(JSLoadContext, ContextAccess, access,
Operator::kEliminatable | Operator::kNoWrite, 1, 1);
}
- Operator* StoreContext(uint16_t depth, uint32_t index) {
+ const Operator* StoreContext(uint16_t depth, uint32_t index) {
ContextAccess access(depth, index, false);
OP1(JSStoreContext, ContextAccess, access, Operator::kNoProperties, 2, 0);
}
- Operator* TypeOf() { SIMPLE(JSTypeOf, Operator::kPure, 1, 1); }
- Operator* InstanceOf() { NOPROPS(JSInstanceOf, 2, 1); }
- Operator* Debugger() { NOPROPS(JSDebugger, 0, 0); }
+ const Operator* TypeOf() { SIMPLE(JSTypeOf, Operator::kPure, 1, 1); }
+ const Operator* InstanceOf() { NOPROPS(JSInstanceOf, 2, 1); }
+ const Operator* Debugger() { NOPROPS(JSDebugger, 0, 0); }
// TODO(titzer): nail down the static parts of each of these context flavors.
- Operator* CreateFunctionContext() { NOPROPS(JSCreateFunctionContext, 1, 1); }
- Operator* CreateCatchContext(Unique<String> name) {
+ const Operator* CreateFunctionContext() {
+ NOPROPS(JSCreateFunctionContext, 1, 1);
+ }
+ const Operator* CreateCatchContext(Unique<String> name) {
OP1(JSCreateCatchContext, Unique<String>, name, Operator::kNoProperties, 1,
1);
}
- Operator* CreateWithContext() { NOPROPS(JSCreateWithContext, 2, 1); }
- Operator* CreateBlockContext() { NOPROPS(JSCreateBlockContext, 2, 1); }
- Operator* CreateModuleContext() { NOPROPS(JSCreateModuleContext, 2, 1); }
- Operator* CreateGlobalContext() { NOPROPS(JSCreateGlobalContext, 2, 1); }
+ const Operator* CreateWithContext() { NOPROPS(JSCreateWithContext, 2, 1); }
+ const Operator* CreateBlockContext() { NOPROPS(JSCreateBlockContext, 2, 1); }
+ const Operator* CreateModuleContext() {
+ NOPROPS(JSCreateModuleContext, 2, 1);
+ }
+ const Operator* CreateGlobalContext() {
+ NOPROPS(JSCreateGlobalContext, 2, 1);
+ }
- Operator* Runtime(Runtime::FunctionId function, int arguments) {
+ const Operator* Runtime(Runtime::FunctionId function, int arguments) {
const Runtime::Function* f = Runtime::FunctionForId(function);
DCHECK(f->nargs == -1 || f->nargs == arguments);
OP1(JSCallRuntime, Runtime::FunctionId, function, Operator::kNoProperties,
return a == b;
}
};
-}
-}
-} // namespace v8::internal::compiler
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
#endif // V8_COMPILER_JS_OPERATOR_H_
// Remove all effect and control inputs and outputs to this node and change
// to the pure operator {op}, possibly inserting a boolean inversion.
- Reduction ChangeToPureOperator(Operator* op, bool invert = false) {
+ Reduction ChangeToPureOperator(const Operator* op, bool invert = false) {
DCHECK_EQ(0, OperatorProperties::GetEffectInputCount(op));
DCHECK_EQ(false, OperatorProperties::HasContextInput(op));
DCHECK_EQ(0, OperatorProperties::GetControlInputCount(op));
if (input_type->Is(type)) return node; // already in the value range.
- Operator* op = is_signed ? simplified()->NumberToInt32()
- : simplified()->NumberToUint32();
+ const Operator* op = is_signed ? simplified()->NumberToInt32()
+ : simplified()->NumberToUint32();
Node* n = graph()->NewNode(op, node);
return n;
}
}
-Reduction JSTypedLowering::ReduceNumberBinop(Node* node, Operator* numberOp) {
+Reduction JSTypedLowering::ReduceNumberBinop(Node* node,
+ const Operator* numberOp) {
JSBinopReduction r(this, node);
if (r.OneInputIs(Type::Primitive())) {
// If at least one input is a primitive, then insert appropriate conversions
Reduction JSTypedLowering::ReduceI32Binop(Node* node, bool left_signed,
- bool right_signed, Operator* intOp) {
+ bool right_signed,
+ const Operator* intOp) {
JSBinopReduction r(this, node);
// TODO(titzer): some Smi bitwise operations don't really require going
// all the way to int32, which can save tagging/untagging for some operations
Reduction JSTypedLowering::ReduceI32Shift(Node* node, bool left_signed,
- Operator* shift_op) {
+ const Operator* shift_op) {
JSBinopReduction r(this, node);
r.ConvertInputsForShift(left_signed);
return r.ChangeToPureOperator(shift_op);
JSBinopReduction r(this, node);
if (r.BothInputsAre(Type::String())) {
// If both inputs are definitely strings, perform a string comparison.
- Operator* stringOp;
+ const Operator* stringOp;
switch (node->opcode()) {
case IrOpcode::kJSLessThan:
stringOp = simplified()->StringLessThan();
return r.ChangeToPureOperator(stringOp);
} else if (r.OneInputCannotBe(Type::String())) {
// If one input cannot be a string, then emit a number comparison.
- Operator* less_than;
- Operator* less_than_or_equal;
+ const Operator* less_than;
+ const Operator* less_than_or_equal;
if (r.BothInputsAre(Type::Unsigned32())) {
less_than = machine()->Uint32LessThan();
less_than_or_equal = machine()->Uint32LessThanOrEqual();
less_than = simplified()->NumberLessThan();
less_than_or_equal = simplified()->NumberLessThanOrEqual();
}
- Operator* comparison;
+ const Operator* comparison;
switch (node->opcode()) {
case IrOpcode::kJSLessThan:
comparison = less_than;
Reduction ReduceJSToNumberInput(Node* input);
Reduction ReduceJSToStringInput(Node* input);
Reduction ReduceJSToBooleanInput(Node* input);
- Reduction ReduceNumberBinop(Node* node, Operator* numberOp);
+ Reduction ReduceNumberBinop(Node* node, const Operator* numberOp);
Reduction ReduceI32Binop(Node* node, bool left_signed, bool right_signed,
- Operator* intOp);
- Reduction ReduceI32Shift(Node* node, bool left_signed, Operator* shift_op);
+ const Operator* intOp);
+ Reduction ReduceI32Shift(Node* node, bool left_signed,
+ const Operator* shift_op);
JSOperatorBuilder* javascript() { return jsgraph_->javascript(); }
CommonOperatorBuilder* common() { return jsgraph_->common(); }
namespace {
struct UnaryOperator {
- Operator* (MachineOperatorBuilder::*constructor)();
+ const Operator* (MachineOperatorBuilder::*constructor)();
const char* constructor_name;
};
TEST_P(MachineOperatorCommonTest, ChangeInt32ToInt64) {
- Operator* op = machine()->ChangeInt32ToInt64();
+ const Operator* op = machine()->ChangeInt32ToInt64();
EXPECT_EQ(1, OperatorProperties::GetValueInputCount(op));
EXPECT_EQ(1, OperatorProperties::GetTotalInputCount(op));
EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
TEST_P(MachineOperatorCommonTest, ChangeUint32ToUint64) {
- Operator* op = machine()->ChangeUint32ToUint64();
+ const Operator* op = machine()->ChangeUint32ToUint64();
EXPECT_EQ(1, OperatorProperties::GetValueInputCount(op));
EXPECT_EQ(1, OperatorProperties::GetTotalInputCount(op));
EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
TEST_P(MachineOperatorCommonTest, TruncateFloat64ToInt32) {
- Operator* op = machine()->TruncateFloat64ToInt32();
+ const Operator* op = machine()->TruncateFloat64ToInt32();
EXPECT_EQ(1, OperatorProperties::GetValueInputCount(op));
EXPECT_EQ(1, OperatorProperties::GetTotalInputCount(op));
EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
TEST_P(MachineOperatorCommonTest, TruncateInt64ToInt32) {
- Operator* op = machine()->TruncateInt64ToInt32();
+ const Operator* op = machine()->TruncateInt64ToInt32();
EXPECT_EQ(1, OperatorProperties::GetValueInputCount(op));
EXPECT_EQ(1, OperatorProperties::GetTotalInputCount(op));
EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
#define WORD_SIZE(x) return is64() ? Word64##x() : Word32##x()
#define INT_SIZE(x) return is64() ? Int64##x() : Int32##x()
- Operator* Load(MachineType rep) { // load [base + index]
+ const Operator* Load(MachineType rep) { // load [base + index]
OP1(Load, MachineType, rep, Operator::kNoWrite, 2, 1);
}
// store [base + index], value
- Operator* Store(MachineType rep, WriteBarrierKind kind) {
+ const Operator* Store(MachineType rep, WriteBarrierKind kind) {
StoreRepresentation store_rep = {rep, kind};
OP1(Store, StoreRepresentation, store_rep, Operator::kNoRead, 3, 0);
}
- Operator* WordAnd() { WORD_SIZE(And); }
- Operator* WordOr() { WORD_SIZE(Or); }
- Operator* WordXor() { WORD_SIZE(Xor); }
- Operator* WordShl() { WORD_SIZE(Shl); }
- Operator* WordShr() { WORD_SIZE(Shr); }
- Operator* WordSar() { WORD_SIZE(Sar); }
- Operator* WordRor() { WORD_SIZE(Ror); }
- Operator* WordEqual() { WORD_SIZE(Equal); }
-
- Operator* Word32And() { BINOP_AC(Word32And); }
- Operator* Word32Or() { BINOP_AC(Word32Or); }
- Operator* Word32Xor() { BINOP_AC(Word32Xor); }
- Operator* Word32Shl() { BINOP(Word32Shl); }
- Operator* Word32Shr() { BINOP(Word32Shr); }
- Operator* Word32Sar() { BINOP(Word32Sar); }
- Operator* Word32Ror() { BINOP(Word32Ror); }
- Operator* Word32Equal() { BINOP_C(Word32Equal); }
-
- Operator* Word64And() { BINOP_AC(Word64And); }
- Operator* Word64Or() { BINOP_AC(Word64Or); }
- Operator* Word64Xor() { BINOP_AC(Word64Xor); }
- Operator* Word64Shl() { BINOP(Word64Shl); }
- Operator* Word64Shr() { BINOP(Word64Shr); }
- Operator* Word64Sar() { BINOP(Word64Sar); }
- Operator* Word64Ror() { BINOP(Word64Ror); }
- Operator* Word64Equal() { BINOP_C(Word64Equal); }
-
- Operator* Int32Add() { BINOP_AC(Int32Add); }
- Operator* Int32AddWithOverflow() { BINOP_ACO(Int32AddWithOverflow); }
- Operator* Int32Sub() { BINOP(Int32Sub); }
- Operator* Int32SubWithOverflow() { BINOP_O(Int32SubWithOverflow); }
- Operator* Int32Mul() { BINOP_AC(Int32Mul); }
- Operator* Int32Div() { BINOP(Int32Div); }
- Operator* Int32UDiv() { BINOP(Int32UDiv); }
- Operator* Int32Mod() { BINOP(Int32Mod); }
- Operator* Int32UMod() { BINOP(Int32UMod); }
- Operator* Int32LessThan() { BINOP(Int32LessThan); }
- Operator* Int32LessThanOrEqual() { BINOP(Int32LessThanOrEqual); }
- Operator* Uint32LessThan() { BINOP(Uint32LessThan); }
- Operator* Uint32LessThanOrEqual() { BINOP(Uint32LessThanOrEqual); }
-
- Operator* Int64Add() { BINOP_AC(Int64Add); }
- Operator* Int64Sub() { BINOP(Int64Sub); }
- Operator* Int64Mul() { BINOP_AC(Int64Mul); }
- Operator* Int64Div() { BINOP(Int64Div); }
- Operator* Int64UDiv() { BINOP(Int64UDiv); }
- Operator* Int64Mod() { BINOP(Int64Mod); }
- Operator* Int64UMod() { BINOP(Int64UMod); }
- Operator* Int64LessThan() { BINOP(Int64LessThan); }
- Operator* Int64LessThanOrEqual() { BINOP(Int64LessThanOrEqual); }
+ const Operator* WordAnd() { WORD_SIZE(And); }
+ const Operator* WordOr() { WORD_SIZE(Or); }
+ const Operator* WordXor() { WORD_SIZE(Xor); }
+ const Operator* WordShl() { WORD_SIZE(Shl); }
+ const Operator* WordShr() { WORD_SIZE(Shr); }
+ const Operator* WordSar() { WORD_SIZE(Sar); }
+ const Operator* WordRor() { WORD_SIZE(Ror); }
+ const Operator* WordEqual() { WORD_SIZE(Equal); }
+
+ const Operator* Word32And() { BINOP_AC(Word32And); }
+ const Operator* Word32Or() { BINOP_AC(Word32Or); }
+ const Operator* Word32Xor() { BINOP_AC(Word32Xor); }
+ const Operator* Word32Shl() { BINOP(Word32Shl); }
+ const Operator* Word32Shr() { BINOP(Word32Shr); }
+ const Operator* Word32Sar() { BINOP(Word32Sar); }
+ const Operator* Word32Ror() { BINOP(Word32Ror); }
+ const Operator* Word32Equal() { BINOP_C(Word32Equal); }
+
+ const Operator* Word64And() { BINOP_AC(Word64And); }
+ const Operator* Word64Or() { BINOP_AC(Word64Or); }
+ const Operator* Word64Xor() { BINOP_AC(Word64Xor); }
+ const Operator* Word64Shl() { BINOP(Word64Shl); }
+ const Operator* Word64Shr() { BINOP(Word64Shr); }
+ const Operator* Word64Sar() { BINOP(Word64Sar); }
+ const Operator* Word64Ror() { BINOP(Word64Ror); }
+ const Operator* Word64Equal() { BINOP_C(Word64Equal); }
+
+ const Operator* Int32Add() { BINOP_AC(Int32Add); }
+ const Operator* Int32AddWithOverflow() { BINOP_ACO(Int32AddWithOverflow); }
+ const Operator* Int32Sub() { BINOP(Int32Sub); }
+ const Operator* Int32SubWithOverflow() { BINOP_O(Int32SubWithOverflow); }
+ const Operator* Int32Mul() { BINOP_AC(Int32Mul); }
+ const Operator* Int32Div() { BINOP(Int32Div); }
+ const Operator* Int32UDiv() { BINOP(Int32UDiv); }
+ const Operator* Int32Mod() { BINOP(Int32Mod); }
+ const Operator* Int32UMod() { BINOP(Int32UMod); }
+ const Operator* Int32LessThan() { BINOP(Int32LessThan); }
+ const Operator* Int32LessThanOrEqual() { BINOP(Int32LessThanOrEqual); }
+ const Operator* Uint32LessThan() { BINOP(Uint32LessThan); }
+ const Operator* Uint32LessThanOrEqual() { BINOP(Uint32LessThanOrEqual); }
+
+ const Operator* Int64Add() { BINOP_AC(Int64Add); }
+ const Operator* Int64Sub() { BINOP(Int64Sub); }
+ const Operator* Int64Mul() { BINOP_AC(Int64Mul); }
+ const Operator* Int64Div() { BINOP(Int64Div); }
+ const Operator* Int64UDiv() { BINOP(Int64UDiv); }
+ const Operator* Int64Mod() { BINOP(Int64Mod); }
+ const Operator* Int64UMod() { BINOP(Int64UMod); }
+ const Operator* Int64LessThan() { BINOP(Int64LessThan); }
+ const Operator* Int64LessThanOrEqual() { BINOP(Int64LessThanOrEqual); }
// Signed comparison of word-sized integer values, translates to int32/int64
// comparisons depending on the word-size of the machine.
- Operator* IntLessThan() { INT_SIZE(LessThan); }
- Operator* IntLessThanOrEqual() { INT_SIZE(LessThanOrEqual); }
+ const Operator* IntLessThan() { INT_SIZE(LessThan); }
+ const Operator* IntLessThanOrEqual() { INT_SIZE(LessThanOrEqual); }
// Convert representation of integers between float64 and int32/uint32.
// The precise rounding mode and handling of out of range inputs are *not*
// defined for these operators, since they are intended only for use with
// integers.
- Operator* ChangeInt32ToFloat64() { UNOP(ChangeInt32ToFloat64); }
- Operator* ChangeUint32ToFloat64() { UNOP(ChangeUint32ToFloat64); }
- Operator* ChangeFloat64ToInt32() { UNOP(ChangeFloat64ToInt32); }
- Operator* ChangeFloat64ToUint32() { UNOP(ChangeFloat64ToUint32); }
+ const Operator* ChangeInt32ToFloat64() { UNOP(ChangeInt32ToFloat64); }
+ const Operator* ChangeUint32ToFloat64() { UNOP(ChangeUint32ToFloat64); }
+ const Operator* ChangeFloat64ToInt32() { UNOP(ChangeFloat64ToInt32); }
+ const Operator* ChangeFloat64ToUint32() { UNOP(ChangeFloat64ToUint32); }
// Sign/zero extend int32/uint32 to int64/uint64.
- Operator* ChangeInt32ToInt64() { UNOP(ChangeInt32ToInt64); }
- Operator* ChangeUint32ToUint64() { UNOP(ChangeUint32ToUint64); }
+ const Operator* ChangeInt32ToInt64() { UNOP(ChangeInt32ToInt64); }
+ const Operator* ChangeUint32ToUint64() { UNOP(ChangeUint32ToUint64); }
// Truncate double to int32 using JavaScript semantics.
- Operator* TruncateFloat64ToInt32() { UNOP(TruncateFloat64ToInt32); }
+ const Operator* TruncateFloat64ToInt32() { UNOP(TruncateFloat64ToInt32); }
// Truncate the high order bits and convert the remaining bits to int32.
- Operator* TruncateInt64ToInt32() { UNOP(TruncateInt64ToInt32); }
+ const Operator* TruncateInt64ToInt32() { UNOP(TruncateInt64ToInt32); }
// Floating point operators always operate with IEEE 754 round-to-nearest.
- Operator* Float64Add() { BINOP_C(Float64Add); }
- Operator* Float64Sub() { BINOP(Float64Sub); }
- Operator* Float64Mul() { BINOP_C(Float64Mul); }
- Operator* Float64Div() { BINOP(Float64Div); }
- Operator* Float64Mod() { BINOP(Float64Mod); }
+ const Operator* Float64Add() { BINOP_C(Float64Add); }
+ const Operator* Float64Sub() { BINOP(Float64Sub); }
+ const Operator* Float64Mul() { BINOP_C(Float64Mul); }
+ const Operator* Float64Div() { BINOP(Float64Div); }
+ const Operator* Float64Mod() { BINOP(Float64Mod); }
// Floating point comparisons complying to IEEE 754.
- Operator* Float64Equal() { BINOP_C(Float64Equal); }
- Operator* Float64LessThan() { BINOP(Float64LessThan); }
- Operator* Float64LessThanOrEqual() { BINOP(Float64LessThanOrEqual); }
+ const Operator* Float64Equal() { BINOP_C(Float64Equal); }
+ const Operator* Float64LessThan() { BINOP(Float64LessThan); }
+ const Operator* Float64LessThanOrEqual() { BINOP(Float64LessThanOrEqual); }
inline bool is32() const { return word_ == kRepWord32; }
inline bool is64() const { return word_ == kRepWord64; }
Zone* zone_;
MachineType word_;
};
-}
-}
-} // namespace v8::internal::compiler
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
#endif // V8_COMPILER_MACHINE_OPERATOR_H_
}
-Node* RawMachineAssembler::MakeNode(Operator* op, int input_count,
+Node* RawMachineAssembler::MakeNode(const Operator* op, int input_count,
Node** inputs) {
DCHECK(ScheduleValid());
DCHECK(current_block_ != NULL);
Schedule* Export();
protected:
- virtual Node* MakeNode(Operator* op, int input_count, Node** inputs);
+ virtual Node* MakeNode(const Operator* op, int input_count,
+ Node** inputs) FINAL;
bool ScheduleValid() { return schedule_ != NULL; }
break;
}
// Select the correct X -> Tagged operator.
- Operator* op;
+ const Operator* op;
if (output_type & kRepBit) {
op = simplified()->ChangeBitToBool();
} else if (output_type & rWord) {
break;
}
// Select the correct X -> Float64 operator.
- Operator* op;
+ const Operator* op;
if (output_type & kRepBit) {
return TypeError(node, output_type, kRepFloat64);
} else if (output_type & rWord) {
break;
}
// Select the correct X -> Word32 operator.
- Operator* op = NULL;
+ const Operator* op = NULL;
if (output_type & kRepFloat64) {
if (output_type & kTypeUint32 || use_unsigned) {
op = machine()->ChangeFloat64ToUint32();
break;
}
// Select the correct X -> Bit operator.
- Operator* op;
+ const Operator* op;
if (output_type & rWord) {
return node; // No change necessary.
} else if (output_type & kRepWord64) {
return TypeError(node, output_type, kRepWord64);
}
- Operator* Int32OperatorFor(IrOpcode::Value opcode) {
+ const Operator* Int32OperatorFor(IrOpcode::Value opcode) {
switch (opcode) {
case IrOpcode::kNumberAdd:
return machine()->Int32Add();
}
}
- Operator* Uint32OperatorFor(IrOpcode::Value opcode) {
+ const Operator* Uint32OperatorFor(IrOpcode::Value opcode) {
switch (opcode) {
case IrOpcode::kNumberAdd:
return machine()->Int32Add();
}
}
- Operator* Float64OperatorFor(IrOpcode::Value opcode) {
+ const Operator* Float64OperatorFor(IrOpcode::Value opcode) {
switch (opcode) {
case IrOpcode::kNumberAdd:
return machine()->Float64Add();
}
}
- Operator* Int32Op(Node* node) {
+ const Operator* Int32Op(Node* node) {
return changer_->Int32OperatorFor(node->opcode());
}
- Operator* Uint32Op(Node* node) {
+ const Operator* Uint32Op(Node* node) {
return changer_->Uint32OperatorFor(node->opcode());
}
- Operator* Float64Op(Node* node) {
+ const Operator* Float64Op(Node* node) {
return changer_->Float64OperatorFor(node->opcode());
}
namespace {
struct UnaryOperator {
- Operator* (SimplifiedOperatorBuilder::*constructor)() const;
+ const Operator* (SimplifiedOperatorBuilder::*constructor)() const;
const char* constructor_name;
};
}
-Reduction SimplifiedOperatorReducer::Change(Node* node, Operator* op, Node* a) {
+Reduction SimplifiedOperatorReducer::Change(Node* node, const Operator* op,
+ Node* a) {
node->set_op(op);
node->ReplaceInput(0, a);
return Changed(node);
virtual Reduction Reduce(Node* node) OVERRIDE;
private:
- Reduction Change(Node* node, Operator* op, Node* a);
+ Reduction Change(Node* node, const Operator* op, Node* a);
Reduction ReplaceFloat64(double value);
Reduction ReplaceInt32(int32_t value);
Reduction ReplaceUint32(uint32_t value) {
#define UNOP(name) SIMPLE(name, Operator::kPure, 1, 1)
#define BINOP(name) SIMPLE(name, Operator::kPure, 2, 1)
- Operator* BooleanNot() const { UNOP(BooleanNot); }
-
- Operator* NumberEqual() const { BINOP(NumberEqual); }
- Operator* NumberLessThan() const { BINOP(NumberLessThan); }
- Operator* NumberLessThanOrEqual() const { BINOP(NumberLessThanOrEqual); }
- Operator* NumberAdd() const { BINOP(NumberAdd); }
- Operator* NumberSubtract() const { BINOP(NumberSubtract); }
- Operator* NumberMultiply() const { BINOP(NumberMultiply); }
- Operator* NumberDivide() const { BINOP(NumberDivide); }
- Operator* NumberModulus() const { BINOP(NumberModulus); }
- Operator* NumberToInt32() const { UNOP(NumberToInt32); }
- Operator* NumberToUint32() const { UNOP(NumberToUint32); }
-
- Operator* ReferenceEqual(Type* type) const { BINOP(ReferenceEqual); }
-
- Operator* StringEqual() const { BINOP(StringEqual); }
- Operator* StringLessThan() const { BINOP(StringLessThan); }
- Operator* StringLessThanOrEqual() const { BINOP(StringLessThanOrEqual); }
- Operator* StringAdd() const { BINOP(StringAdd); }
-
- Operator* ChangeTaggedToInt32() const { UNOP(ChangeTaggedToInt32); }
- Operator* ChangeTaggedToUint32() const { UNOP(ChangeTaggedToUint32); }
- Operator* ChangeTaggedToFloat64() const { UNOP(ChangeTaggedToFloat64); }
- Operator* ChangeInt32ToTagged() const { UNOP(ChangeInt32ToTagged); }
- Operator* ChangeUint32ToTagged() const { UNOP(ChangeUint32ToTagged); }
- Operator* ChangeFloat64ToTagged() const { UNOP(ChangeFloat64ToTagged); }
- Operator* ChangeBoolToBit() const { UNOP(ChangeBoolToBit); }
- Operator* ChangeBitToBool() const { UNOP(ChangeBitToBool); }
-
- Operator* LoadField(const FieldAccess& access) const {
+ const Operator* BooleanNot() const { UNOP(BooleanNot); }
+
+ const Operator* NumberEqual() const { BINOP(NumberEqual); }
+ const Operator* NumberLessThan() const { BINOP(NumberLessThan); }
+ const Operator* NumberLessThanOrEqual() const {
+ BINOP(NumberLessThanOrEqual);
+ }
+ const Operator* NumberAdd() const { BINOP(NumberAdd); }
+ const Operator* NumberSubtract() const { BINOP(NumberSubtract); }
+ const Operator* NumberMultiply() const { BINOP(NumberMultiply); }
+ const Operator* NumberDivide() const { BINOP(NumberDivide); }
+ const Operator* NumberModulus() const { BINOP(NumberModulus); }
+ const Operator* NumberToInt32() const { UNOP(NumberToInt32); }
+ const Operator* NumberToUint32() const { UNOP(NumberToUint32); }
+
+ const Operator* ReferenceEqual(Type* type) const { BINOP(ReferenceEqual); }
+
+ const Operator* StringEqual() const { BINOP(StringEqual); }
+ const Operator* StringLessThan() const { BINOP(StringLessThan); }
+ const Operator* StringLessThanOrEqual() const {
+ BINOP(StringLessThanOrEqual);
+ }
+ const Operator* StringAdd() const { BINOP(StringAdd); }
+
+ const Operator* ChangeTaggedToInt32() const { UNOP(ChangeTaggedToInt32); }
+ const Operator* ChangeTaggedToUint32() const { UNOP(ChangeTaggedToUint32); }
+ const Operator* ChangeTaggedToFloat64() const { UNOP(ChangeTaggedToFloat64); }
+ const Operator* ChangeInt32ToTagged() const { UNOP(ChangeInt32ToTagged); }
+ const Operator* ChangeUint32ToTagged() const { UNOP(ChangeUint32ToTagged); }
+ const Operator* ChangeFloat64ToTagged() const { UNOP(ChangeFloat64ToTagged); }
+ const Operator* ChangeBoolToBit() const { UNOP(ChangeBoolToBit); }
+ const Operator* ChangeBitToBool() const { UNOP(ChangeBitToBool); }
+
+ const Operator* LoadField(const FieldAccess& access) const {
OP1(LoadField, FieldAccess, access, Operator::kNoWrite, 1, 1);
}
- Operator* StoreField(const FieldAccess& access) const {
+ const Operator* StoreField(const FieldAccess& access) const {
OP1(StoreField, FieldAccess, access, Operator::kNoRead, 2, 0);
}
- Operator* LoadElement(const ElementAccess& access) const {
+ const Operator* LoadElement(const ElementAccess& access) const {
OP1(LoadElement, ElementAccess, access, Operator::kNoWrite, 2, 1);
}
- Operator* StoreElement(const ElementAccess& access) const {
+ const Operator* StoreElement(const ElementAccess& access) const {
OP1(StoreElement, ElementAccess, access, Operator::kNoRead, 3, 0);
}
return m->NewNode(op(m->machine()), a, b);
}
- Operator* op(MachineOperatorBuilder* machine) {
+ const Operator* op(MachineOperatorBuilder* machine) {
switch (opcode) {
case IrOpcode::kWord32Equal:
return machine->Word32Equal();
virtual ~DirectGraphBuilder() {}
protected:
- virtual Node* MakeNode(Operator* op, int value_input_count,
- Node** value_inputs) {
+ virtual Node* MakeNode(const Operator* op, int value_input_count,
+ Node** value_inputs) FINAL {
return graph()->NewNode(op, value_input_count, value_inputs);
}
};
}
-Node* SimplifiedGraphBuilder::MakeNode(Operator* op, int value_input_count,
+Node* SimplifiedGraphBuilder::MakeNode(const Operator* op,
+ int value_input_count,
Node** value_inputs) {
DCHECK(op->InputCount() == value_input_count);
}
protected:
- virtual Node* MakeNode(Operator* op, int value_input_count,
- Node** value_inputs);
+ virtual Node* MakeNode(const Operator* op, int value_input_count,
+ Node** value_inputs) FINAL;
private:
Node* effect_;
CHECK(this->isolate()->factory()->NewNumber(expected)->SameValue(number));
}
- void BuildAndLower(Operator* op) {
+ void BuildAndLower(const Operator* op) {
// We build a graph by hand here, because the raw machine assembler
// does not add the correct control and effect nodes.
Node* p0 = this->Parameter(0);
LowerChange(change);
}
- void BuildStoreAndLower(Operator* op, Operator* store_op, void* location) {
+ void BuildStoreAndLower(const Operator* op, const Operator* store_op,
+ void* location) {
// We build a graph by hand here, because the raw machine assembler
// does not add the correct control and effect nodes.
Node* p0 = this->Parameter(0);
LowerChange(change);
}
- void BuildLoadAndLower(Operator* op, Operator* load_op, void* location) {
+ void BuildLoadAndLower(const Operator* op, const Operator* load_op,
+ void* location) {
// We build a graph by hand here, because the raw machine assembler
// does not add the correct control and effect nodes.
Node* load =
}
Isolate* isolate;
- Operator* binop;
- Operator* unop;
+ const Operator* binop;
+ const Operator* unop;
JSOperatorBuilder javascript;
MachineOperatorBuilder machine;
SimplifiedOperatorBuilder simplified;
CHECK_EQ(2, node->InputCount()); // should not have context, effect, etc.
}
- void CheckPureBinop(Operator* expected, Node* node) {
+ void CheckPureBinop(const Operator* expected, Node* node) {
CHECK_EQ(expected->opcode(), node->op()->opcode());
CHECK_EQ(2, node->InputCount()); // should not have context, effect, etc.
}
- Node* ReduceUnop(Operator* op, Type* input_type) {
+ Node* ReduceUnop(const Operator* op, Type* input_type) {
return reduce(Unop(op, Parameter(input_type)));
}
- Node* ReduceBinop(Operator* op, Type* left_type, Type* right_type) {
+ Node* ReduceBinop(const Operator* op, Type* left_type, Type* right_type) {
return reduce(Binop(op, Parameter(left_type, 0), Parameter(right_type, 1)));
}
- Node* Binop(Operator* op, Node* left, Node* right) {
+ Node* Binop(const Operator* op, Node* left, Node* right) {
// JS binops also require context, effect, and control
return graph.NewNode(op, left, right, context(), start(), control());
}
- Node* Unop(Operator* op, Node* input) {
+ Node* Unop(const Operator* op, Node* input) {
// JS unops also require context, effect, and control
return graph.NewNode(op, input, context(), start(), control());
}
TEST(NumberBinops) {
JSTypedLoweringTester R;
- Operator* ops[] = {
+ const Operator* ops[] = {
R.javascript.Add(), R.simplified.NumberAdd(),
R.javascript.Subtract(), R.simplified.NumberSubtract(),
R.javascript.Multiply(), R.simplified.NumberMultiply(),
class JSBitwiseShiftTypedLoweringTester : public JSTypedLoweringTester {
public:
static const int kNumberOps = 6;
- Operator* ops[kNumberOps];
+ const Operator* ops[kNumberOps];
bool signedness[kNumberOps];
JSBitwiseShiftTypedLoweringTester() {
}
private:
- void set(int idx, Operator* op, bool s) {
+ void set(int idx, const Operator* op, bool s) {
ops[idx] = op;
signedness[idx] = s;
}
class JSBitwiseTypedLoweringTester : public JSTypedLoweringTester {
public:
static const int kNumberOps = 6;
- Operator* ops[kNumberOps];
+ const Operator* ops[kNumberOps];
bool signedness[kNumberOps];
JSBitwiseTypedLoweringTester() {
}
private:
- void set(int idx, Operator* op, bool s) {
+ void set(int idx, const Operator* op, bool s) {
ops[idx] = op;
signedness[idx] = s;
}
TEST(JSToNumber1) {
JSTypedLoweringTester R;
- Operator* ton = R.javascript.ToNumber();
+ const Operator* ton = R.javascript.ToNumber();
for (size_t i = 0; i < arraysize(kNumberTypes); i++) { // ToNumber(number)
Node* r = R.ReduceUnop(ton, kNumberTypes[i]);
TEST(JSToNumberOfConstant) {
JSTypedLoweringTester R;
- Operator* ops[] = {R.common.NumberConstant(0), R.common.NumberConstant(-1),
- R.common.NumberConstant(0.1), R.common.Int32Constant(1177),
- R.common.Float64Constant(0.99)};
+ const Operator* ops[] = {
+ R.common.NumberConstant(0), R.common.NumberConstant(-1),
+ R.common.NumberConstant(0.1), R.common.Int32Constant(1177),
+ R.common.Float64Constant(0.99)};
for (size_t i = 0; i < arraysize(ops); i++) {
Node* n = R.graph.NewNode(ops[i]);
TEST(JSToBoolean) {
JSTypedLoweringTester R;
- Operator* op = R.javascript.ToBoolean();
+ const Operator* op = R.javascript.ToBoolean();
{ // ToBoolean(undefined)
Node* r = R.ReduceUnop(op, Type::Undefined());
CHECK_EQ(IrOpcode::kParameter, r->opcode());
}
- Operator* op = R.javascript.ToString();
+ const Operator* op = R.javascript.ToString();
{ // ToString(undefined) => "undefined"
Node* r = R.ReduceUnop(op, Type::Undefined());
TEST(StringComparison) {
JSTypedLoweringTester R;
- Operator* ops[] = {
+ const Operator* ops[] = {
R.javascript.LessThan(), R.simplified.StringLessThan(),
R.javascript.LessThanOrEqual(), R.simplified.StringLessThanOrEqual(),
R.javascript.GreaterThan(), R.simplified.StringLessThan(),
TEST(NumberComparison) {
JSTypedLoweringTester R;
- Operator* ops[] = {
+ const Operator* ops[] = {
R.javascript.LessThan(), R.simplified.NumberLessThan(),
R.javascript.LessThanOrEqual(), R.simplified.NumberLessThanOrEqual(),
R.javascript.GreaterThan(), R.simplified.NumberLessThan(),
TEST(UnaryNot) {
JSTypedLoweringTester R;
- Operator* opnot = R.javascript.UnaryNot();
+ const Operator* opnot = R.javascript.UnaryNot();
for (size_t i = 0; i < arraysize(kJSTypes); i++) {
Node* orig = R.Unop(opnot, R.Parameter(kJSTypes[i]));
// Helper class for testing the reduction of a single binop.
class BinopEffectsTester {
public:
- explicit BinopEffectsTester(Operator* op, Type* t0, Type* t1)
+ explicit BinopEffectsTester(const Operator* op, Type* t0, Type* t1)
: R(),
p0(R.Parameter(t0, 0)),
p1(R.Parameter(t1, 1)),
TEST(RemovePureNumberBinopEffects) {
JSTypedLoweringTester R;
- Operator* ops[] = {
+ const Operator* ops[] = {
R.javascript.Equal(), R.simplified.NumberEqual(),
R.javascript.Add(), R.simplified.NumberAdd(),
R.javascript.Subtract(), R.simplified.NumberSubtract(),
TEST(OrderNumberBinopEffects1) {
JSTypedLoweringTester R;
- Operator* ops[] = {
+ const Operator* ops[] = {
R.javascript.Subtract(), R.simplified.NumberSubtract(),
R.javascript.Multiply(), R.simplified.NumberMultiply(),
R.javascript.Divide(), R.simplified.NumberDivide(),
TEST(OrderNumberBinopEffects2) {
JSTypedLoweringTester R;
- Operator* ops[] = {
+ const Operator* ops[] = {
R.javascript.Add(), R.simplified.NumberAdd(),
R.javascript.Subtract(), R.simplified.NumberSubtract(),
R.javascript.Multiply(), R.simplified.NumberMultiply(),
TEST(OrderCompareEffects) {
JSTypedLoweringTester R;
- Operator* ops[] = {
+ const Operator* ops[] = {
R.javascript.GreaterThan(), R.simplified.NumberLessThan(),
R.javascript.GreaterThanOrEqual(), R.simplified.NumberLessThanOrEqual(),
};
TEST(UnaryNotEffects) {
JSTypedLoweringTester R;
- Operator* opnot = R.javascript.UnaryNot();
+ const Operator* opnot = R.javascript.UnaryNot();
for (size_t i = 0; i < arraysize(kJSTypes); i++) {
Node* p0 = R.Parameter(kJSTypes[i], 0);
JSTypedLoweringTester R;
struct Entry {
- Operator* js_op;
- Operator* uint_op;
- Operator* int_op;
- Operator* num_op;
+ const Operator* js_op;
+ const Operator* uint_op;
+ const Operator* int_op;
+ const Operator* num_op;
bool commute;
};
Node* cmp = R.Binop(ops[o].js_op, p0, p1);
Node* r = R.reduce(cmp);
- Operator* expected;
+ const Operator* expected;
if (t0->Is(Type::Unsigned32()) && t1->Is(Type::Unsigned32())) {
expected = ops[o].uint_op;
} else if (t0->Is(Type::Signed32()) && t1->Is(Type::Signed32())) {
using namespace v8::internal::compiler;
template <typename T>
-Operator* NewConstantOperator(CommonOperatorBuilder* common, volatile T value);
+const Operator* NewConstantOperator(CommonOperatorBuilder* common,
+ volatile T value);
template <>
-Operator* NewConstantOperator<int32_t>(CommonOperatorBuilder* common,
- volatile int32_t value) {
+const Operator* NewConstantOperator<int32_t>(CommonOperatorBuilder* common,
+ volatile int32_t value) {
return common->Int32Constant(value);
}
template <>
-Operator* NewConstantOperator<double>(CommonOperatorBuilder* common,
- volatile double value) {
+const Operator* NewConstantOperator<double>(CommonOperatorBuilder* common,
+ volatile double value) {
return common->Float64Constant(value);
}
}
Isolate* isolate;
- Operator* binop;
- Operator* unop;
+ const Operator* binop;
+ const Operator* unop;
MachineOperatorBuilder machine;
CommonOperatorBuilder common;
Graph graph;
// Check that the reduction of this binop applied to {left} and {right} yields
// the {op_expect} applied to {left_expect} and {right_expect}.
template <typename T>
- void CheckFoldBinop(volatile T left_expect, Operator* op_expect,
+ void CheckFoldBinop(volatile T left_expect, const Operator* op_expect,
Node* right_expect, Node* left, Node* right) {
CHECK_NE(NULL, binop);
Node* n = graph.NewNode(binop, left, right);
// Check that the reduction of this binop applied to {left} and {right} yields
// the {op_expect} applied to {left_expect} and {right_expect}.
template <typename T>
- void CheckFoldBinop(Node* left_expect, Operator* op_expect,
+ void CheckFoldBinop(Node* left_expect, const Operator* op_expect,
volatile T right_expect, Node* left, Node* right) {
CHECK_NE(NULL, binop);
Node* n = graph.NewNode(binop, left, right);
TEST(CodeGenInt32Binop) {
RawMachineAssemblerTester<void> m;
- Operator* ops[] = {
+ const Operator* ops[] = {
m.machine()->Word32And(), m.machine()->Word32Or(),
m.machine()->Word32Xor(), m.machine()->Word32Shl(),
m.machine()->Word32Shr(), m.machine()->Word32Sar(),
}
{
RawMachineAssemblerTester<void> m;
- Operator* shops[] = {m.machine()->Word32Sar(), m.machine()->Word32Shl(),
- m.machine()->Word32Shr()};
+ const Operator* shops[] = {m.machine()->Word32Sar(),
+ m.machine()->Word32Shl(),
+ m.machine()->Word32Shr()};
for (size_t n = 0; n < arraysize(shops); n++) {
RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32,
kMachUint32);
}
{
RawMachineAssemblerTester<void> m;
- Operator* shops[] = {m.machine()->Word32Sar(), m.machine()->Word32Shl(),
- m.machine()->Word32Shr()};
+ const Operator* shops[] = {m.machine()->Word32Sar(),
+ m.machine()->Word32Shl(),
+ m.machine()->Word32Shr()};
for (size_t n = 0; n < arraysize(shops); n++) {
RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32,
kMachUint32);
}
{
RawMachineAssemblerTester<void> m;
- Operator* shops[] = {m.machine()->Word32Sar(), m.machine()->Word32Shl(),
- m.machine()->Word32Shr()};
+ const Operator* shops[] = {m.machine()->Word32Sar(),
+ m.machine()->Word32Shl(),
+ m.machine()->Word32Shr()};
for (size_t n = 0; n < arraysize(shops); n++) {
RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32,
kMachUint32);
}
{
RawMachineAssemblerTester<void> m;
- Operator* shops[] = {m.machine()->Word32Sar(), m.machine()->Word32Shl(),
- m.machine()->Word32Shr()};
+ const Operator* shops[] = {m.machine()->Word32Sar(),
+ m.machine()->Word32Shl(),
+ m.machine()->Word32Shr()};
for (size_t n = 0; n < arraysize(shops); n++) {
RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32,
kMachUint32);
}
{
RawMachineAssemblerTester<void> m;
- Operator* shops[] = {m.machine()->Word32Sar(), m.machine()->Word32Shl(),
- m.machine()->Word32Shr()};
+ const Operator* shops[] = {m.machine()->Word32Sar(),
+ m.machine()->Word32Shl(),
+ m.machine()->Word32Shr()};
for (size_t n = 0; n < arraysize(shops); n++) {
RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32,
kMachUint32);
}
{
RawMachineAssemblerTester<void> m;
- Operator* shops[] = {m.machine()->Word32Sar(), m.machine()->Word32Shl(),
- m.machine()->Word32Shr()};
+ const Operator* shops[] = {m.machine()->Word32Sar(),
+ m.machine()->Word32Shl(),
+ m.machine()->Word32Shr()};
for (size_t n = 0; n < arraysize(shops); n++) {
RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32,
kMachUint32);
}
{
RawMachineAssemblerTester<void> m;
- Operator* shops[] = {m.machine()->Word32Sar(), m.machine()->Word32Shl(),
- m.machine()->Word32Shr()};
+ const Operator* shops[] = {m.machine()->Word32Sar(),
+ m.machine()->Word32Shl(),
+ m.machine()->Word32Shr()};
for (size_t n = 0; n < arraysize(shops); n++) {
RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32,
kMachUint32);
TEST(RunDeadInt32Binops) {
RawMachineAssemblerTester<int32_t> m;
- Operator* ops[] = {
+ const Operator* ops[] = {
m.machine()->Word32And(), m.machine()->Word32Or(),
m.machine()->Word32Xor(), m.machine()->Word32Shl(),
m.machine()->Word32Shr(), m.machine()->Word32Sar(),
RawMachineAssemblerTester<int32_t> m;
double result;
- Operator* ops[] = {m.machine()->Float64Add(), m.machine()->Float64Sub(),
- m.machine()->Float64Mul(), m.machine()->Float64Div(),
- m.machine()->Float64Mod(), NULL};
+ const Operator* ops[] = {m.machine()->Float64Add(), m.machine()->Float64Sub(),
+ m.machine()->Float64Mul(), m.machine()->Float64Div(),
+ m.machine()->Float64Mod(), NULL};
double inf = V8_INFINITY;
- Operator* inputs[] = {
+ const Operator* inputs[] = {
m.common()->Float64Constant(0), m.common()->Float64Constant(1),
m.common()->Float64Constant(1), m.common()->Float64Constant(0),
m.common()->Float64Constant(0), m.common()->Float64Constant(-1),
TEST(RunDeadFloat64Binops) {
RawMachineAssemblerTester<int32_t> m;
- Operator* ops[] = {m.machine()->Float64Add(), m.machine()->Float64Sub(),
- m.machine()->Float64Mul(), m.machine()->Float64Div(),
- m.machine()->Float64Mod(), NULL};
+ const Operator* ops[] = {m.machine()->Float64Add(), m.machine()->Float64Sub(),
+ m.machine()->Float64Mul(), m.machine()->Float64Div(),
+ m.machine()->Float64Mod(), NULL};
for (int i = 0; ops[i] != NULL; i++) {
RawMachineAssemblerTester<int32_t> m;
TEST(RunFloat64UnorderedCompare) {
RawMachineAssemblerTester<int32_t> m;
- Operator* operators[] = {m.machine()->Float64Equal(),
- m.machine()->Float64LessThan(),
- m.machine()->Float64LessThanOrEqual()};
+ const Operator* operators[] = {m.machine()->Float64Equal(),
+ m.machine()->Float64LessThan(),
+ m.machine()->Float64LessThanOrEqual()};
double nan = v8::base::OS::nan_value();
Graph graph(scope.main_zone());
CommonOperatorBuilder common_builder(scope.main_zone());
JSOperatorBuilder js_builder(scope.main_zone());
- Operator* op;
+ const Operator* op;
Handle<Object> object =
Handle<Object>(isolate->heap()->undefined_value(), isolate);
Graph graph(scope.main_zone());
CommonOperatorBuilder common_builder(scope.main_zone());
JSOperatorBuilder js_builder(scope.main_zone());
- Operator* op;
+ const Operator* op;
Handle<Object> object =
Handle<Object>(isolate->heap()->undefined_value(), isolate);
Graph graph(scope.main_zone());
CommonOperatorBuilder common_builder(scope.main_zone());
JSOperatorBuilder js_builder(scope.main_zone());
- Operator* op;
+ const Operator* op;
Handle<Object> object =
Handle<Object>(isolate->heap()->undefined_value(), isolate);
Graph graph(scope.main_zone());
CommonOperatorBuilder common_builder(scope.main_zone());
JSOperatorBuilder js_builder(scope.main_zone());
- Operator* op;
+ const Operator* op;
Handle<Object> object =
Handle<Object>(isolate->heap()->undefined_value(), isolate);
CommonOperatorBuilder common_builder(scope.main_zone());
JSOperatorBuilder js_builder(scope.main_zone());
MachineOperatorBuilder machine_builder(scope.main_zone());
- Operator* op;
+ const Operator* op;
Handle<Object> object =
Handle<Object>(isolate->heap()->undefined_value(), isolate);
NodeProperties::SetBounds(p1, Bounds(p1_type));
}
- void CheckLoweringBinop(IrOpcode::Value expected, Operator* op) {
+ void CheckLoweringBinop(IrOpcode::Value expected, const Operator* op) {
Node* node = Return(graph()->NewNode(op, p0, p1));
Lower();
CHECK_EQ(expected, node->opcode());
}
- void CheckLoweringTruncatedBinop(IrOpcode::Value expected, Operator* op,
- Operator* trunc) {
+ void CheckLoweringTruncatedBinop(IrOpcode::Value expected, const Operator* op,
+ const Operator* trunc) {
Node* node = graph()->NewNode(op, p0, p1);
Return(graph()->NewNode(trunc, node));
Lower();
}
-static void CheckChangesAroundBinop(TestingGraph* t, Operator* op,
+static void CheckChangesAroundBinop(TestingGraph* t, const Operator* op,
IrOpcode::Value input_change,
IrOpcode::Value output_change) {
Node* binop = t->graph()->NewNode(op, t->p0, t->p1);
TEST(InsertChangesAroundInt32Binops) {
TestingGraph t(Type::Signed32(), Type::Signed32());
- Operator* ops[] = {t.machine()->Int32Add(), t.machine()->Int32Sub(),
- t.machine()->Int32Mul(), t.machine()->Int32Div(),
- t.machine()->Int32Mod(), t.machine()->Word32And(),
- t.machine()->Word32Or(), t.machine()->Word32Xor(),
- t.machine()->Word32Shl(), t.machine()->Word32Sar()};
+ const Operator* ops[] = {t.machine()->Int32Add(), t.machine()->Int32Sub(),
+ t.machine()->Int32Mul(), t.machine()->Int32Div(),
+ t.machine()->Int32Mod(), t.machine()->Word32And(),
+ t.machine()->Word32Or(), t.machine()->Word32Xor(),
+ t.machine()->Word32Shl(), t.machine()->Word32Sar()};
for (size_t i = 0; i < arraysize(ops); i++) {
CheckChangesAroundBinop(&t, ops[i], IrOpcode::kChangeTaggedToInt32,
TEST(InsertChangesAroundInt32Cmp) {
TestingGraph t(Type::Signed32(), Type::Signed32());
- Operator* ops[] = {t.machine()->Int32LessThan(),
- t.machine()->Int32LessThanOrEqual()};
+ const Operator* ops[] = {t.machine()->Int32LessThan(),
+ t.machine()->Int32LessThanOrEqual()};
for (size_t i = 0; i < arraysize(ops); i++) {
CheckChangesAroundBinop(&t, ops[i], IrOpcode::kChangeTaggedToInt32,
TEST(InsertChangesAroundUint32Cmp) {
TestingGraph t(Type::Unsigned32(), Type::Unsigned32());
- Operator* ops[] = {t.machine()->Uint32LessThan(),
- t.machine()->Uint32LessThanOrEqual()};
+ const Operator* ops[] = {t.machine()->Uint32LessThan(),
+ t.machine()->Uint32LessThanOrEqual()};
for (size_t i = 0; i < arraysize(ops); i++) {
CheckChangesAroundBinop(&t, ops[i], IrOpcode::kChangeTaggedToUint32,
TEST(InsertChangesAroundFloat64Binops) {
TestingGraph t(Type::Number(), Type::Number());
- Operator* ops[] = {
+ const Operator* ops[] = {
t.machine()->Float64Add(), t.machine()->Float64Sub(),
t.machine()->Float64Mul(), t.machine()->Float64Div(),
t.machine()->Float64Mod(),
TEST(InsertChangesAroundFloat64Cmp) {
TestingGraph t(Type::Number(), Type::Number());
- Operator* ops[] = {t.machine()->Float64Equal(),
- t.machine()->Float64LessThan(),
- t.machine()->Float64LessThanOrEqual()};
+ const Operator* ops[] = {t.machine()->Float64Equal(),
+ t.machine()->Float64LessThan(),
+ t.machine()->Float64LessThanOrEqual()};
for (size_t i = 0; i < arraysize(ops); i++) {
CheckChangesAroundBinop(&t, ops[i], IrOpcode::kChangeTaggedToFloat64,
projects / platform / upstream / v8.git / commitdiff