This revision seems to have created a hang on startup on Windows. LLDB now
hangs during global static initialization on this line:
const ConstString
RenderScriptRuntime::Element::FallbackStructName("struct");
Perhaps its an initialization order problem?
Adrian.
On Mon, Nov 30, 2015 at 2:29 AM, Ewan Crawford via lldb-commits <
lldb-commits@lists.llvm.org> wrote:
> Author: ewancrawford
> Date: Mon Nov 30 04:29:49 2015
> New Revision: 254294
>
> URL: http://llvm.org/viewvc/llvm-project?rev=254294&view=rev
> Log:
> [RS] Support RenderScript struct allocations
>
> This patch adds functionality for dumping allocations of struct elements.
> This involves:
>
> + Jitting the runtime for details on all the struct fields.
>
> + Finding the name of the struct type by looking for a global variable
> of the same type, which will have been reflected back to the java host code.
>
> + Using this struct type name to pass into expression evaluation for
> pretty printing the data for the dump command.
>
> Modified:
>
> lldb/trunk/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp
>
> lldb/trunk/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h
>
> Modified:
> lldb/trunk/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp?rev=254294&r1=254293&r2=254294&view=diff
>
> ==============================================================================
> ---
> lldb/trunk/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp
> (original)
> +++
> lldb/trunk/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp
> Mon Nov 30 04:29:49 2015
> @@ -18,7 +18,9 @@
> #include "lldb/Core/Error.h"
> #include "lldb/Core/Log.h"
> #include "lldb/Core/PluginManager.h"
> +#include "lldb/Core/ValueObjectVariable.h"
> #include "lldb/Core/RegularExpression.h"
> +#include "lldb/DataFormatters/DumpValueObjectOptions.h"
> #include "lldb/Host/StringConvert.h"
> #include "lldb/Symbol/Symbol.h"
> #include "lldb/Symbol/Type.h"
> @@ -133,42 +135,61 @@ struct RenderScriptRuntime::ScriptDetail
> empirical_type<lldb::addr_t> script;
> };
>
> +// This Element class represents the Element object in RS,
> +// defining the type associated with an Allocation.
> +struct RenderScriptRuntime::Element
> +{
> + // Taken from rsDefines.h
> + enum DataKind
> + {
> + RS_KIND_USER,
> + RS_KIND_PIXEL_L = 7,
> + RS_KIND_PIXEL_A,
> + RS_KIND_PIXEL_LA,
> + RS_KIND_PIXEL_RGB,
> + RS_KIND_PIXEL_RGBA,
> + RS_KIND_PIXEL_DEPTH,
> + RS_KIND_PIXEL_YUV,
> + RS_KIND_INVALID = 100
> + };
> +
> + // Taken from rsDefines.h
> + enum DataType
> + {
> + RS_TYPE_NONE = 0,
> + RS_TYPE_FLOAT_16,
> + RS_TYPE_FLOAT_32,
> + RS_TYPE_FLOAT_64,
> + RS_TYPE_SIGNED_8,
> + RS_TYPE_SIGNED_16,
> + RS_TYPE_SIGNED_32,
> + RS_TYPE_SIGNED_64,
> + RS_TYPE_UNSIGNED_8,
> + RS_TYPE_UNSIGNED_16,
> + RS_TYPE_UNSIGNED_32,
> + RS_TYPE_UNSIGNED_64,
> + RS_TYPE_BOOLEAN
> + };
> +
> + std::vector<Element> children; // Child Element
> fields for structs
> + empirical_type<lldb::addr_t> element_ptr; // Pointer to
> the RS Element of the Type
> + empirical_type<DataType> type; // Type of each
> data pointer stored by the allocation
> + empirical_type<DataKind> type_kind; // Defines pixel
> type if Allocation is created from an image
> + empirical_type<uint32_t> type_vec_size; // Vector size
> of each data point, e.g '4' for uchar4
> + empirical_type<uint32_t> field_count; // Number of
> Subelements
> + empirical_type<uint32_t> datum_size; // Size of a
> single Element with padding
> + empirical_type<uint32_t> padding; // Number of
> padding bytes
> + empirical_type<uint32_t> array_size; // Number of
> items in array, only needed for strucrs
> + ConstString type_name; // Name of type,
> only needed for structs
> +
> + static const ConstString FallbackStructName; // Print this as
> the type name of a struct Element
> + // If we can't
> resolve the actual struct name
> +};
> +
> // This AllocationDetails class collects data associated with a single
> // allocation instance.
> struct RenderScriptRuntime::AllocationDetails
> {
> - // Taken from rsDefines.h
> - enum DataKind
> - {
> - RS_KIND_USER,
> - RS_KIND_PIXEL_L = 7,
> - RS_KIND_PIXEL_A,
> - RS_KIND_PIXEL_LA,
> - RS_KIND_PIXEL_RGB,
> - RS_KIND_PIXEL_RGBA,
> - RS_KIND_PIXEL_DEPTH,
> - RS_KIND_PIXEL_YUV,
> - RS_KIND_INVALID = 100
> - };
> -
> - // Taken from rsDefines.h
> - enum DataType
> - {
> - RS_TYPE_NONE = 0,
> - RS_TYPE_FLOAT_16,
> - RS_TYPE_FLOAT_32,
> - RS_TYPE_FLOAT_64,
> - RS_TYPE_SIGNED_8,
> - RS_TYPE_SIGNED_16,
> - RS_TYPE_SIGNED_32,
> - RS_TYPE_SIGNED_64,
> - RS_TYPE_UNSIGNED_8,
> - RS_TYPE_UNSIGNED_16,
> - RS_TYPE_UNSIGNED_32,
> - RS_TYPE_UNSIGNED_64,
> - RS_TYPE_BOOLEAN
> - };
> -
> struct Dimension
> {
> uint32_t dim_1;
> @@ -214,14 +235,11 @@ struct RenderScriptRuntime::AllocationDe
> // for commands to reference it.
> const unsigned int id;
>
> - empirical_type<DataType> type; // Type of each data
> pointer stored by the allocation
> - empirical_type<DataKind> type_kind; // Defines pixel type if
> Allocation is created from an image
> - empirical_type<uint32_t> type_vec_size; // Vector size of each data
> point, e.g '4' for uchar4
> + RenderScriptRuntime::Element element; // Allocation Element type
> empirical_type<Dimension> dimension; // Dimensions of the
> Allocation
> empirical_type<lldb::addr_t> address; // Pointer to address of
> the RS Allocation
> empirical_type<lldb::addr_t> data_ptr; // Pointer to the data held
> by the Allocation
> empirical_type<lldb::addr_t> type_ptr; // Pointer to the RS Type
> of the Allocation
> - empirical_type<lldb::addr_t> element_ptr; // Pointer to the RS
> Element of the Type
> empirical_type<lldb::addr_t> context; // Pointer to the RS
> Context of the Allocation
> empirical_type<uint32_t> size; // Size of the allocation
> empirical_type<uint32_t> stride; // Stride between rows of
> the allocation
> @@ -232,6 +250,8 @@ struct RenderScriptRuntime::AllocationDe
> }
> };
>
> +const ConstString
> RenderScriptRuntime::Element::FallbackStructName("struct");
> +
> unsigned int RenderScriptRuntime::AllocationDetails::ID = 1;
>
> const char* RenderScriptRuntime::AllocationDetails::RsDataKindToString[] =
> @@ -1099,7 +1119,11 @@ enum ExpressionStrings
> eExprTypeElemPtr,
> eExprElementType,
> eExprElementKind,
> - eExprElementVec
> + eExprElementVec,
> + eExprElementFieldCount,
> + eExprSubelementsId,
> + eExprSubelementsName,
> + eExprSubelementsArrSize
> };
>
> // Format strings containing the expressions we may need to evaluate.
> @@ -1122,9 +1146,22 @@ const char runtimeExpressions[][256] =
>
> // rsaElementGetNativeData(Context*, Element*, uint32_t* elemData,size)
> // Pack mType; mKind; mNormalized; mVectorSize; NumSubElements into
> elemData
> - "uint32_t data[6]; (void*)rsaElementGetNativeData(0x%lx, 0x%lx, data,
> 5); data[0]", // Type
> - "uint32_t data[6]; (void*)rsaElementGetNativeData(0x%lx, 0x%lx, data,
> 5); data[1]", // Kind
> - "uint32_t data[6]; (void*)rsaElementGetNativeData(0x%lx, 0x%lx, data,
> 5); data[3]" // Vector Size
> + "uint32_t data[5]; (void*)rsaElementGetNativeData(0x%lx, 0x%lx, data,
> 5); data[0]", // Type
> + "uint32_t data[5]; (void*)rsaElementGetNativeData(0x%lx, 0x%lx, data,
> 5); data[1]", // Kind
> + "uint32_t data[5]; (void*)rsaElementGetNativeData(0x%lx, 0x%lx, data,
> 5); data[3]", // Vector Size
> + "uint32_t data[5]; (void*)rsaElementGetNativeData(0x%lx, 0x%lx, data,
> 5); data[4]", // Field Count
> +
> + // rsaElementGetSubElements(RsContext con, RsElement elem, uintptr_t
> *ids, const char **names,
> + // size_t *arraySizes, uint32_t dataSize)
> + // Needed for Allocations of structs to gather details about
> fields/Subelements
> + "void* ids[%u]; const char* names[%u]; size_t arr_size[%u];"
> + "(void*)rsaElementGetSubElements(0x%lx, 0x%lx, ids, names, arr_size,
> %u); ids[%u]", // Element* of field
> +
> + "void* ids[%u]; const char* names[%u]; size_t arr_size[%u];"
> + "(void*)rsaElementGetSubElements(0x%lx, 0x%lx, ids, names, arr_size,
> %u); names[%u]", // Name of field
> +
> + "void* ids[%u]; const char* names[%u]; size_t arr_size[%u];"
> + "(void*)rsaElementGetSubElements(0x%lx, 0x%lx, ids, names, arr_size,
> %u); arr_size[%u]" // Array size of field
> };
>
> // JITs the RS runtime for the internal data pointer of an allocation.
> @@ -1272,7 +1309,7 @@ RenderScriptRuntime::JITTypePacked(Alloc
> allocation->dimension = dims;
>
> addr_t elem_ptr = static_cast<lldb::addr_t>(results[3]);
> - allocation->element_ptr = elem_ptr;
> + allocation->element.element_ptr = elem_ptr;
>
> if (log)
> log->Printf("RenderScriptRuntime::JITTypePacked - dims (%u, %u,
> %u) Element*: 0x%" PRIx64,
> @@ -1282,23 +1319,23 @@ RenderScriptRuntime::JITTypePacked(Alloc
> }
>
> // JITs the RS runtime for information about the Element of an allocation
> -// Then sets type, type_vec_size, and type_kind members in Allocation
> with the result.
> +// Then sets type, type_vec_size, field_count and type_kind members in
> Element with the result.
> // Returns true on success, false otherwise
> bool
> -RenderScriptRuntime::JITElementPacked(AllocationDetails* allocation,
> StackFrame* frame_ptr)
> +RenderScriptRuntime::JITElementPacked(Element& elem, const lldb::addr_t
> context, StackFrame* frame_ptr)
> {
> Log* log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
>
> - if (!allocation->element_ptr.isValid() ||
> !allocation->context.isValid())
> + if (!elem.element_ptr.isValid())
> {
> if (log)
> log->Printf("RenderScriptRuntime::JITElementPacked - Failed
> to find allocation details");
> return false;
> }
>
> - // We want 3 elements from packed data
> - const unsigned int num_exprs = 3;
> - assert(num_exprs == (eExprElementVec - eExprElementType + 1) &&
> "Invalid number of expressions");
> + // We want 4 elements from packed data
> + const unsigned int num_exprs = 4;
> + assert(num_exprs == (eExprElementFieldCount - eExprElementType + 1)
> && "Invalid number of expressions");
>
> const int max_expr_size = 512; // Max expression size
> char buffer[num_exprs][max_expr_size];
> @@ -1306,11 +1343,11 @@ RenderScriptRuntime::JITElementPacked(Al
>
> for (unsigned int i = 0; i < num_exprs; i++)
> {
> - int chars_written = snprintf(buffer[i], max_expr_size,
> runtimeExpressions[eExprElementType + i], *allocation->context.get(),
> *allocation->element_ptr.get());
> + int chars_written = snprintf(buffer[i], max_expr_size,
> runtimeExpressions[eExprElementType + i], context, *elem.element_ptr.get());
> if (chars_written < 0)
> {
> if (log)
> - log->Printf("RenderScriptRuntime::JITDataPointer -
> Encoding error in snprintf()");
> + log->Printf("RenderScriptRuntime::JITElementPacked -
> Encoding error in snprintf()");
> return false;
> }
> else if (chars_written >= max_expr_size)
> @@ -1326,13 +1363,109 @@ RenderScriptRuntime::JITElementPacked(Al
> }
>
> // Assign results to allocation members
> - allocation->type =
> static_cast<RenderScriptRuntime::AllocationDetails::DataType>(results[0]);
> - allocation->type_kind =
> static_cast<RenderScriptRuntime::AllocationDetails::DataKind>(results[1]);
> - allocation->type_vec_size = static_cast<uint32_t>(results[2]);
> + elem.type =
> static_cast<RenderScriptRuntime::Element::DataType>(results[0]);
> + elem.type_kind =
> static_cast<RenderScriptRuntime::Element::DataKind>(results[1]);
> + elem.type_vec_size = static_cast<uint32_t>(results[2]);
> + elem.field_count = static_cast<uint32_t>(results[3]);
>
> if (log)
> - log->Printf("RenderScriptRuntime::JITElementPacked - data type
> %u, pixel type %u, vector size %u",
> - *allocation->type.get(),
> *allocation->type_kind.get(), *allocation->type_vec_size.get());
> + log->Printf("RenderScriptRuntime::JITElementPacked - data type
> %u, pixel type %u, vector size %u, field count %u",
> + *elem.type.get(), *elem.type_kind.get(),
> *elem.type_vec_size.get(), *elem.field_count.get());
> +
> + // If this Element has subelements then JIT
> rsaElementGetSubElements() for details about its fields
> + if (*elem.field_count.get() > 0 && !JITSubelements(elem, context,
> frame_ptr))
> + return false;
> +
> + return true;
> +}
> +
> +// JITs the RS runtime for information about the subelements/fields of a
> struct allocation
> +// This is necessary for infering the struct type so we can pretty print
> the allocation's contents.
> +// Returns true on success, false otherwise
> +bool
> +RenderScriptRuntime::JITSubelements(Element& elem, const lldb::addr_t
> context, StackFrame* frame_ptr)
> +{
> + Log* log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
> +
> + if (!elem.element_ptr.isValid() || !elem.field_count.isValid())
> + {
> + if (log)
> + log->Printf("RenderScriptRuntime::JITSubelements - Failed to
> find allocation details");
> + return false;
> + }
> +
> + const short num_exprs = 3;
> + assert(num_exprs == (eExprSubelementsArrSize - eExprSubelementsId +
> 1) && "Invalid number of expressions");
> +
> + const int max_expr_size = 512; // Max expression size
> + char expr_buffer[max_expr_size];
> + uint64_t results;
> +
> + // Iterate over struct fields.
> + const uint32_t field_count = *elem.field_count.get();
> + for (unsigned int field_index = 0; field_index < field_count;
> ++field_index)
> + {
> + Element child;
> + for (unsigned int expr_index = 0; expr_index < num_exprs;
> ++expr_index)
> + {
> + int chars_written = snprintf(expr_buffer, max_expr_size,
> runtimeExpressions[eExprSubelementsId + expr_index],
> + field_count, field_count,
> field_count,
> + context,
> *elem.element_ptr.get(), field_count, field_index);
> + if (chars_written < 0)
> + {
> + if (log)
> + log->Printf("RenderScriptRuntime::JITSubelements -
> Encoding error in snprintf()");
> + return false;
> + }
> + else if (chars_written >= max_expr_size)
> + {
> + if (log)
> + log->Printf("RenderScriptRuntime::JITSubelements -
> Expression too long");
> + return false;
> + }
> +
> + // Perform expression evaluation
> + if (!EvalRSExpression(expr_buffer, frame_ptr, &results))
> + return false;
> +
> + if (log)
> + log->Printf("RenderScriptRuntime::JITSubelements - Expr
> result 0x%" PRIx64, results);
> +
> + switch(expr_index)
> + {
> + case 0: // Element* of child
> + child.element_ptr = static_cast<addr_t>(results);
> + break;
> + case 1: // Name of child
> + {
> + lldb::addr_t address = static_cast<addr_t>(results);
> + Error err;
> + std::string name;
> + GetProcess()->ReadCStringFromMemory(address, name,
> err);
> + if (!err.Fail())
> + child.type_name = ConstString(name);
> + else
> + {
> + if (log)
> +
> log->Printf("RenderScriptRuntime::JITSubelements - Warning: Couldn't read
> field name");
> + }
> + break;
> + }
> + case 2: // Array size of child
> + child.array_size = static_cast<uint32_t>(results);
> + break;
> + }
> + }
> +
> + // We need to recursively JIT each Element field of the struct
> since
> + // structs can be nested inside structs.
> + if (!JITElementPacked(child, context, frame_ptr))
> + return false;
> + elem.children.push_back(child);
> + }
> +
> + // Try to infer the name of the struct type so we can pretty print
> the allocation contents.
> + FindStructTypeName(elem, frame_ptr);
>
> return true;
> }
> @@ -1343,28 +1476,43 @@ RenderScriptRuntime::JITElementPacked(Al
> // Using this offset minus the starting address we can calculate the size
> of the allocation.
> // Returns true on success, false otherwise
> bool
> -RenderScriptRuntime::JITAllocationSize(AllocationDetails* allocation,
> StackFrame* frame_ptr,
> - const uint32_t elem_size)
> +RenderScriptRuntime::JITAllocationSize(AllocationDetails* allocation,
> StackFrame* frame_ptr)
> {
> Log* log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
>
> if (!allocation->address.isValid() || !allocation->dimension.isValid()
> - || !allocation->data_ptr.isValid())
> + || !allocation->data_ptr.isValid() ||
> !allocation->element.datum_size.isValid())
> {
> if (log)
> log->Printf("RenderScriptRuntime::JITAllocationSize - Failed
> to find allocation details");
> return false;
> }
>
> - const char* expr_cstr = runtimeExpressions[eExprGetOffsetPtr];
> - const int max_expr_size = 512; // Max expression size
> - char buffer[max_expr_size];
> -
> // Find dimensions
> unsigned int dim_x = allocation->dimension.get()->dim_1;
> unsigned int dim_y = allocation->dimension.get()->dim_2;
> unsigned int dim_z = allocation->dimension.get()->dim_3;
>
> + // Our plan of jitting the last element address doesn't seem to work
> for struct Allocations
> + // Instead try to infer the size ourselves without any inter element
> padding.
> + if (allocation->element.children.size() > 0)
> + {
> + if (dim_x == 0) dim_x = 1;
> + if (dim_y == 0) dim_y = 1;
> + if (dim_z == 0) dim_z = 1;
> +
> + allocation->size = dim_x * dim_y * dim_z *
> *allocation->element.datum_size.get();
> +
> + if (log)
> + log->Printf("RenderScriptRuntime::JITAllocationSize - Infered
> size of struct allocation %u", *allocation->size.get());
> +
> + return true;
> + }
> +
> + const char* expr_cstr = runtimeExpressions[eExprGetOffsetPtr];
> + const int max_expr_size = 512;
> + char buffer[max_expr_size];
> +
> // Calculate last element
> dim_x = dim_x == 0 ? 0 : dim_x - 1;
> dim_y = dim_y == 0 ? 0 : dim_y - 1;
> @@ -1391,7 +1539,7 @@ RenderScriptRuntime::JITAllocationSize(A
>
> addr_t mem_ptr = static_cast<lldb::addr_t>(result);
> // Find pointer to last element and add on size of an element
> - allocation->size = static_cast<uint32_t>(mem_ptr -
> *allocation->data_ptr.get()) + elem_size;
> + allocation->size = static_cast<uint32_t>(mem_ptr -
> *allocation->data_ptr.get()) + *allocation->element.datum_size.get();
>
> return true;
> }
> @@ -1457,31 +1605,140 @@ RenderScriptRuntime::RefreshAllocation(A
> return false;
>
> // rsaElementGetNativeData()
> - if (!JITElementPacked(allocation, frame_ptr))
> + if (!JITElementPacked(allocation->element,
> *allocation->context.get(), frame_ptr))
> return false;
>
> + // Sets the datum_size member in Element
> + SetElementSize(allocation->element);
> +
> // Use GetOffsetPointer() to infer size of the allocation
> - const unsigned int element_size = GetElementSize(allocation);
> - if (!JITAllocationSize(allocation, frame_ptr, element_size))
> + if (!JITAllocationSize(allocation, frame_ptr))
> return false;
>
> return true;
> }
>
> -// Returns the size of a single allocation element including padding.
> +// Function attempts to set the type_name member of the paramaterised
> Element object.
> +// This string should be the name of the struct type the Element
> represents.
> +// We need this string for pretty printing the Element to users.
> +void
> +RenderScriptRuntime::FindStructTypeName(Element& elem, StackFrame*
> frame_ptr)
> +{
> + Log* log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
> +
> + if (!elem.type_name.IsEmpty()) // Name already set
> + return;
> + else
> + elem.type_name = Element::FallbackStructName; // Default type
> name if we don't succeed
> +
> + // Find all the global variables from the script rs modules
> + VariableList variable_list;
> + for (auto module_sp : m_rsmodules)
> + module_sp->m_module->FindGlobalVariables(RegularExpression("."),
> true, UINT32_MAX, variable_list);
> +
> + // Iterate over all the global variables looking for one with a
> matching type to the Element.
> + // We make the assumption a match exists since there needs to be a
> global variable to reflect the
> + // struct type back into java host code.
> + for (uint32_t var_index = 0; var_index < variable_list.GetSize();
> ++var_index)
> + {
> + const VariableSP
> var_sp(variable_list.GetVariableAtIndex(var_index));
> + if (!var_sp)
> + continue;
> +
> + ValueObjectSP valobj_sp = ValueObjectVariable::Create(frame_ptr,
> var_sp);
> + if (!valobj_sp)
> + continue;
> +
> + // Find the number of variable fields.
> + // If it has no fields, or more fields than our Element, then it
> can't be the struct we're looking for.
> + // Don't check for equality since RS can add extra struct members
> for padding.
> + size_t num_children = valobj_sp->GetNumChildren();
> + if (num_children > elem.children.size() || num_children == 0)
> + continue;
> +
> + // Iterate over children looking for members with matching field
> names.
> + // If all the field names match, this is likely the struct we
> want.
> + //
> + // TODO: This could be made more robust by also checking
> children data sizes, or array size
> + bool found = true;
> + for (size_t child_index = 0; child_index < num_children;
> ++child_index)
> + {
> + ValueObjectSP child = valobj_sp->GetChildAtIndex(child_index,
> true);
> + if (!child || (child->GetName() !=
> elem.children[child_index].type_name))
> + {
> + found = false;
> + break;
> + }
> + }
> +
> + // RS can add extra struct members for padding in the format
> '#rs_padding_[0-9]+'
> + if (found && num_children < elem.children.size())
> + {
> + const unsigned int size_diff = elem.children.size() -
> num_children;
> + if (log)
> + log->Printf("RenderScriptRuntime::FindStructTypeName - %u
> padding struct entries", size_diff);
> +
> + for (unsigned int padding_index = 0; padding_index <
> size_diff; ++padding_index)
> + {
> + const ConstString& name = elem.children[num_children +
> padding_index].type_name;
> + if (strcmp(name.AsCString(), "#rs_padding") < 0)
> + found = false;
> + }
> + }
> +
> + // We've found a global var with matching type
> + if (found)
> + {
> + // Dereference since our Element type isn't a pointer.
> + if (valobj_sp->IsPointerType())
> + {
> + Error err;
> + ValueObjectSP deref_valobj = valobj_sp->Dereference(err);
> + if (!err.Fail())
> + valobj_sp = deref_valobj;
> + }
> +
> + // Save name of variable in Element.
> + elem.type_name = valobj_sp->GetTypeName();
> + if (log)
> + log->Printf("RenderScriptRuntime::FindStructTypeName -
> Element name set to %s", elem.type_name.AsCString());
> +
> + return;
> + }
> + }
> +}
> +
> +// Function sets the datum_size member of Element. Representing the size
> of a single instance including padding.
> // Assumes the relevant allocation information has already been jitted.
> -unsigned int
> -RenderScriptRuntime::GetElementSize(const AllocationDetails* allocation)
> +void
> +RenderScriptRuntime::SetElementSize(Element& elem)
> {
> - const AllocationDetails::DataType type = *allocation->type.get();
> - assert(type >= AllocationDetails::RS_TYPE_NONE && type <=
> AllocationDetails::RS_TYPE_BOOLEAN
> + Log* log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
> + const Element::DataType type = *elem.type.get();
> + assert(type >= Element::RS_TYPE_NONE && type <=
> Element::RS_TYPE_BOOLEAN
> && "Invalid allocation
> type");
>
> - const unsigned int vec_size = *allocation->type_vec_size.get();
> - const unsigned int data_size = vec_size *
> AllocationDetails::RSTypeToFormat[type][eElementSize];
> + const unsigned int vec_size = *elem.type_vec_size.get();
> + unsigned int data_size = 0;
> const unsigned int padding = vec_size == 3 ?
> AllocationDetails::RSTypeToFormat[type][eElementSize] : 0;
>
> - return data_size + padding;
> + // Element is of a struct type, calculate size recursively.
> + if ((type == Element::RS_TYPE_NONE) && (elem.children.size() > 0))
> + {
> + for (Element& child : elem.children)
> + {
> + SetElementSize(child);
> + const unsigned int array_size = child.array_size.isValid() ?
> *child.array_size.get() : 1;
> + data_size += *child.datum_size.get() * array_size;
> + }
> + }
> + else
> + data_size = vec_size *
> AllocationDetails::RSTypeToFormat[type][eElementSize];
> +
> + elem.padding = padding;
> + elem.datum_size = data_size + padding;
> + if (log)
> + log->Printf("RenderScriptRuntime::SetElementSize - element size
> set to %u", data_size + padding);
> }
>
> // Given an allocation, this function copies the allocation contents from
> device into a buffer on the heap.
> @@ -1492,8 +1749,8 @@ RenderScriptRuntime::GetAllocationData(A
> Log* log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
>
> // JIT all the allocation details
> - if (!allocation->data_ptr.isValid() || !allocation->type.isValid() ||
> !allocation->type_vec_size.isValid()
> - || !allocation->size.isValid())
> + if (!allocation->data_ptr.isValid() ||
> !allocation->element.type.isValid()
> + || !allocation->element.type_vec_size.isValid() ||
> !allocation->size.isValid())
> {
> if (log)
> log->Printf("RenderScriptRuntime::GetAllocationData -
> Allocation details not calculated yet, jitting info");
> @@ -1506,7 +1763,7 @@ RenderScriptRuntime::GetAllocationData(A
> }
> }
>
> - assert(allocation->data_ptr.isValid() && allocation->type.isValid()
> && allocation->type_vec_size.isValid()
> + assert(allocation->data_ptr.isValid() &&
> allocation->element.type.isValid() &&
> allocation->element.type_vec_size.isValid()
> && allocation->size.isValid() && "Allocation information not
> available");
>
> // Allocate a buffer to copy data into
> @@ -1551,7 +1808,8 @@ RenderScriptRuntime::LoadAllocation(Stre
> log->Printf("RenderScriptRuntime::LoadAllocation - Found
> allocation 0x%" PRIx64, *alloc->address.get());
>
> // JIT all the allocation details
> - if (!alloc->data_ptr.isValid() || !alloc->type.isValid() ||
> !alloc->type_vec_size.isValid() || !alloc->size.isValid())
> + if (!alloc->data_ptr.isValid() || !alloc->element.type.isValid() ||
> !alloc->element.datum_size.isValid()
> + || !alloc->element.type_vec_size.isValid() ||
> !alloc->size.isValid())
> {
> if (log)
> log->Printf("RenderScriptRuntime::LoadAllocation - Allocation
> details not calculated yet, jitting info");
> @@ -1564,8 +1822,8 @@ RenderScriptRuntime::LoadAllocation(Stre
> }
> }
>
> - assert(alloc->data_ptr.isValid() && alloc->type.isValid() &&
> alloc->type_vec_size.isValid() && alloc->size.isValid()
> - && "Allocation information not available");
> + assert(alloc->data_ptr.isValid() && alloc->element.type.isValid() &&
> alloc->element.type_vec_size.isValid()
> + && alloc->size.isValid() &&
> alloc->element.datum_size.isValid() && "Allocation information not
> available");
>
> // Check we can read from file
> FileSpec file(filename, true);
> @@ -1598,16 +1856,15 @@ RenderScriptRuntime::LoadAllocation(Stre
> head->type, head->element_size);
>
> // Check if the target allocation and file both have the same number
> of bytes for an Element
> - const unsigned int elem_size = GetElementSize(alloc);
> - if (elem_size != head->element_size)
> + if (*alloc->element.datum_size.get() != head->element_size)
> {
> strm.Printf("Warning: Mismatched Element sizes - file %u bytes,
> allocation %u bytes",
> - head->element_size, elem_size);
> + head->element_size, *alloc->element.datum_size.get());
> strm.EOL();
> }
>
> // Check if the target allocation and file both have the same
> integral type
> - const unsigned int type = static_cast<unsigned
> int>(*alloc->type.get());
> + const unsigned int type = static_cast<unsigned
> int>(*alloc->element.type.get());
> if (type != head->type)
> {
> const char* file_type_cstr =
> AllocationDetails::RsDataTypeToString[head->type][0];
> @@ -1665,8 +1922,8 @@ RenderScriptRuntime::SaveAllocation(Stre
> log->Printf("RenderScriptRuntime::SaveAllocation - Found
> allocation 0x%" PRIx64, *alloc->address.get());
>
> // JIT all the allocation details
> - if (!alloc->data_ptr.isValid() || !alloc->type.isValid() ||
> !alloc->type_vec_size.isValid()
> - || !alloc->type_kind.isValid() || !alloc->dimension.isValid())
> + if (!alloc->data_ptr.isValid() || !alloc->element.type.isValid() ||
> !alloc->element.type_vec_size.isValid()
> + || !alloc->element.type_kind.isValid() ||
> !alloc->dimension.isValid())
> {
> if (log)
> log->Printf("RenderScriptRuntime::SaveAllocation - Allocation
> details not calculated yet, jitting info");
> @@ -1679,8 +1936,8 @@ RenderScriptRuntime::SaveAllocation(Stre
> }
> }
>
> - assert(alloc->data_ptr.isValid() && alloc->type.isValid() &&
> alloc->type_vec_size.isValid() && alloc->type_kind.isValid()
> - && alloc->dimension.isValid() && "Allocation information not
> available");
> + assert(alloc->data_ptr.isValid() && alloc->element.type.isValid() &&
> alloc->element.type_vec_size.isValid() && alloc->element.datum_size.get()
> + && alloc->element.type_kind.isValid() &&
> alloc->dimension.isValid() && "Allocation information not available");
>
> // Check we can create writable file
> FileSpec file_spec(filename, true);
> @@ -1705,12 +1962,12 @@ RenderScriptRuntime::SaveAllocation(Stre
> AllocationDetails::FileHeader head;
> head.ident[0] = 'R'; head.ident[1] = 'S'; head.ident[2] = 'A';
> head.ident[3] = 'D';
> head.hdr_size =
> static_cast<uint16_t>(sizeof(AllocationDetails::FileHeader));
> - head.type = static_cast<uint16_t>(*alloc->type.get());
> - head.kind = static_cast<uint32_t>(*alloc->type_kind.get());
> + head.type = static_cast<uint16_t>(*alloc->element.type.get());
> + head.kind = static_cast<uint32_t>(*alloc->element.type_kind.get());
> head.dims[0] = static_cast<uint32_t>(alloc->dimension.get()->dim_1);
> head.dims[1] = static_cast<uint32_t>(alloc->dimension.get()->dim_2);
> head.dims[2] = static_cast<uint32_t>(alloc->dimension.get()->dim_3);
> - head.element_size = static_cast<uint32_t>(GetElementSize(alloc));
> + head.element_size =
> static_cast<uint32_t>(*alloc->element.datum_size.get());
>
> // Write the file header
> size_t num_bytes = sizeof(AllocationDetails::FileHeader);
> @@ -2080,8 +2337,8 @@ RenderScriptRuntime::DumpAllocation(Stre
> log->Printf("RenderScriptRuntime::DumpAllocation - Found
> allocation 0x%" PRIx64, *alloc->address.get());
>
> // Check we have information about the allocation, if not calculate it
> - if (!alloc->data_ptr.isValid() || !alloc->type.isValid() ||
> - !alloc->type_vec_size.isValid() || !alloc->dimension.isValid())
> + if (!alloc->data_ptr.isValid() || !alloc->element.type.isValid() ||
> + !alloc->element.type_vec_size.isValid() ||
> !alloc->dimension.isValid() || !alloc->element.datum_size.isValid())
> {
> if (log)
> log->Printf("RenderScriptRuntime::DumpAllocation - Allocation
> details not calculated yet, jitting info");
> @@ -2096,22 +2353,19 @@ RenderScriptRuntime::DumpAllocation(Stre
> }
>
> // Establish format and size of each data element
> - const unsigned int vec_size = *alloc->type_vec_size.get();
> - const AllocationDetails::DataType type = *alloc->type.get();
> + const unsigned int vec_size = *alloc->element.type_vec_size.get();
> + const Element::DataType type = *alloc->element.type.get();
>
> - assert(type >= AllocationDetails::RS_TYPE_NONE && type <=
> AllocationDetails::RS_TYPE_BOOLEAN
> + assert(type >= Element::RS_TYPE_NONE && type <=
> Element::RS_TYPE_BOOLEAN
> && "Invalid allocation
> type");
>
> lldb::Format format = vec_size == 1 ?
> static_cast<lldb::Format>(AllocationDetails::RSTypeToFormat[type][eFormatSingle])
> :
> static_cast<lldb::Format>(AllocationDetails::RSTypeToFormat[type][eFormatVector]);
>
> - const unsigned int data_size = vec_size *
> AllocationDetails::RSTypeToFormat[type][eElementSize];
> - // Renderscript pads vector 3 elements to vector 4
> - const unsigned int elem_padding = vec_size == 3 ?
> AllocationDetails::RSTypeToFormat[type][eElementSize] : 0;
> + const unsigned int data_size = *alloc->element.datum_size.get();
>
> if (log)
> - log->Printf("RenderScriptRuntime::DumpAllocation - Element size
> %u bytes, element padding %u bytes",
> - data_size, elem_padding);
> + log->Printf("RenderScriptRuntime::DumpAllocation - Element size
> %u bytes, including padding", data_size);
>
> // Allocate a buffer to copy data into
> std::shared_ptr<uint8_t> buffer = GetAllocationData(alloc, frame_ptr);
> @@ -2136,10 +2390,10 @@ RenderScriptRuntime::DumpAllocation(Stre
> }
> }
> const unsigned int stride = *alloc->stride.get();
> - const unsigned int size = *alloc->size.get(); //size of last element
> -
> + const unsigned int size = *alloc->size.get(); // Size of whole
> allocation
> + const unsigned int padding = alloc->element.padding.isValid() ?
> *alloc->element.padding.get() : 0;
> if (log)
> - log->Printf("RenderScriptRuntime::DumpAllocation - stride %u
> bytes, size %u bytes", stride, size);
> + log->Printf("RenderScriptRuntime::DumpAllocation - stride %u
> bytes, size %u bytes, padding %u", stride, size, padding);
>
> // Find dimensions used to index loops, so need to be non-zero
> unsigned int dim_x = alloc->dimension.get()->dim_1;
> @@ -2173,8 +2427,41 @@ RenderScriptRuntime::DumpAllocation(Stre
> for (unsigned int x = 0; x < dim_x; ++x)
> {
> strm.Printf("\n(%u, %u, %u) = ", x, y, z);
> - alloc_data.Dump(&strm, offset, format, data_size, 1, 1,
> LLDB_INVALID_ADDRESS, 0, 0);
> - offset += data_size + elem_padding;
> + if ((type == Element::RS_TYPE_NONE) &&
> (alloc->element.children.size() > 0) &&
> + (alloc->element.type_name !=
> Element::FallbackStructName))
> + {
> + // Here we are dumping an Element of struct type.
> + // This is done using expression evaluation with the
> name of the struct type and pointer to element.
> +
> + // Don't print the name of the resulting expression,
> since this will be '$[0-9]+'
> + DumpValueObjectOptions expr_options;
> + expr_options.SetHideName(true);
> +
> + // Setup expression as derefrencing a pointer cast to
> element address.
> + const int max_expr_size = 512;
> + char expr_char_buffer[max_expr_size];
> + int chars_written = snprintf(expr_char_buffer,
> max_expr_size, "*(%s*) 0x%" PRIx64,
> +
> alloc->element.type_name.AsCString(), *alloc->data_ptr.get() + offset);
> +
> + if (chars_written < 0 || chars_written >=
> max_expr_size)
> + {
> + if (log)
> +
> log->Printf("RenderScriptRuntime::DumpAllocation- Error in snprintf()");
> + continue;
> + }
> +
> + // Evaluate expression
> + ValueObjectSP expr_result;
> +
> GetProcess()->GetTarget().EvaluateExpression(expr_char_buffer, frame_ptr,
> expr_result);
> +
> + // Print the results to our stream.
> + expr_result->Dump(strm, expr_options);
> + }
> + else
> + {
> + alloc_data.Dump(&strm, offset, format, data_size -
> padding, 1, 1, LLDB_INVALID_ADDRESS, 0, 0);
> + }
> + offset += data_size;
> }
> }
> }
> @@ -2234,27 +2521,29 @@ RenderScriptRuntime::ListAllocations(Str
> alloc->dimension.get()->dim_3);
>
> strm.Indent("Data Type: ");
> - if (!alloc->type.isValid() || !alloc->type_vec_size.isValid())
> + if (!alloc->element.type.isValid() ||
> !alloc->element.type_vec_size.isValid())
> strm.Printf("unknown\n");
> else
> {
> - const int vector_size = *alloc->type_vec_size.get();
> - const AllocationDetails::DataType type = *alloc->type.get();
> + const int vector_size = *alloc->element.type_vec_size.get();
> + const Element::DataType type = *alloc->element.type.get();
>
> - if (vector_size > 4 || vector_size < 1 ||
> - type < AllocationDetails::RS_TYPE_NONE || type >
> AllocationDetails::RS_TYPE_BOOLEAN)
> + if (!alloc->element.type_name.IsEmpty())
> + strm.Printf("%s\n", alloc->element.type_name.AsCString());
> + else if (vector_size > 4 || vector_size < 1 ||
> + type < Element::RS_TYPE_NONE || type >
> Element::RS_TYPE_BOOLEAN)
> strm.Printf("invalid type\n");
> else
> strm.Printf("%s\n",
> AllocationDetails::RsDataTypeToString[static_cast<unsigned
> int>(type)][vector_size-1]);
> }
>
> strm.Indent("Data Kind: ");
> - if (!alloc->type_kind.isValid())
> + if (!alloc->element.type_kind.isValid())
> strm.Printf("unknown\n");
> else
> {
> - const AllocationDetails::DataKind kind =
> *alloc->type_kind.get();
> - if (kind < AllocationDetails::RS_KIND_USER || kind >
> AllocationDetails::RS_KIND_PIXEL_YUV)
> + const Element::DataKind kind =
> *alloc->element.type_kind.get();
> + if (kind < Element::RS_KIND_USER || kind >
> Element::RS_KIND_PIXEL_YUV)
> strm.Printf("invalid kind\n");
> else
> strm.Printf("%s\n",
> AllocationDetails::RsDataKindToString[static_cast<unsigned int>(kind)]);
>
> Modified:
> lldb/trunk/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h
> URL:
> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h?rev=254294&r1=254293&r2=254294&view=diff
>
> ==============================================================================
> ---
> lldb/trunk/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h
> (original)
> +++
> lldb/trunk/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h
> Mon Nov 30 04:29:49 2015
> @@ -231,6 +231,7 @@ public:
> protected:
> struct ScriptDetails;
> struct AllocationDetails;
> + struct Element;
>
> void InitSearchFilter(lldb::TargetSP target)
> {
> @@ -311,8 +312,9 @@ private:
>
> AllocationDetails* FindAllocByID(Stream &strm, const uint32_t
> alloc_id);
> std::shared_ptr<uint8_t> GetAllocationData(AllocationDetails*
> allocation, StackFrame* frame_ptr);
> - unsigned int GetElementSize(const AllocationDetails* allocation);
> + void SetElementSize(Element& elem);
> static bool GetFrameVarAsUnsigned(const lldb::StackFrameSP, const
> char* var_name, uint64_t& val);
> + void FindStructTypeName(Element& elem, StackFrame* frame_ptr);
>
> //
> // Helper functions for jitting the runtime
> @@ -324,9 +326,11 @@ private:
>
> bool JITTypePacked(AllocationDetails* allocation, StackFrame*
> frame_ptr);
>
> - bool JITElementPacked(AllocationDetails* allocation, StackFrame*
> frame_ptr);
> + bool JITElementPacked(Element& elem, const lldb::addr_t context,
> StackFrame* frame_ptr);
>
> - bool JITAllocationSize(AllocationDetails* allocation, StackFrame*
> frame_ptr, const uint32_t elem_size);
> + bool JITAllocationSize(AllocationDetails* allocation, StackFrame*
> frame_ptr);
> +
> + bool JITSubelements(Element& elem, const lldb::addr_t context,
> StackFrame* frame_ptr);
>
> bool JITAllocationStride(AllocationDetails* allocation, StackFrame*
> frame_ptr);
>
>
>
> _______________________________________________
> lldb-commits mailing list
> lldb-commits@lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
>
_______________________________________________
lldb-commits mailing list
lldb-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
