sdk/lib/_internal/compiler/implementation/ir/ir_unpickler.dart - sdk.git - Git at Google

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.

 part of dart2js.ir_pickler;

 class Unpickler {
   final Compiler compiler;

   final IrConstantPool constantPool;

   Unpickler(this.compiler, this.constantPool);

   List<int> data;

   int offset;

   /** For each entry index, the corresponding unpickled object. */
   List<Object> unpickled;

   /** Counter for entries in [unpickled]. */
   int index;

   /**
    * This buffer is used in [readConstantValue] to reconstruct a double value
    * from a sequence of bytes.
    */
   ByteData doubleData = new ByteData(8);

   ConstantSystem get constantSystem => compiler.backend.constantSystem;

   // A partially constructed expression is one that has a single 'hole' where
   // there is an expression missing.  Just like the IR builder, the unpickler
   // represents such an expression by its root and by the 'current' expression
   // that immediately contains the hole.  If there is no hole (e.g., an
   // expression in tail position has been seen), then current is null.
   ir.Expression root;
   ir.Expression current;

   ir.FunctionDefinition unpickle(List<int> data) {
     this.data = data;
     offset = 0;
     int numEntries = readInt();
     unpickled = new List<Object>(numEntries);
     index = 0;
     root = current = null;
     return readFunctionDefinition();
   }

   int readByte() {
     return data[offset++];
   }

   int readInt() {
     int result = 0;
     int next;
     for (int i = 0; true; i += 7) {
       next = readByte();
       result |= (next >> 1) << i;
       if ((next & 1) == 0) break;
     }
     bool isNegative = (result & 1) == 1;
     result >>= 1;
     return isNegative ? -result : result;
   }

   String readString() {
     int tag = readByte();
     int length = readInt();
     List<int> bytes = new Uint8List(length);
     for (int i = 0; i < length; i++) {
       bytes[i] = readByte();
     }
     if (tag == Pickles.STRING_ASCII) {
       return new String.fromCharCodes(bytes);
     } else if (tag == Pickles.STRING_UTF8) {
       return UTF8.decode(bytes);
     } else {
       compiler.internalError(NO_LOCATION_SPANNABLE,
                              "Unexpected string tag: $tag");
       return null;
     }
   }

   Element readElement() {
     int elementIndex = readInt();
     return constantPool.get(elementIndex);
   }

   Selector readSelector() {
     int tag = readByte();
     if (tag == Pickles.BACKREFERENCE) {
       return readBackReference();
     }
     assert(tag == Pickles.SELECTOR_UNTYPED);
     int entryIndex = index++;
     SelectorKind kind = Pickles.selectorKindFromId[readInt()];
     String name = readString();
     Element library = readElement();
     int argumentsCount = readInt();
     int namedArgumentsCount = readInt();
     List<String> namedArguments = new List<String>(namedArgumentsCount);
     for (int i = 0; i < namedArgumentsCount; i++) {
       namedArguments[i] = readString();
     }
     Selector result = new Selector(
         kind, name, library, argumentsCount, namedArguments);
     unpickled[entryIndex] = result;
     return result;
   }

   void addExpression(ir.Expression expr) {
     if (root == null) {
       root = current = expr;
     } else {
       current = current.plug(expr);
     }
   }

   // Read a single expression and plug it into the outer context.
   ir.Expression readExpressionNode() {
     int tag = readByte();
     switch (tag) {
       case Pickles.NODE_CONSTANT:
         ir.Definition constant = readConstant();
         unpickled[index++] = constant;
         addExpression(new ir.LetPrim(constant));
         break;
       case Pickles.NODE_LET_CONT:
         ir.Parameter parameter = new ir.Parameter(null);
         ir.Continuation continuation = new ir.Continuation(parameter);
         unpickled[index++] = continuation;
         ir.Expression body = readDelimitedExpressionNode();
         unpickled[index++] = parameter;
         addExpression(new ir.LetCont(continuation, body));
         break;
       case Pickles.NODE_INVOKE_STATIC:
         addExpression(readInvokeStatic());
         current = null;
         break;
       case Pickles.NODE_INVOKE_CONTINUATION:
         addExpression(readInvokeContinuation());
         current = null;
         break;
       default:
         compiler.internalError(NO_LOCATION_SPANNABLE,
                                "Unexpected expression entry tag: $tag");
         break;
     }
   }

   // Iteratively read expressions until an expression in a tail position
   // (e.g., an invocation) is found.  Do not change the outer context.
   ir.Expression readDelimitedExpressionNode() {
     ir.Expression previous_root = root;
     ir.Expression previous_current = current;
     root = current = null;
     do {
       readExpressionNode();
     } while (current != null);
     ir.Expression result = root;
     root = previous_root;
     current = previous_current;
     return result;
   }

   Object readBackReference() {
     int indexDelta = readInt();
     int entryIndex = index - indexDelta;
     assert(unpickled[entryIndex] != null);
     return unpickled[entryIndex];
   }

   List<ir.Definition> readBackReferenceList() {
     int length = readInt();
     List<ir.Definition> result = new List<ir.Definition>(length);
     for (int i = 0; i < length; ++i) {
       result[i] = readBackReference();
     }
     return result;
   }

   ir.FunctionDefinition readFunctionDefinition() {
     // There is implicitly a return continuation which can be the target of
     // back references.
     ir.Continuation continuation = new ir.Continuation.retrn();
     unpickled[index++] = continuation;

     int parameterCount = readInt();
     List<ir.Parameter> parameters = new List<ir.Parameter>(parameterCount);
     for (int i = 0; i < parameterCount; ++i) {
       unpickled[index++] = parameters[i] = new ir.Parameter(readElement());
     }

     ir.Expression body = readDelimitedExpressionNode();
     return new ir.FunctionDefinition(continuation, parameters, body);
   }

   ir.Constant readConstant() {
     Constant constant = readConstantValue();
     return new ir.Constant(constant);
   }

   ir.InvokeStatic readInvokeStatic() {
     FunctionElement functionElement = readElement();
     Selector selector = readSelector();
     ir.Continuation continuation = readBackReference();
     List<ir.Definition> arguments = readBackReferenceList();
     return new ir.InvokeStatic(functionElement, selector, continuation,
                                arguments);
   }

   ir.InvokeContinuation readInvokeContinuation() {
     ir.Continuation continuation = readBackReference();
     ir.Definition argument = readBackReference();
     return new ir.InvokeContinuation(continuation, argument);
   }

   Constant readConstantValue() {
     int tag = readByte();
     switch(tag) {
       case Pickles.CONST_BOOL:
         return constantSystem.createBool(readByte() == 1);
       case Pickles.CONST_INT:
         return constantSystem.createInt(readInt());
       case Pickles.CONST_DOUBLE:
         for (int i = 0; i < 8; i++) {
           doubleData.setUint8(i, readByte());
         }
         double value = doubleData.getFloat64(0, Endianness.BIG_ENDIAN);
         return constantSystem.createDouble(value);
       case Pickles.CONST_STRING_LITERAL:
       case Pickles.CONST_STRING_RAW:
       case Pickles.CONST_STRING_ESCAPED:
       case Pickles.CONST_STRING_CONS:
         return constantSystem.createString(readDartString(tag));
       case Pickles.CONST_NULL:
         return constantSystem.createNull();
       default:
         compiler.internalError(NO_LOCATION_SPANNABLE,
                                "Unexpected constant tag: $tag");
         return null;
     }
   }

   ast.DartString readDartString(int tag) {
     switch(tag) {
       case Pickles.CONST_STRING_LITERAL:
         return new ast.LiteralDartString(readString());
       case Pickles.CONST_STRING_RAW:
         return new ast.RawSourceDartString(readString(), readInt());
       case Pickles.CONST_STRING_ESCAPED:
         return new ast.EscapedSourceDartString(readString(), readInt());
       case Pickles.CONST_STRING_CONS:
         return new ast.ConsDartString(
             readDartString(readByte()), readDartString(readByte()));
       default:
         compiler.internalError(NO_LOCATION_SPANNABLE,
                                "Unexpected dart string tag: $tag");
         return null;
     }
   }
 }
	// Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file
	// for details. All rights reserved. Use of this source code is governed by a
	// BSD-style license that can be found in the LICENSE file.

	part of dart2js.ir_pickler;

	class Unpickler {
	final Compiler compiler;

	final IrConstantPool constantPool;

	Unpickler(this.compiler, this.constantPool);

	List<int> data;

	int offset;

	/** For each entry index, the corresponding unpickled object. */
	List<Object> unpickled;

	/** Counter for entries in [unpickled]. */
	int index;

	/**
	* This buffer is used in [readConstantValue] to reconstruct a double value
	* from a sequence of bytes.
	*/
	ByteData doubleData = new ByteData(8);

	ConstantSystem get constantSystem => compiler.backend.constantSystem;

	// A partially constructed expression is one that has a single 'hole' where
	// there is an expression missing. Just like the IR builder, the unpickler
	// represents such an expression by its root and by the 'current' expression
	// that immediately contains the hole. If there is no hole (e.g., an
	// expression in tail position has been seen), then current is null.
	ir.Expression root;
	ir.Expression current;

	ir.FunctionDefinition unpickle(List<int> data) {
	this.data = data;
	offset = 0;
	int numEntries = readInt();
	unpickled = new List<Object>(numEntries);
	index = 0;
	root = current = null;
	return readFunctionDefinition();
	}

	int readByte() {
	return data[offset++];
	}

	int readInt() {
	int result = 0;
	int next;
	for (int i = 0; true; i += 7) {
	next = readByte();
	result \|= (next >> 1) << i;
	if ((next & 1) == 0) break;
	}
	bool isNegative = (result & 1) == 1;
	result >>= 1;
	return isNegative ? -result : result;
	}

	String readString() {
	int tag = readByte();
	int length = readInt();
	List<int> bytes = new Uint8List(length);
	for (int i = 0; i < length; i++) {
	bytes[i] = readByte();
	}
	if (tag == Pickles.STRING_ASCII) {
	return new String.fromCharCodes(bytes);
	} else if (tag == Pickles.STRING_UTF8) {
	return UTF8.decode(bytes);
	} else {
	compiler.internalError(NO_LOCATION_SPANNABLE,
	"Unexpected string tag: $tag");
	return null;
	}
	}

	Element readElement() {
	int elementIndex = readInt();
	return constantPool.get(elementIndex);
	}

	Selector readSelector() {
	int tag = readByte();
	if (tag == Pickles.BACKREFERENCE) {
	return readBackReference();
	}
	assert(tag == Pickles.SELECTOR_UNTYPED);
	int entryIndex = index++;
	SelectorKind kind = Pickles.selectorKindFromId[readInt()];
	String name = readString();
	Element library = readElement();
	int argumentsCount = readInt();
	int namedArgumentsCount = readInt();
	List<String> namedArguments = new List<String>(namedArgumentsCount);
	for (int i = 0; i < namedArgumentsCount; i++) {
	namedArguments[i] = readString();
	}
	Selector result = new Selector(
	kind, name, library, argumentsCount, namedArguments);
	unpickled[entryIndex] = result;
	return result;
	}

	void addExpression(ir.Expression expr) {
	if (root == null) {
	root = current = expr;
	} else {
	current = current.plug(expr);
	}
	}

	// Read a single expression and plug it into the outer context.
	ir.Expression readExpressionNode() {
	int tag = readByte();
	switch (tag) {
	case Pickles.NODE_CONSTANT:
	ir.Definition constant = readConstant();
	unpickled[index++] = constant;
	addExpression(new ir.LetPrim(constant));
	break;
	case Pickles.NODE_LET_CONT:
	ir.Parameter parameter = new ir.Parameter(null);
	ir.Continuation continuation = new ir.Continuation(parameter);
	unpickled[index++] = continuation;
	ir.Expression body = readDelimitedExpressionNode();
	unpickled[index++] = parameter;
	addExpression(new ir.LetCont(continuation, body));
	break;
	case Pickles.NODE_INVOKE_STATIC:
	addExpression(readInvokeStatic());
	current = null;
	break;
	case Pickles.NODE_INVOKE_CONTINUATION:
	addExpression(readInvokeContinuation());
	current = null;
	break;
	default:
	compiler.internalError(NO_LOCATION_SPANNABLE,
	"Unexpected expression entry tag: $tag");
	break;
	}
	}

	// Iteratively read expressions until an expression in a tail position
	// (e.g., an invocation) is found. Do not change the outer context.
	ir.Expression readDelimitedExpressionNode() {
	ir.Expression previous_root = root;
	ir.Expression previous_current = current;
	root = current = null;
	do {
	readExpressionNode();
	} while (current != null);
	ir.Expression result = root;
	root = previous_root;
	current = previous_current;
	return result;
	}

	Object readBackReference() {
	int indexDelta = readInt();
	int entryIndex = index - indexDelta;
	assert(unpickled[entryIndex] != null);
	return unpickled[entryIndex];
	}

	List<ir.Definition> readBackReferenceList() {
	int length = readInt();
	List<ir.Definition> result = new List<ir.Definition>(length);
	for (int i = 0; i < length; ++i) {
	result[i] = readBackReference();
	}
	return result;
	}

	ir.FunctionDefinition readFunctionDefinition() {
	// There is implicitly a return continuation which can be the target of
	// back references.
	ir.Continuation continuation = new ir.Continuation.retrn();
	unpickled[index++] = continuation;

	int parameterCount = readInt();
	List<ir.Parameter> parameters = new List<ir.Parameter>(parameterCount);
	for (int i = 0; i < parameterCount; ++i) {
	unpickled[index++] = parameters[i] = new ir.Parameter(readElement());
	}

	ir.Expression body = readDelimitedExpressionNode();
	return new ir.FunctionDefinition(continuation, parameters, body);
	}

	ir.Constant readConstant() {
	Constant constant = readConstantValue();
	return new ir.Constant(constant);
	}

	ir.InvokeStatic readInvokeStatic() {
	FunctionElement functionElement = readElement();
	Selector selector = readSelector();
	ir.Continuation continuation = readBackReference();
	List<ir.Definition> arguments = readBackReferenceList();
	return new ir.InvokeStatic(functionElement, selector, continuation,
	arguments);
	}

	ir.InvokeContinuation readInvokeContinuation() {
	ir.Continuation continuation = readBackReference();
	ir.Definition argument = readBackReference();
	return new ir.InvokeContinuation(continuation, argument);
	}

	Constant readConstantValue() {
	int tag = readByte();
	switch(tag) {
	case Pickles.CONST_BOOL:
	return constantSystem.createBool(readByte() == 1);
	case Pickles.CONST_INT:
	return constantSystem.createInt(readInt());
	case Pickles.CONST_DOUBLE:
	for (int i = 0; i < 8; i++) {
	doubleData.setUint8(i, readByte());
	}
	double value = doubleData.getFloat64(0, Endianness.BIG_ENDIAN);
	return constantSystem.createDouble(value);
	case Pickles.CONST_STRING_LITERAL:
	case Pickles.CONST_STRING_RAW:
	case Pickles.CONST_STRING_ESCAPED:
	case Pickles.CONST_STRING_CONS:
	return constantSystem.createString(readDartString(tag));
	case Pickles.CONST_NULL:
	return constantSystem.createNull();
	default:
	compiler.internalError(NO_LOCATION_SPANNABLE,
	"Unexpected constant tag: $tag");
	return null;
	}
	}

	ast.DartString readDartString(int tag) {
	switch(tag) {
	case Pickles.CONST_STRING_LITERAL:
	return new ast.LiteralDartString(readString());
	case Pickles.CONST_STRING_RAW:
	return new ast.RawSourceDartString(readString(), readInt());
	case Pickles.CONST_STRING_ESCAPED:
	return new ast.EscapedSourceDartString(readString(), readInt());
	case Pickles.CONST_STRING_CONS:
	return new ast.ConsDartString(
	readDartString(readByte()), readDartString(readByte()));
	default:
	compiler.internalError(NO_LOCATION_SPANNABLE,
	"Unexpected dart string tag: $tag");
	return null;
	}
	}
	}