lldb/source/Plugins/SystemRuntime/MacOSX/AbortWithPayloadFrameRecognizer.cpp - llvm-project - Git at Google


            
            //===-- AbortWithPayloadFrameRecognizer.cpp -------------------------------===//

            
            //

            
            // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

            
            // See https://llvm.org/LICENSE.txt for license information.

            
            // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

            
            //

            
            //===----------------------------------------------------------------------===//


            #include "AbortWithPayloadFrameRecognizer.h"


            #include "lldb/Core/Value.h"

            
            #include "lldb/Target/ABI.h"

            
            #include "lldb/Target/Process.h"

            
            #include "lldb/Target/StackFrame.h"

            
            #include "lldb/Target/Target.h"

            
            #include "lldb/Target/Thread.h"

            
            #include "lldb/Utility/LLDBLog.h"

            
            #include "lldb/Utility/Log.h"

            
            #include "lldb/Utility/StructuredData.h"

            
            #include "lldb/ValueObject/ValueObjectConstResult.h"


            #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"


            using namespace lldb;

            
            using namespace lldb_private;


            namespace lldb_private {

            
            void RegisterAbortWithPayloadFrameRecognizer(Process *process) {

            
              // There are two user-level API's that this recognizer captures,

            
              // abort_with_reason and abort_with_payload.  But they both call the private

            
              // __abort_with_payload, the abort_with_reason call fills in a null payload.

            
              static ConstString sym_name("__abort_with_payload");


              if (!process)

            
                return;


              std::string module_name("libsystem_kernel.dylib");

            
              process->GetTarget().GetFrameRecognizerManager().AddRecognizer(

            
                  std::make_shared<AbortWithPayloadFrameRecognizer>(), module_name,

            
                  {sym_name}, Mangled::NamePreference::ePreferDemangled,

            
                  /*first_instruction_only*/ false);

            
            }


            RecognizedStackFrameSP

            
            AbortWithPayloadFrameRecognizer::RecognizeFrame(lldb::StackFrameSP frame_sp) {

            
              // We have two jobs:

            
              // 1) to add the data passed to abort_with_payload to the

            
              //    ExtraCrashInformation dictionary.

            
              // 2) To make up faux arguments for this frame.

            
              static constexpr llvm::StringLiteral namespace_key("namespace");

            
              static constexpr llvm::StringLiteral code_key("code");

            
              static constexpr llvm::StringLiteral payload_addr_key("payload_addr");

            
              static constexpr llvm::StringLiteral payload_size_key("payload_size");

            
              static constexpr llvm::StringLiteral reason_key("reason");

            
              static constexpr llvm::StringLiteral flags_key("flags");

            
              static constexpr llvm::StringLiteral info_key("abort_with_payload");


              Log *log = GetLog(LLDBLog::SystemRuntime);


              if (!frame_sp) {

            
                LLDB_LOG(log, "abort_with_payload recognizer: invalid frame.");

            
                return {};

            
              }


              Thread *thread = frame_sp->GetThread().get();

            
              if (!thread) {

            
                LLDB_LOG(log, "abort_with_payload recognizer: invalid thread.");

            
                return {};

            
              }


              Process *process = thread->GetProcess().get();

            
              if (!thread) {

            
                LLDB_LOG(log, "abort_with_payload recognizer: invalid process.");

            
              }


              TypeSystemClangSP scratch_ts_sp =

            
                  ScratchTypeSystemClang::GetForTarget(process->GetTarget());

            
              if (!scratch_ts_sp) {

            
                LLDB_LOG(log, "abort_with_payload recognizer: invalid scratch typesystem.");

            
                return {};

            
              }


              // The abort_with_payload signature is:

            
              // abort_with_payload(uint32_t reason_namespace, uint64_t reason_code,

            
              //                      void* payload, uint32_t payload_size,

            
              //                      const char* reason_string, uint64_t reason_flags);


              ValueList arg_values;

            
              Value input_value_32;

            
              Value input_value_64;

            
              Value input_value_void_ptr;

            
              Value input_value_char_ptr;


              CompilerType clang_void_ptr_type =

            
                  scratch_ts_sp->GetBasicType(eBasicTypeVoid).GetPointerType();

            
              CompilerType clang_char_ptr_type =

            
                  scratch_ts_sp->GetBasicType(eBasicTypeChar).GetPointerType();

            
              CompilerType clang_uint64_type =

            
                  scratch_ts_sp->GetBuiltinTypeForEncodingAndBitSize(lldb::eEncodingUint,

            
                                                                     64);

            
              CompilerType clang_uint32_type =

            
                  scratch_ts_sp->GetBuiltinTypeForEncodingAndBitSize(lldb::eEncodingUint,

            
                                                                     32);

            
              CompilerType clang_char_star_type =

            
                  scratch_ts_sp->GetBuiltinTypeForEncodingAndBitSize(lldb::eEncodingUint,

            
                                                                     64);


              input_value_32.SetValueType(Value::ValueType::Scalar);

            
              input_value_32.SetCompilerType(clang_uint32_type);

            
              input_value_64.SetValueType(Value::ValueType::Scalar);

            
              input_value_64.SetCompilerType(clang_uint64_type);

            
              input_value_void_ptr.SetValueType(Value::ValueType::Scalar);

            
              input_value_void_ptr.SetCompilerType(clang_void_ptr_type);

            
              input_value_char_ptr.SetValueType(Value::ValueType::Scalar);

            
              input_value_char_ptr.SetCompilerType(clang_char_ptr_type);


              arg_values.PushValue(input_value_32);

            
              arg_values.PushValue(input_value_64);

            
              arg_values.PushValue(input_value_void_ptr);

            
              arg_values.PushValue(input_value_32);

            
              arg_values.PushValue(input_value_char_ptr);

            
              arg_values.PushValue(input_value_64);


              lldb::ABISP abi_sp = process->GetABI();

            
              bool success = abi_sp->GetArgumentValues(*thread, arg_values);

            
              if (!success)

            
                return {};


              Value *cur_value;

            
              StackFrame *frame = frame_sp.get();

            
              ValueObjectListSP arguments_sp = std::make_shared<ValueObjectList>();


              auto add_to_arguments = [&](llvm::StringRef name, Value *value,

            
                                          bool dynamic) {

            
                ValueObjectSP cur_valobj_sp =

            
                    ValueObjectConstResult::Create(frame, *value, ConstString(name));

            
                cur_valobj_sp = ValueObjectRecognizerSynthesizedValue::Create(

            
                    *cur_valobj_sp, eValueTypeVariableArgument);

            
                ValueObjectSP dyn_valobj_sp;

            
                if (dynamic) {

            
                  dyn_valobj_sp = cur_valobj_sp->GetDynamicValue(eDynamicDontRunTarget);

            
                  if (dyn_valobj_sp)

            
                    cur_valobj_sp = dyn_valobj_sp;

            
                }

            
                arguments_sp->Append(cur_valobj_sp);

            
              };


              // Decode the arg_values:


              uint32_t namespace_val = 0;

            
              cur_value = arg_values.GetValueAtIndex(0);

            
              add_to_arguments(namespace_key, cur_value, false);

            
              namespace_val = cur_value->GetScalar().UInt(namespace_val);


              uint32_t code_val = 0;

            
              cur_value = arg_values.GetValueAtIndex(1);

            
              add_to_arguments(code_key, cur_value, false);

            
              code_val = cur_value->GetScalar().UInt(code_val);


              lldb::addr_t payload_addr = LLDB_INVALID_ADDRESS;

            
              cur_value = arg_values.GetValueAtIndex(2);

            
              add_to_arguments(payload_addr_key, cur_value, true);

            
              payload_addr = cur_value->GetScalar().ULongLong(payload_addr);


              uint32_t payload_size = 0;

            
              cur_value = arg_values.GetValueAtIndex(3);

            
              add_to_arguments(payload_size_key, cur_value, false);

            
              payload_size = cur_value->GetScalar().UInt(payload_size);


              lldb::addr_t reason_addr = LLDB_INVALID_ADDRESS;

            
              cur_value = arg_values.GetValueAtIndex(4);

            
              add_to_arguments(reason_key, cur_value, false);

            
              reason_addr = cur_value->GetScalar().ULongLong(payload_addr);


              // For the reason string, we want the string not the address, so fetch that.

            
              std::string reason_string;

            
              Status error;

            
              process->ReadCStringFromMemory(reason_addr, reason_string, error);

            
              if (error.Fail()) {

            
                // Even if we couldn't read the string, return the other data.

            
                LLDB_LOG(log, "Couldn't fetch reason string: {0}.", error);

            
                reason_string = "<error fetching reason string>";

            
              }


              uint32_t flags_val = 0;

            
              cur_value = arg_values.GetValueAtIndex(5);

            
              add_to_arguments(flags_key, cur_value, false);

            
              flags_val = cur_value->GetScalar().UInt(flags_val);


              // Okay, we've gotten all the argument values, now put them in a

            
              // StructuredData, and add that to the Process ExtraCrashInformation:

            
              StructuredData::DictionarySP abort_dict_sp(new StructuredData::Dictionary());

            
              abort_dict_sp->AddIntegerItem(namespace_key, namespace_val);

            
              abort_dict_sp->AddIntegerItem(code_key, code_val);

            
              abort_dict_sp->AddIntegerItem(payload_addr_key, payload_addr);

            
              abort_dict_sp->AddIntegerItem(payload_size_key, payload_size);

            
              abort_dict_sp->AddStringItem(reason_key, reason_string);

            
              abort_dict_sp->AddIntegerItem(flags_key, flags_val);


              // This will overwrite the abort_with_payload information in the dictionary

            
              // already.  But we can only crash on abort_with_payload once, so that

            
              // shouldn't matter.

            
              process->GetExtendedCrashInfoDict()->AddItem(info_key, abort_dict_sp);


              return RecognizedStackFrameSP(

            
                  new AbortWithPayloadRecognizedStackFrame(frame_sp, arguments_sp));

            
            }


            AbortWithPayloadRecognizedStackFrame::AbortWithPayloadRecognizedStackFrame(

            
                lldb::StackFrameSP &frame_sp, ValueObjectListSP &args_sp)

            
                : RecognizedStackFrame() {

            
              m_arguments = args_sp;

            
              m_stop_desc = "abort with payload or reason";

            
            }


            } // namespace lldb_private
	//===-- AbortWithPayloadFrameRecognizer.cpp -------------------------------===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//

	#include "AbortWithPayloadFrameRecognizer.h"

	#include "lldb/Core/Value.h"
	#include "lldb/Target/ABI.h"
	#include "lldb/Target/Process.h"
	#include "lldb/Target/StackFrame.h"
	#include "lldb/Target/Target.h"
	#include "lldb/Target/Thread.h"
	#include "lldb/Utility/LLDBLog.h"
	#include "lldb/Utility/Log.h"
	#include "lldb/Utility/StructuredData.h"
	#include "lldb/ValueObject/ValueObjectConstResult.h"

	#include "Plugins/TypeSystem/Clang/TypeSystemClang.h"

	using namespace lldb;
	using namespace lldb_private;

	namespace lldb_private {
	void RegisterAbortWithPayloadFrameRecognizer(Process *process) {
	// There are two user-level API's that this recognizer captures,
	// abort_with_reason and abort_with_payload. But they both call the private
	// __abort_with_payload, the abort_with_reason call fills in a null payload.
	static ConstString sym_name("__abort_with_payload");

	if (!process)
	return;

	std::string module_name("libsystem_kernel.dylib");
	process->GetTarget().GetFrameRecognizerManager().AddRecognizer(
	std::make_shared<AbortWithPayloadFrameRecognizer>(), module_name,
	{sym_name}, Mangled::NamePreference::ePreferDemangled,
	/first_instruction_only/ false);
	}

	RecognizedStackFrameSP
	AbortWithPayloadFrameRecognizer::RecognizeFrame(lldb::StackFrameSP frame_sp) {
	// We have two jobs:
	// 1) to add the data passed to abort_with_payload to the
	// ExtraCrashInformation dictionary.
	// 2) To make up faux arguments for this frame.
	static constexpr llvm::StringLiteral namespace_key("namespace");
	static constexpr llvm::StringLiteral code_key("code");
	static constexpr llvm::StringLiteral payload_addr_key("payload_addr");
	static constexpr llvm::StringLiteral payload_size_key("payload_size");
	static constexpr llvm::StringLiteral reason_key("reason");
	static constexpr llvm::StringLiteral flags_key("flags");
	static constexpr llvm::StringLiteral info_key("abort_with_payload");

	Log *log = GetLog(LLDBLog::SystemRuntime);

	if (!frame_sp) {
	LLDB_LOG(log, "abort_with_payload recognizer: invalid frame.");
	return {};
	}

	Thread *thread = frame_sp->GetThread().get();
	if (!thread) {
	LLDB_LOG(log, "abort_with_payload recognizer: invalid thread.");
	return {};
	}

	Process *process = thread->GetProcess().get();
	if (!thread) {
	LLDB_LOG(log, "abort_with_payload recognizer: invalid process.");
	}

	TypeSystemClangSP scratch_ts_sp =
	ScratchTypeSystemClang::GetForTarget(process->GetTarget());
	if (!scratch_ts_sp) {
	LLDB_LOG(log, "abort_with_payload recognizer: invalid scratch typesystem.");
	return {};
	}

	// The abort_with_payload signature is:
	// abort_with_payload(uint32_t reason_namespace, uint64_t reason_code,
	// void* payload, uint32_t payload_size,
	// const char* reason_string, uint64_t reason_flags);

	ValueList arg_values;
	Value input_value_32;
	Value input_value_64;
	Value input_value_void_ptr;
	Value input_value_char_ptr;

	CompilerType clang_void_ptr_type =
	scratch_ts_sp->GetBasicType(eBasicTypeVoid).GetPointerType();
	CompilerType clang_char_ptr_type =
	scratch_ts_sp->GetBasicType(eBasicTypeChar).GetPointerType();
	CompilerType clang_uint64_type =
	scratch_ts_sp->GetBuiltinTypeForEncodingAndBitSize(lldb::eEncodingUint,
	64);
	CompilerType clang_uint32_type =
	scratch_ts_sp->GetBuiltinTypeForEncodingAndBitSize(lldb::eEncodingUint,
	32);
	CompilerType clang_char_star_type =
	scratch_ts_sp->GetBuiltinTypeForEncodingAndBitSize(lldb::eEncodingUint,
	64);

	input_value_32.SetValueType(Value::ValueType::Scalar);
	input_value_32.SetCompilerType(clang_uint32_type);
	input_value_64.SetValueType(Value::ValueType::Scalar);
	input_value_64.SetCompilerType(clang_uint64_type);
	input_value_void_ptr.SetValueType(Value::ValueType::Scalar);
	input_value_void_ptr.SetCompilerType(clang_void_ptr_type);
	input_value_char_ptr.SetValueType(Value::ValueType::Scalar);
	input_value_char_ptr.SetCompilerType(clang_char_ptr_type);

	arg_values.PushValue(input_value_32);
	arg_values.PushValue(input_value_64);
	arg_values.PushValue(input_value_void_ptr);
	arg_values.PushValue(input_value_32);
	arg_values.PushValue(input_value_char_ptr);
	arg_values.PushValue(input_value_64);

	lldb::ABISP abi_sp = process->GetABI();
	bool success = abi_sp->GetArgumentValues(*thread, arg_values);
	if (!success)
	return {};

	Value *cur_value;
	StackFrame *frame = frame_sp.get();
	ValueObjectListSP arguments_sp = std::make_shared<ValueObjectList>();

	auto add_to_arguments = [&](llvm::StringRef name, Value *value,
	bool dynamic) {
	ValueObjectSP cur_valobj_sp =
	ValueObjectConstResult::Create(frame, *value, ConstString(name));
	cur_valobj_sp = ValueObjectRecognizerSynthesizedValue::Create(
	*cur_valobj_sp, eValueTypeVariableArgument);
	ValueObjectSP dyn_valobj_sp;
	if (dynamic) {
	dyn_valobj_sp = cur_valobj_sp->GetDynamicValue(eDynamicDontRunTarget);
	if (dyn_valobj_sp)
	cur_valobj_sp = dyn_valobj_sp;
	}
	arguments_sp->Append(cur_valobj_sp);
	};

	// Decode the arg_values:

	uint32_t namespace_val = 0;
	cur_value = arg_values.GetValueAtIndex(0);
	add_to_arguments(namespace_key, cur_value, false);
	namespace_val = cur_value->GetScalar().UInt(namespace_val);

	uint32_t code_val = 0;
	cur_value = arg_values.GetValueAtIndex(1);
	add_to_arguments(code_key, cur_value, false);
	code_val = cur_value->GetScalar().UInt(code_val);

	lldb::addr_t payload_addr = LLDB_INVALID_ADDRESS;
	cur_value = arg_values.GetValueAtIndex(2);
	add_to_arguments(payload_addr_key, cur_value, true);
	payload_addr = cur_value->GetScalar().ULongLong(payload_addr);

	uint32_t payload_size = 0;
	cur_value = arg_values.GetValueAtIndex(3);
	add_to_arguments(payload_size_key, cur_value, false);
	payload_size = cur_value->GetScalar().UInt(payload_size);

	lldb::addr_t reason_addr = LLDB_INVALID_ADDRESS;
	cur_value = arg_values.GetValueAtIndex(4);
	add_to_arguments(reason_key, cur_value, false);
	reason_addr = cur_value->GetScalar().ULongLong(payload_addr);

	// For the reason string, we want the string not the address, so fetch that.
	std::string reason_string;
	Status error;
	process->ReadCStringFromMemory(reason_addr, reason_string, error);
	if (error.Fail()) {
	// Even if we couldn't read the string, return the other data.
	LLDB_LOG(log, "Couldn't fetch reason string: {0}.", error);
	reason_string = "<error fetching reason string>";
	}

	uint32_t flags_val = 0;
	cur_value = arg_values.GetValueAtIndex(5);
	add_to_arguments(flags_key, cur_value, false);
	flags_val = cur_value->GetScalar().UInt(flags_val);

	// Okay, we've gotten all the argument values, now put them in a
	// StructuredData, and add that to the Process ExtraCrashInformation:
	StructuredData::DictionarySP abort_dict_sp(new StructuredData::Dictionary());
	abort_dict_sp->AddIntegerItem(namespace_key, namespace_val);
	abort_dict_sp->AddIntegerItem(code_key, code_val);
	abort_dict_sp->AddIntegerItem(payload_addr_key, payload_addr);
	abort_dict_sp->AddIntegerItem(payload_size_key, payload_size);
	abort_dict_sp->AddStringItem(reason_key, reason_string);
	abort_dict_sp->AddIntegerItem(flags_key, flags_val);

	// This will overwrite the abort_with_payload information in the dictionary
	// already. But we can only crash on abort_with_payload once, so that
	// shouldn't matter.
	process->GetExtendedCrashInfoDict()->AddItem(info_key, abort_dict_sp);

	return RecognizedStackFrameSP(
	new AbortWithPayloadRecognizedStackFrame(frame_sp, arguments_sp));
	}

	AbortWithPayloadRecognizedStackFrame::AbortWithPayloadRecognizedStackFrame(
	lldb::StackFrameSP &frame_sp, ValueObjectListSP &args_sp)
	: RecognizedStackFrame() {
	m_arguments = args_sp;
	m_stop_desc = "abort with payload or reason";
	}

	} // namespace lldb_private