dart::AssemblerTest Class Reference

#include <unit_test.h>

Public Member Functions
	AssemblerTest (const char *name, compiler::Assembler *assembler, Zone *zone)
	~AssemblerTest ()
compiler::Assembler *	assembler () const
const Code &	code () const
uword	payload_start () const
uword	payload_size () const
uword	entry () const
template<typename ResultType >
ResultType	InvokeWithCodeAndThread ()
template<typename ResultType , typename Arg1Type >
ResultType	InvokeWithCodeAndThread (Arg1Type arg1)
template<typename ResultType , typename Arg1Type >
ResultType	Invoke (Arg1Type arg1)
template<typename ResultType , typename Arg1Type , typename Arg2Type , typename Arg3Type >
ResultType	Invoke (Arg1Type arg1, Arg2Type arg2, Arg3Type arg3)
void	Assemble ()
char *	RelativeDisassembly ()

Static Public Member Functions
static const Code &	Generate (const char *name, const std::function< void(compiler::Assembler *assembler)> &generator)

Detailed Description

Definition at line 503 of file unit_test.h.

Constructor & Destructor Documentation

AssemblerTest()

dart::AssemblerTest::AssemblerTest ( const char *  name, compiler::Assembler *  assembler, Zone *  zone  )

inline

Definition at line 505 of file unit_test.h.

      : name_(name),
        assembler_(assembler),
        code_(Code::ZoneHandle(zone)),
        disassembly_(zone->Alloc<char>(DISASSEMBLY_SIZE)) {
    ASSERT(name != nullptr);
    ASSERT(assembler != nullptr);
  }

~AssemblerTest()

dart::AssemblerTest::~AssemblerTest ( )

inline

Definition at line 513 of file unit_test.h.

{}

Member Function Documentation

Assemble()

void dart::AssemblerTest::Assemble

(

)

Definition at line 703 of file unit_test.cc.

                             {
  auto thread = Thread::Current();
  const String& function_name = String::ZoneHandle(Symbols::New(thread, name_));
 
  // We make a dummy script so that exception objects can be composed for
  // assembler instructions that do runtime calls.
  const char* kDummyScript = "assembler_test_dummy_function() {}";
  const Script& script = Script::Handle(
      Script::New(function_name, String::Handle(String::New(kDummyScript))));
  const Library& lib = Library::Handle(Library::CoreLibrary());
  const Class& cls = Class::ZoneHandle(
      Class::New(lib, function_name, script, TokenPosition::kMinSource));
  const FunctionType& signature = FunctionType::ZoneHandle(FunctionType::New());
  Function& function = Function::ZoneHandle(Function::New(
      signature, function_name, UntaggedFunction::kRegularFunction, true, false,
      false, false, false, cls, TokenPosition::kMinSource));
  SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
  code_ = Code::FinalizeCodeAndNotify(function, nullptr, assembler_,
                                      Code::PoolAttachment::kAttachPool);
  code_.set_owner(function);
  code_.set_exception_handlers(Object::empty_exception_handlers());
#ifndef PRODUCT
  // Disassemble relative since code addresses are not stable from run to run.
  SetFlagScope<bool> sfs(&FLAG_disassemble_relative, true);
  uword start = code_.PayloadStart();
  if (FLAG_disassemble) {
    OS::PrintErr("Code for test '%s' {\n", name_);
    Disassembler::Disassemble(start, start + assembler_->CodeSize());
    OS::PrintErr("}\n");
  }
  Disassembler::Disassemble(start, start + assembler_->CodeSize(), disassembly_,
                            DISASSEMBLY_SIZE);
#if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64)
  // Blank out absolute addressing constants on ia32, since they are not stable
  // from run to run.
  // Blank out thread-relative offsets on x64 since they change when new fields
  // are added to thread object.
  bool in_hex_constant = false;
  for (char* p = disassembly_; *p != '\0'; p++) {
    if (in_hex_constant) {
      if (IsHex(*p)) {
        *p = '.';
      } else {
        in_hex_constant = false;
      }
    } else {
#if defined(TARGET_ARCH_IA32)
      if (*p == '[' && *(p + 1) == '0' && *(p + 2) == 'x' && IsHex(*(p + 3)) &&
          IsHex(*(p + 4))) {
        p += 2;
        in_hex_constant = true;
      }
#endif  // defined(TARGET_ARCH_IA32)
#if defined(TARGET_ARCH_X64)
      if (*p == '[' && *(p + 1) == 't' && *(p + 2) == 'h' && *(p + 3) == 'r' &&
          *(p + 4) == '+' && *(p + 5) == '0' && *(p + 6) == 'x' &&
          IsHex(*(p + 7)) && IsHex(*(p + 8))) {
        p += 6;
        in_hex_constant = true;
      }
#endif  // defined(TARGET_ARCH_X64)
    }
  }
#endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64)
#endif  // !PRODUCT
}

assembler()

compiler::Assembler * dart::AssemblerTest::assembler ( ) const

inline

Definition at line 515 of file unit_test.h.

{ return assembler_; }

code()

const Code & dart::AssemblerTest::code ( ) const

inline

Definition at line 517 of file unit_test.h.

{ return code_; }

entry()

uword dart::AssemblerTest::entry ( ) const

inline

Definition at line 521 of file unit_test.h.

{ return code_.EntryPoint(); }

Generate()

const Code & dart::AssemblerTest::Generate ( const char *  name, const std::function< void(compiler::Assembler *assembler)> &  generator  )

static

Definition at line 770 of file unit_test.cc.

                                                                      {
  compiler::ObjectPoolBuilder object_pool_builder;
  compiler::Assembler assembler(&object_pool_builder, /*far_branch_level=*/0);
  AssemblerTest test(name, &assembler, Thread::Current()->zone());
  assembler.Ret();
  test.Assemble();
  return test.code();
}

Invoke() [1/2]

template<typename ResultType , typename Arg1Type >

ResultType dart::AssemblerTest::Invoke ( Arg1Type  arg1 )

inline

Definition at line 601 of file unit_test.h.

                                   {
    typedef ResultType (*FunctionType)(Arg1Type);
    return reinterpret_cast<FunctionType>(entry())(arg1);
  }

Invoke() [2/2]

template<typename ResultType , typename Arg1Type , typename Arg2Type , typename Arg3Type >

ResultType dart::AssemblerTest::Invoke ( Arg1Type  arg1, Arg2Type  arg2, Arg3Type  arg3  )

inline

Definition at line 610 of file unit_test.h.

                                                                 {
    typedef ResultType (*FunctionType)(Arg1Type, Arg2Type, Arg3Type);
    return reinterpret_cast<FunctionType>(entry())(arg1, arg2, arg3);
  }

InvokeWithCodeAndThread() [1/2]

template<typename ResultType >

ResultType dart::AssemblerTest::InvokeWithCodeAndThread ( )

inline

Definition at line 585 of file unit_test.h.

                                       {
    Thread* thread = Thread::Current();
    ASSERT(thread != nullptr);
    typedef ResultType (*FunctionType)(CodePtr, Thread*);
    return reinterpret_cast<FunctionType>(entry())(code_.ptr(), thread);
  }

InvokeWithCodeAndThread() [2/2]

template<typename ResultType , typename Arg1Type >

ResultType dart::AssemblerTest::InvokeWithCodeAndThread ( Arg1Type  arg1 )

inline

Definition at line 593 of file unit_test.h.

                                                    {
    Thread* thread = Thread::Current();
    ASSERT(thread != nullptr);
    typedef ResultType (*FunctionType)(CodePtr, Thread*, Arg1Type);
    return reinterpret_cast<FunctionType>(entry())(code_.ptr(), thread, arg1);
  }

payload_size()

uword dart::AssemblerTest::payload_size ( ) const

inline

Definition at line 520 of file unit_test.h.

{ return assembler_->CodeSize(); }

payload_start()

uword dart::AssemblerTest::payload_start ( ) const

inline

Definition at line 519 of file unit_test.h.

{ return code_.PayloadStart(); }

RelativeDisassembly()

char * dart::AssemblerTest::RelativeDisassembly ( )

inline

Definition at line 620 of file unit_test.h.

{ return disassembly_; }

---

The documentation for this class was generated from the following files:

• third_party/dart-lang/sdk/runtime/vm/unit_test.h
• third_party/dart-lang/sdk/runtime/vm/unit_test.cc