src/developer/shell/interpreter/src/code.h - fuchsia - Git at Google

 // Copyright 2020 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #ifndef SRC_DEVELOPER_SHELL_INTERPRETER_SRC_CODE_H_
 #define SRC_DEVELOPER_SHELL_INTERPRETER_SRC_CODE_H_

 #include <memory>
 #include <set>
 #include <vector>

 #include "src/developer/shell/interpreter/src/nodes.h"
 #include "src/developer/shell/interpreter/src/value.h"

 namespace shell {
 namespace interpreter {

 namespace code {

 // Defines all the operations the interpreter can execute.
 enum class Opcode : uint64_t {
   // Nop: do nothing.
   kNop,
   // Pops a value from the stack and emits it (send it back to the client).
   kEmitResult,
   // Pops two 8 bit integers from the stack, adds them and pushes the result to the stack.
   kInt8Addition,
   // Pops two 16 bit integers from the stack, adds them and pushes the result to the stack.
   kInt16Addition,
   // Pops two 32 bit integers from the stack, adds them and pushes the result to the stack.
   kInt32Addition,
   // Pops two 64 bit integers from the stack, adds them and pushes the result to the stack.
   kInt64Addition,
   // Pushes a 64 bit literal to the thread's value stack.
   kLiteral64,
   // Loads a 8 bit global variable and pushes it to the stack.
   kLoadRaw8,
   // Loads a 16 bit global variable and pushes it to the stack.
   kLoadRaw16,
   // Loads a 32 bit global variable and pushes it to the stack.
   kLoadRaw32,
   // Loads a 64 bit global variable and pushes it to the stack.
   kLoadRaw64,
   // Loads a referenced counted value from a global variable and pushes it to the thread's value
   // stack.
   kLoadReferenceCounted,
   // Initializes an object.
   // Value stack before:
   //   <reference to uninitialized object>
   //   <initial value N>
   //   <initial value N-1>
   //   ...
   //   (where 1, 2, ..., N are values in the order they appear in the schema of the object)
   // Value stack after:
   //   <reference to initialized object>
   kObjectInit,
   // Allocates an object and sets its schema.
   // Value stack before:
   //   ...
   // Value stack after:
   //   <reference>
   //   ...
   kObjectNew,
   // Pushes a reference counted literal to the thread's value stack. Increment the reference count
   // for the object.
   kReferenceCountedLiteral,
   // Return from code execution. The execution goes back to the calling scope or stops if it was
   // the last execution scope.
   kRet,
   // Pops two 8 bit signed integers from the stack, adds them and pushes the result to the stack.
   // If an overflow or and underflow occur, an error is generated and the execution stops.
   kSint8AdditionWithExceptions,
   // Pops two 16 bit signed integers from the stack, adds them and pushes the result to the stack.
   // If an overflow or and underflow occur, an error is generated and the execution stops.
   kSint16AdditionWithExceptions,
   // Pops two 32 bit signed integers from the stack, adds them and pushes the result to the stack.
   // If an overflow or and underflow occur, an error is generated and the execution stops.
   kSint32AdditionWithExceptions,
   // Pops two 64 bit signed integers from the stack, adds them and pushes the result to the stack.
   // If an overflow or and underflow occur, an error is generated and the execution stops.
   kSint64AdditionWithExceptions,
   // Pops a value from the thread's value stack and stores it into a 8 bit global variable.
   kStoreRaw8,
   // Pops a value from the thread's value stack and stores it into a 16 bit global variable.
   kStoreRaw16,
   // Pops a value from the thread's value stack and stores it into a 32 bit global variable.
   kStoreRaw32,
   // Pops a value from the thread's value stack and stores it into a 64 bit global variable.
   kStoreRaw64,
   // Pops a value from the stack, releases the old value of the global variable and stores the new
   // value.
   kStoreReferenceCounted,
   // Pops several strings from the stack, concatenates them and pushes the result to the stack.
   kStringConcatenation,
   // Pops two 8 bit unsigned integers from the stack, adds them and pushes the result to the stack.
   // If an overflow occurs, an error is generated and the execution stops.
   kUint8AdditionWithExceptions,
   // Pops two 16 bit unsigned integers from the stack, adds them and pushes the result to the stack.
   // If an overflow occurs, an error is generated and the execution stops.
   kUint16AdditionWithExceptions,
   // Pops two 32 bit unsigned integers from the stack, adds them and pushes the result to the stack.
   // If an overflow occurs, an error is generated and the execution stops.
   kUint32AdditionWithExceptions,
   // Pops two 64 bit unsigned integers from the stack, adds them and pushes the result to the stack.
   // If an overflow occurs, an error is generated and the execution stops.
   kUint64AdditionWithExceptions,
 };

 // Defines some code. This can represent the code for one function or the code for the pending
 // instructions of one execution context.
 class Code {
  public:
   Code() = default;

   const std::vector<uint64_t>& code() const { return code_; }

   // Adds an emit result.
   void EmitResult(std::unique_ptr<Type> type) {
     emplace_back_opcode(Opcode::kEmitResult);
     code_.emplace_back(reinterpret_cast<uint64_t>(type.get()));
     types_.emplace_back(std::move(type));
   }

   // Adds an integer addition.
   void IntegerAddition(bool with_exceptions, size_t size, bool is_signed) {
     switch (size) {
       case 1:
         emplace_back_opcode(with_exceptions ? (is_signed ? Opcode::kSint8AdditionWithExceptions
                                                          : Opcode::kUint8AdditionWithExceptions)
                                             : Opcode::kInt8Addition);
         break;
       case 2:
         emplace_back_opcode(with_exceptions ? (is_signed ? Opcode::kSint16AdditionWithExceptions
                                                          : Opcode::kUint16AdditionWithExceptions)
                                             : Opcode::kInt16Addition);
         break;
       case 4:
         emplace_back_opcode(with_exceptions ? (is_signed ? Opcode::kSint32AdditionWithExceptions
                                                          : Opcode::kUint32AdditionWithExceptions)
                                             : Opcode::kInt32Addition);
         break;
       case 8:
         emplace_back_opcode(with_exceptions ? (is_signed ? Opcode::kSint64AdditionWithExceptions
                                                          : Opcode::kUint64AdditionWithExceptions)
                                             : Opcode::kInt64Addition);
         break;
       default:
         FX_LOGS(FATAL) << "Bad integer size " << size;
     }
   }

   // Adds a 64 bit literal operation.
   void Literal64(uint64_t value) {
     emplace_back_opcode(Opcode::kLiteral64);
     code_.emplace_back(value);
   }

   // Adds a 64 bit literal operation.
   void LoadReferenceCounted(size_t index) {
     emplace_back_opcode(Opcode::kLoadReferenceCounted);
     code_.emplace_back(index);
   }

   // Adds a global variable load operation.
   void LoadRaw(size_t index, size_t size) {
     switch (size) {
       case 1:
         emplace_back_opcode(Opcode::kLoadRaw8);
         break;
       case 2:
         emplace_back_opcode(Opcode::kLoadRaw16);
         break;
       case 4:
         emplace_back_opcode(Opcode::kLoadRaw32);
         break;
       case 8:
         emplace_back_opcode(Opcode::kLoadRaw64);
         break;
       default:
         FX_LOGS(FATAL) << "Bad builtin size " << size;
     }
     code_.emplace_back(index);
   }

   // Adds a ret operation.
   void Ret() { emplace_back_opcode(Opcode::kRet); }

   // Adds a global variable store operation.
   void StoreRaw(uint64_t index, uint64_t size) {
     switch (size) {
       case 1:
         emplace_back_opcode(Opcode::kStoreRaw8);
         break;
       case 2:
         emplace_back_opcode(Opcode::kStoreRaw16);
         break;
       case 4:
         emplace_back_opcode(Opcode::kStoreRaw32);
         break;
       case 8:
         emplace_back_opcode(Opcode::kStoreRaw64);
         break;
       default:
         FX_LOGS(FATAL) << "Bad builtin size " << size;
     }
     code_.emplace_back(index);
   }

   // Adds a reference counted global variable store operation.
   void StoreReferenceCounted(uint64_t index) {
     emplace_back_opcode(Opcode::kStoreReferenceCounted);
     code_.emplace_back(index);
   }

   // Adds a string concatenation operation.
   void StringConcatenation(size_t string_count) {
     emplace_back_opcode(Opcode::kStringConcatenation);
     code_.emplace_back(string_count);
   }

   // Adds a string literal operation.
   void StringLiteral(String* value) {
     strings_.emplace_back(value);
     emplace_back_opcode(Opcode::kReferenceCountedLiteral);
     code_.emplace_back(reinterpret_cast<uint64_t>(value));
   }

   // Adds an operation that allocates an object and leaves a reference to it on the stack.
   void ObjectPush(const std::shared_ptr<ObjectSchema>& object_schema) {
     emplace_back_opcode(Opcode::kObjectNew);
     auto ref = object_schemas_.insert(object_schema);
     // We store the shared_ptr so that the object that later gets allocated can ref and deref it.
     const std::shared_ptr<ObjectSchema>* ptr = &(*(ref.first));
     code_.emplace_back(reinterpret_cast<uint64_t>(ptr));
   }

   // Adds an operation that initializes an object.
   void ObjectInit() { emplace_back_opcode(Opcode::kObjectInit); }

  private:
   void emplace_back_opcode(Opcode opcode) { code_.emplace_back(static_cast<uint64_t>(opcode)); }

   struct SchemaPtrLT {
     constexpr bool operator()(const std::shared_ptr<ObjectSchema>& lhs,
                               const std::shared_ptr<ObjectSchema>& rhs) const {
       return lhs.get() < rhs.get();
     }
   };

   // Tracking for the schemas used as arguments by the code.  Because schemas are managed by
   // shared_ptrs, and code_ only stores opaque values.
   std::set<std::shared_ptr<ObjectSchema>, SchemaPtrLT> object_schemas_;

   // Contains the operations. It's a mix of opcodes and arguments for the operations.
   std::vector<uint64_t> code_;

   // Keeps alive the string literals in the code.
   std::vector<StringContainer> strings_;

   // Keeps alive the types in the code.
   std::vector<std::unique_ptr<Type>> types_;
 };

 }  // namespace code
 }  // namespace interpreter
 }  // namespace shell

 #endif  // SRC_DEVELOPER_SHELL_INTERPRETER_SRC_CODE_H_
	// Copyright 2020 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#ifndef SRC_DEVELOPER_SHELL_INTERPRETER_SRC_CODE_H_
	#define SRC_DEVELOPER_SHELL_INTERPRETER_SRC_CODE_H_

	#include <memory>
	#include <set>
	#include <vector>

	#include "src/developer/shell/interpreter/src/nodes.h"
	#include "src/developer/shell/interpreter/src/value.h"

	namespace shell {
	namespace interpreter {

	namespace code {

	// Defines all the operations the interpreter can execute.
	enum class Opcode : uint64_t {
	// Nop: do nothing.
	kNop,
	// Pops a value from the stack and emits it (send it back to the client).
	kEmitResult,
	// Pops two 8 bit integers from the stack, adds them and pushes the result to the stack.
	kInt8Addition,
	// Pops two 16 bit integers from the stack, adds them and pushes the result to the stack.
	kInt16Addition,
	// Pops two 32 bit integers from the stack, adds them and pushes the result to the stack.
	kInt32Addition,
	// Pops two 64 bit integers from the stack, adds them and pushes the result to the stack.
	kInt64Addition,
	// Pushes a 64 bit literal to the thread's value stack.
	kLiteral64,
	// Loads a 8 bit global variable and pushes it to the stack.
	kLoadRaw8,
	// Loads a 16 bit global variable and pushes it to the stack.
	kLoadRaw16,
	// Loads a 32 bit global variable and pushes it to the stack.
	kLoadRaw32,
	// Loads a 64 bit global variable and pushes it to the stack.
	kLoadRaw64,
	// Loads a referenced counted value from a global variable and pushes it to the thread's value
	// stack.
	kLoadReferenceCounted,
	// Initializes an object.
	// Value stack before:
	// <reference to uninitialized object>
	// <initial value N>
	// <initial value N-1>
	// ...
	// (where 1, 2, ..., N are values in the order they appear in the schema of the object)
	// Value stack after:
	// <reference to initialized object>
	kObjectInit,
	// Allocates an object and sets its schema.
	// Value stack before:
	// ...
	// Value stack after:
	// <reference>
	// ...
	kObjectNew,
	// Pushes a reference counted literal to the thread's value stack. Increment the reference count
	// for the object.
	kReferenceCountedLiteral,
	// Return from code execution. The execution goes back to the calling scope or stops if it was
	// the last execution scope.
	kRet,
	// Pops two 8 bit signed integers from the stack, adds them and pushes the result to the stack.
	// If an overflow or and underflow occur, an error is generated and the execution stops.
	kSint8AdditionWithExceptions,
	// Pops two 16 bit signed integers from the stack, adds them and pushes the result to the stack.
	// If an overflow or and underflow occur, an error is generated and the execution stops.
	kSint16AdditionWithExceptions,
	// Pops two 32 bit signed integers from the stack, adds them and pushes the result to the stack.
	// If an overflow or and underflow occur, an error is generated and the execution stops.
	kSint32AdditionWithExceptions,
	// Pops two 64 bit signed integers from the stack, adds them and pushes the result to the stack.
	// If an overflow or and underflow occur, an error is generated and the execution stops.
	kSint64AdditionWithExceptions,
	// Pops a value from the thread's value stack and stores it into a 8 bit global variable.
	kStoreRaw8,
	// Pops a value from the thread's value stack and stores it into a 16 bit global variable.
	kStoreRaw16,
	// Pops a value from the thread's value stack and stores it into a 32 bit global variable.
	kStoreRaw32,
	// Pops a value from the thread's value stack and stores it into a 64 bit global variable.
	kStoreRaw64,
	// Pops a value from the stack, releases the old value of the global variable and stores the new
	// value.
	kStoreReferenceCounted,
	// Pops several strings from the stack, concatenates them and pushes the result to the stack.
	kStringConcatenation,
	// Pops two 8 bit unsigned integers from the stack, adds them and pushes the result to the stack.
	// If an overflow occurs, an error is generated and the execution stops.
	kUint8AdditionWithExceptions,
	// Pops two 16 bit unsigned integers from the stack, adds them and pushes the result to the stack.
	// If an overflow occurs, an error is generated and the execution stops.
	kUint16AdditionWithExceptions,
	// Pops two 32 bit unsigned integers from the stack, adds them and pushes the result to the stack.
	// If an overflow occurs, an error is generated and the execution stops.
	kUint32AdditionWithExceptions,
	// Pops two 64 bit unsigned integers from the stack, adds them and pushes the result to the stack.
	// If an overflow occurs, an error is generated and the execution stops.
	kUint64AdditionWithExceptions,
	};

	// Defines some code. This can represent the code for one function or the code for the pending
	// instructions of one execution context.
	class Code {
	public:
	Code() = default;

	const std::vector<uint64_t>& code() const { return code_; }

	// Adds an emit result.
	void EmitResult(std::unique_ptr<Type> type) {
	emplace_back_opcode(Opcode::kEmitResult);
	code_.emplace_back(reinterpret_cast<uint64_t>(type.get()));
	types_.emplace_back(std::move(type));
	}

	// Adds an integer addition.
	void IntegerAddition(bool with_exceptions, size_t size, bool is_signed) {
	switch (size) {
	case 1:
	emplace_back_opcode(with_exceptions ? (is_signed ? Opcode::kSint8AdditionWithExceptions
	: Opcode::kUint8AdditionWithExceptions)
	: Opcode::kInt8Addition);
	break;
	case 2:
	emplace_back_opcode(with_exceptions ? (is_signed ? Opcode::kSint16AdditionWithExceptions
	: Opcode::kUint16AdditionWithExceptions)
	: Opcode::kInt16Addition);
	break;
	case 4:
	emplace_back_opcode(with_exceptions ? (is_signed ? Opcode::kSint32AdditionWithExceptions
	: Opcode::kUint32AdditionWithExceptions)
	: Opcode::kInt32Addition);
	break;
	case 8:
	emplace_back_opcode(with_exceptions ? (is_signed ? Opcode::kSint64AdditionWithExceptions
	: Opcode::kUint64AdditionWithExceptions)
	: Opcode::kInt64Addition);
	break;
	default:
	FX_LOGS(FATAL) << "Bad integer size " << size;
	}
	}

	// Adds a 64 bit literal operation.
	void Literal64(uint64_t value) {
	emplace_back_opcode(Opcode::kLiteral64);
	code_.emplace_back(value);
	}

	// Adds a 64 bit literal operation.
	void LoadReferenceCounted(size_t index) {
	emplace_back_opcode(Opcode::kLoadReferenceCounted);
	code_.emplace_back(index);
	}

	// Adds a global variable load operation.
	void LoadRaw(size_t index, size_t size) {
	switch (size) {
	case 1:
	emplace_back_opcode(Opcode::kLoadRaw8);
	break;
	case 2:
	emplace_back_opcode(Opcode::kLoadRaw16);
	break;
	case 4:
	emplace_back_opcode(Opcode::kLoadRaw32);
	break;
	case 8:
	emplace_back_opcode(Opcode::kLoadRaw64);
	break;
	default:
	FX_LOGS(FATAL) << "Bad builtin size " << size;
	}
	code_.emplace_back(index);
	}

	// Adds a ret operation.
	void Ret() { emplace_back_opcode(Opcode::kRet); }

	// Adds a global variable store operation.
	void StoreRaw(uint64_t index, uint64_t size) {
	switch (size) {
	case 1:
	emplace_back_opcode(Opcode::kStoreRaw8);
	break;
	case 2:
	emplace_back_opcode(Opcode::kStoreRaw16);
	break;
	case 4:
	emplace_back_opcode(Opcode::kStoreRaw32);
	break;
	case 8:
	emplace_back_opcode(Opcode::kStoreRaw64);
	break;
	default:
	FX_LOGS(FATAL) << "Bad builtin size " << size;
	}
	code_.emplace_back(index);
	}

	// Adds a reference counted global variable store operation.
	void StoreReferenceCounted(uint64_t index) {
	emplace_back_opcode(Opcode::kStoreReferenceCounted);
	code_.emplace_back(index);
	}

	// Adds a string concatenation operation.
	void StringConcatenation(size_t string_count) {
	emplace_back_opcode(Opcode::kStringConcatenation);
	code_.emplace_back(string_count);
	}

	// Adds a string literal operation.
	void StringLiteral(String* value) {
	strings_.emplace_back(value);
	emplace_back_opcode(Opcode::kReferenceCountedLiteral);
	code_.emplace_back(reinterpret_cast<uint64_t>(value));
	}

	// Adds an operation that allocates an object and leaves a reference to it on the stack.
	void ObjectPush(const std::shared_ptr<ObjectSchema>& object_schema) {
	emplace_back_opcode(Opcode::kObjectNew);
	auto ref = object_schemas_.insert(object_schema);
	// We store the shared_ptr so that the object that later gets allocated can ref and deref it.
	const std::shared_ptr<ObjectSchema>* ptr = &(*(ref.first));
	code_.emplace_back(reinterpret_cast<uint64_t>(ptr));
	}

	// Adds an operation that initializes an object.
	void ObjectInit() { emplace_back_opcode(Opcode::kObjectInit); }

	private:
	void emplace_back_opcode(Opcode opcode) { code_.emplace_back(static_cast<uint64_t>(opcode)); }

	struct SchemaPtrLT {
	constexpr bool operator()(const std::shared_ptr<ObjectSchema>& lhs,
	const std::shared_ptr<ObjectSchema>& rhs) const {
	return lhs.get() < rhs.get();
	}
	};

	// Tracking for the schemas used as arguments by the code. Because schemas are managed by
	// shared_ptrs, and code_ only stores opaque values.
	std::set<std::shared_ptr<ObjectSchema>, SchemaPtrLT> object_schemas_;

	// Contains the operations. It's a mix of opcodes and arguments for the operations.
	std::vector<uint64_t> code_;

	// Keeps alive the string literals in the code.
	std::vector<StringContainer> strings_;

	// Keeps alive the types in the code.
	std::vector<std::unique_ptr<Type>> types_;
	};

	} // namespace code
	} // namespace interpreter
	} // namespace shell

	#endif // SRC_DEVELOPER_SHELL_INTERPRETER_SRC_CODE_H_