hydrogen-instructions.cc File Reference

#include "src/v8.h"
#include "src/base/bits.h"
#include "src/double.h"
#include "src/factory.h"
#include "src/hydrogen-infer-representation.h"
#include "src/property-details-inl.h"
#include "src/base/safe_math.h"

Include dependency graph for hydrogen-instructions.cc:

Go to the source code of this file.

Namespaces
	v8
	Debugger support for the V8 JavaScript engine.
	v8::internal

Macros
#define	DEFINE_COMPILE(type)
#define	MAKE_CASE(type)   case k##type: return #type;
#define	PRINT_DO(Type)
#define	IMMORTAL_IMMOVABLE_ROOT(name)    object_.IsKnownGlobal(heap->name()) ||
#define	INTERNALIZED_STRING(name, value)    object_.IsKnownGlobal(heap->name()) ||
#define	STRING_TYPE(NAME, size, name, Name)    object_.IsKnownGlobal(heap->name##_map()) ||
#define	H_CONSTANT_INT(val)   HConstant::New(zone, context, static_cast<int32_t>(val))
#define	H_CONSTANT_DOUBLE(val)   HConstant::New(zone, context, static_cast<double>(val))
#define	DEFINE_NEW_H_SIMPLE_ARITHMETIC_INSTR(HInstr, op)
#define	DEFINE_NEW_H_BITWISE_INSTR(HInstr, result)

Functions
static int32_t	v8::internal::ConvertAndSetOverflow (Representation r, int64_t result, bool *overflow)
static int32_t	v8::internal::AddWithoutOverflow (Representation r, int32_t a, int32_t b, bool *overflow)
static int32_t	v8::internal::SubWithoutOverflow (Representation r, int32_t a, int32_t b, bool *overflow)
static int32_t	v8::internal::MulWithoutOverflow (const Representation &r, int32_t a, int32_t b, bool *overflow)
OStream &	v8::internal::operator<< (OStream &os, const HValue &v)
OStream &	v8::internal::operator<< (OStream &os, const TypeOf &t)
OStream &	v8::internal::operator<< (OStream &os, const ChangesOf &c)
OStream &	v8::internal::operator<< (OStream &os, const HSourcePosition &p)
OStream &	v8::internal::operator<< (OStream &os, const NameOf &v)
static String *	v8::internal::TypeOfString (HConstant *constant, Isolate *isolate)
static bool	v8::internal::MatchLeftIsOnes (HValue *l, HValue *r, HValue **negated)
static bool	v8::internal::MatchNegationViaXor (HValue *instr, HValue **negated)
static bool	v8::internal::MatchDoubleNegation (HValue *instr, HValue **arg)
static bool	v8::internal::IsIdentityOperation (HValue *arg1, HValue *arg2, int32_t identity)
static int32_t	v8::internal::AbsMinus1 (int32_t a)
static void	v8::internal::ReplayEnvironmentNested (const ZoneList< HValue * > *values, HCapturedObject *other)
static bool	v8::internal::IsInteger32 (double value)
bool	v8::internal::ConstantIsObject (HConstant *constant, Isolate *isolate)
	v8::internal::DEFINE_NEW_H_BITWISE_INSTR (HSar, c_left->NumberValueAsInteger32() >>(c_right->NumberValueAsInteger32() &0x1f)) DEFINE_NEW_H_BITWISE_INSTR(HShl
c_left	v8::internal::NumberValueAsInteger32 ()<<(c_right -> NumberValueAsInteger32() &0x1f)) HInstruction *HShr::New(Zone *zone, HValue *context, HValue *left, HValue *right)
OStream &	v8::internal::operator<< (OStream &os, const HObjectAccess &access)

Macro Definition Documentation

DEFINE_COMPILE

#define DEFINE_COMPILE

(

type

)

Value:

  LInstruction* H##type::CompileToLithium(LChunkBuilder* builder) {  \
    return builder->Do##type(this);                                  \
  }

Definition at line 36 of file hydrogen-instructions.cc.

DEFINE_NEW_H_BITWISE_INSTR

#define DEFINE_NEW_H_BITWISE_INSTR	(		HInstr,
			result
	)

Value:

HInstruction* HInstr::New(                                                     \
    Zone* zone, HValue* context, HValue* left, HValue* right) {                \
  if (FLAG_fold_constants && left->IsConstant() && right->IsConstant()) {      \
    HConstant* c_left = HConstant::cast(left);                                 \
    HConstant* c_right = HConstant::cast(right);                               \
    if ((c_left->HasNumberValue() && c_right->HasNumberValue())) {             \
      return H_CONSTANT_INT(result);                                           \
    }                                                                          \
  }                                                                            \
  return new(zone) HInstr(context, left, right);                               \
}

Definition at line 4370 of file hydrogen-instructions.cc.

DEFINE_NEW_H_SIMPLE_ARITHMETIC_INSTR

#define DEFINE_NEW_H_SIMPLE_ARITHMETIC_INSTR	(		HInstr,
			op
	)

Value:

HInstruction* HInstr::New(                                                     \
    Zone* zone, HValue* context, HValue* left, HValue* right) {                \
  if (FLAG_fold_constants && left->IsConstant() && right->IsConstant()) {      \
    HConstant* c_left = HConstant::cast(left);                                 \
    HConstant* c_right = HConstant::cast(right);                               \
    if ((c_left->HasNumberValue() && c_right->HasNumberValue())) {             \
      double double_res = c_left->DoubleValue() op c_right->DoubleValue();     \
      if (IsInt32Double(double_res)) {                                         \
        return H_CONSTANT_INT(double_res);                                     \
      }                                                                        \
      return H_CONSTANT_DOUBLE(double_res);                                    \
    }                                                                          \
  }                                                                            \
  return new(zone) HInstr(context, left, right);                               \
}

Definition at line 4048 of file hydrogen-instructions.cc.

H_CONSTANT_DOUBLE

#define H_CONSTANT_DOUBLE

(

val

)

HConstant::New(zone, context, static_cast<double>(val))

Definition at line 4045 of file hydrogen-instructions.cc.

H_CONSTANT_INT

#define H_CONSTANT_INT

(

val

)

HConstant::New(zone, context, static_cast<int32_t>(val))

Definition at line 4043 of file hydrogen-instructions.cc.

IMMORTAL_IMMOVABLE_ROOT

#define IMMORTAL_IMMOVABLE_ROOT

(

name

)

object_.IsKnownGlobal(heap->name()) ||

INTERNALIZED_STRING

#define INTERNALIZED_STRING	(		name,
			value
	)		object_.IsKnownGlobal(heap->name()) ||

MAKE_CASE

#define MAKE_CASE

(

type

)

case k##type: return #type;

PRINT_DO

#define PRINT_DO

(

Type

)

Value:

  if (changes_flags.Contains(k##Type)) { \
    if (add_comma) os << ",";            \
    add_comma = true;                    \
    os << #Type;                         \
  }

STRING_TYPE

#define STRING_TYPE	(		NAME,
			size,
			name,
			Name
	)		object_.IsKnownGlobal(heap->name##_map()) ||