Method TranslateBasicBlock

3rdParty/tinydbr/tinydbr.cpp:644–743

}

void TinyDBR::TranslateBasicBlock(char*                                     address,
								  ModuleInfo*                               module,
								  std::set<char*>*                          queue,
								  std::list<std::pair<uint32_t, uint32_t>>* offset_fixes)
{
	uint32_t original_offset   = (uint32_t)((size_t)address - (size_t)(module->min_address));
	uint32_t translated_offset = (uint32_t)module->instrumented_code_allocated;

	unwind_generator->OnBasicBlockStart(module,
										(size_t)address,
										GetCurrentInstrumentedAddress(module));

	//printf("[%08X]: Instrumenting bb, original at %p, instrumented at %p\n",
	//	   GetCurTid(), address, module->instrumented_code_remote + translated_offset);

	module->basic_blocks.insert({ original_offset, translated_offset });

	AddressRange* range = GetRegion(module, (size_t)address);
	if (!range)
	{
		// just insert a jump to address
		assembler_->JmpAddress(module, (size_t)address);
		return;
	}

	uint32_t range_offset = (uint32_t)((size_t)address - (size_t)range->from);
	size_t   code_size    = (uint32_t)((size_t)range->to - (size_t)address);
	char*    code_ptr     = range->data + range_offset;

	size_t offset = 0, last_offset = 0;

	if (trace_basic_blocks)
	{
		size_t breakpoint_address = GetCurrentInstrumentedAddress(module);
		assembler_->Breakpoint(module);
		module->tracepoints[breakpoint_address] = (size_t)address;
	}

	// write pre-bb instrumentation
	InstrumentBasicBlock(module, (size_t)address);

	Instruction inst;
	while (true)
	{
		bool success =
			assembler_->DecodeInstruction(
				inst,
				(const unsigned char*)(code_ptr + offset),
				(unsigned int)(code_size - offset));

		if (!success)
			break;

		unwind_generator->OnInstruction(module,
										(size_t)address + offset,
										GetCurrentInstrumentedAddress(module));

		// instruction-level-instrumentation