[LLDB][NFC] Fix a incorrect use of shared_ptr in RenderScriptRuntime.cpp

[xgupta]

Summary

Incorrect use of shared_ptr.

found by PVS-Studio https://pvs-studio.com/en/blog/posts/cpp/1003/, N8 & N9.

[jingham]

I don't think this code is going to compile, is it? You took out the if (!buffer) { but left the RHS } so now the scopes are unbalanced. I think you should just change how the shared pointer is defined - which is presumably the substance of the patch - and leave everything after as is.

[xgupta]

address comments

[xgupta]

In D142309#4075616, @jingham wrote:

I don't think this code is going to compile, is it? You took out the if (!buffer) { but left the RHS } so now the scopes are unbalanced. I think you should just change how the shared pointer is defined - which is presumably the substance of the patch - and leave everything after as is.

Yeah, correct, I didn't notice carefully. Thanks.

[JDevlieghere]

LGTM, but I wonder when we'll be able to get rid of RenderScript completely (CC @labath)

[xgupta]

fix build

[xgupta]

In D142309#4075745, @JDevlieghere wrote:

LGTM, but I wonder when we'll be able to get rid of RenderScript completely (CC @labath)

@JDevlieghere, Shall I commit the changes after running check-lldb?

[labath]

In D142309#4075745, @JDevlieghere wrote:

LGTM, but I wonder when we'll be able to get rid of RenderScript completely (CC @labath)

I am not going to stand in your way. I usually redirect these questions to @srhines, but I understand he's moved on to other things as well.

[xgupta]

In D142309#4102284, @labath wrote:

In D142309#4075745, @JDevlieghere wrote:

LGTM, but I wonder when we'll be able to get rid of RenderScript completely (CC @labath)

I am not going to stand in your way. I usually redirect these questions to @srhines, but I understand he's moved on to other things as well.

Thanks, no problem.

[srhines]

In D142309#4107170, @xgupta wrote:

In D142309#4102284, @labath wrote:

In D142309#4075745, @JDevlieghere wrote:

LGTM, but I wonder when we'll be able to get rid of RenderScript completely (CC @labath)

I am not going to stand in your way. I usually redirect these questions to @srhines, but I understand he's moved on to other things as well.

Thanks, no problem.

RenderScript support can be removed. I don't necessarily have the bandwidth to do it immediately, but if someone wants to clean that up, I'd help with reviewing.

lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h

private:
 
   void CaptureSetGlobalVar(RuntimeHook *hook_info, ExecutionContext &context);
 
   void CaptureScriptInvokeForEachMulti(RuntimeHook *hook_info,
                                        ExecutionContext &context);
 
   AllocationDetails *FindAllocByID(Stream &strm, const uint32_t alloc_id);
 
-  std::shared_ptr<uint8_t> GetAllocationData(AllocationDetails *alloc,
+  std::shared_ptr<uint8_t []> GetAllocationData(AllocationDetails *alloc,
                                              StackFrame *frame_ptr);
 
   void SetElementSize(Element &elem);
 
   static bool GetFrameVarAsUnsigned(const lldb::StackFrameSP,
                                     const char *var_name, uint64_t &val);
 
   void FindStructTypeName(Element &elem, StackFrame *frame_ptr);
 
-  size_t PopulateElementHeaders(const std::shared_ptr<uint8_t> header_buffer,
+  size_t PopulateElementHeaders(const std::shared_ptr<uint8_t []> header_buffer,
                                 size_t offset, const Element &elem);
 
   size_t CalculateElementHeaderSize(const Element &elem);
 
   void SetConditional(lldb::BreakpointSP bp, lldb_private::Stream &messages,
                       const lldb_renderscript::RSCoordinate &coord);
   //
   // Helper functions for jitting the runtime

lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

void RenderScriptRuntime::SetElementSize(Element &elem) {
   elem.datum_size = data_size + padding;
   LLDB_LOGF(log, "%s - element size set to %" PRIu32, __FUNCTION__,
             data_size + padding);
 }
 
 // Given an allocation, this function copies the allocation contents from
 // device into a buffer on the heap. Returning a shared pointer to the buffer
 // containing the data.
-std::shared_ptr<uint8_t>
+std::shared_ptr<uint8_t []>
 RenderScriptRuntime::GetAllocationData(AllocationDetails *alloc,
                                        StackFrame *frame_ptr) {
   Log *log = GetLog(LLDBLog::Language);
 
   // JIT all the allocation details
   if (alloc->ShouldRefresh()) {
     LLDB_LOGF(log, "%s - allocation details not calculated yet, jitting info",
               __FUNCTION__);
 
     if (!RefreshAllocation(alloc, frame_ptr)) {
       LLDB_LOGF(log, "%s - couldn't JIT allocation details", __FUNCTION__);
       return nullptr;
     }
   }
 
   assert(alloc->data_ptr.isValid() && alloc->element.type.isValid() &&
          alloc->element.type_vec_size.isValid() && alloc->size.isValid() &&
          "Allocation information not available");
 
   // Allocate a buffer to copy data into
   const uint32_t size = *alloc->size.get();
-  std::shared_ptr<uint8_t> buffer(new uint8_t[size]);
+  std::shared_ptr<uint8_t []> buffer(new uint8_t[size]);
   if (!buffer) {
     LLDB_LOGF(log, "%s - couldn't allocate a %" PRIu32 " byte buffer",
               __FUNCTION__, size);
     return nullptr;
   }
 
   // Read the inferior memory
   Status err;

 
 // Function takes as parameters a byte buffer, which will eventually be written
 // to file as the element header, an offset into that buffer, and an Element
 // that will be saved into the buffer at the parametrised offset. Return value
 // is the new offset after writing the element into the buffer. Elements are
 // saved to the file as the ElementHeader struct followed by offsets to the
 // structs of all the element's children.
 size_t RenderScriptRuntime::PopulateElementHeaders(
-    const std::shared_ptr<uint8_t> header_buffer, size_t offset,
+    const std::shared_ptr<uint8_t []> header_buffer, size_t offset,
     const Element &elem) {
   // File struct for an element header with all the relevant details copied
   // from elem. We assume members are valid already.
   AllocationDetails::ElementHeader elem_header;
   elem_header.type = *elem.type.get();
   elem_header.kind = *elem.type_kind.get();
   elem_header.element_size = *elem.datum_size.get();
   elem_header.vector_size = *elem.type_vec_size.get();
if (!file) {
     std::string error = llvm::toString(file.takeError());
     strm.Printf("Error: Failed to open '%s' for writing: %s", path,
                 error.c_str());
     strm.EOL();
     return false;
   }
 
   // Read allocation into buffer of heap memory
-  const std::shared_ptr<uint8_t> buffer = GetAllocationData(alloc, frame_ptr);
+  const std::shared_ptr<uint8_t []> buffer = GetAllocationData(alloc, frame_ptr);
   if (!buffer) {
     strm.Printf("Error: Couldn't read allocation data into buffer");
     strm.EOL();
     return false;
   }
 
   // Create the file header
   AllocationDetails::FileHeader head;
bool RenderScriptRuntime::SaveAllocation(Stream &strm, const uint32_t alloc_id,
   Status err = file.get()->Write(&head, num_bytes);
   if (!err.Success()) {
     strm.Printf("Error: '%s' when writing to file '%s'", err.AsCString(), path);
     strm.EOL();
     return false;
   }
 
   // Create the headers describing the element type of the allocation.
-  std::shared_ptr<uint8_t> element_header_buffer(
+  std::shared_ptr<uint8_t []> element_header_buffer(
       new uint8_t[element_header_size]);
   if (element_header_buffer == nullptr) {
     strm.Printf("Internal Error: Couldn't allocate %" PRIu64
                 " bytes on the heap",
                 (uint64_t)element_header_size);
     strm.EOL();
     return false;
   }
format = vec_size == 1
                        AllocationDetails::RSTypeToFormat[type][eFormatVector]);
 
   const uint32_t data_size = *alloc->element.datum_size.get();
 
   LLDB_LOGF(log, "%s - element size %" PRIu32 " bytes, including padding",
             __FUNCTION__, data_size);
 
   // Allocate a buffer to copy data into
-  std::shared_ptr<uint8_t> buffer = GetAllocationData(alloc, frame_ptr);
+  std::shared_ptr<uint8_t []> buffer = GetAllocationData(alloc, frame_ptr);
   if (!buffer) {
     strm.Printf("Error: Couldn't read allocation data");
     strm.EOL();
     return false;
   }
 
   // Calculate stride between rows as there may be padding at end of rows since
   // allocated memory is 16-byte aligned