Ticket #7761: return_values.patch

src/apps/debugger/Jamfile

@@ -124 +124 @@
 
     # ids
     FunctionID.cpp
+    FunctionParameterID.cpp
     LocalVariableID.cpp
     ObjectID.cpp
-    FunctionParameterID.cpp
+    ReturnValueID.cpp
 
     # jobs
     GetCPUStateJob.cpp

src/apps/debugger/arch/Architecture.h

@@ -30 +30 @@
 class Statement;
 class Team;
 class TeamMemory;
+class ValueLocation;
 
 
 enum {
@@ -118 +119 @@
                                     int32& _maxBytesPerRegister,
                                     uint8& _watchpointCapabilityFlags) = 0;
 
+    virtual status_t            GetReturnAddressLocation(
+                                    StackFrame* frame, target_size_t valueSize,
+                                    ValueLocation*& _location) = 0;
+
 
 protected:
             TeamMemory*         fTeamMemory;

src/apps/debugger/arch/InstructionInfo.cpp

@@ -9 +9 @@
 InstructionInfo::InstructionInfo()
     :
     fAddress(0),
+    fTargetAddress(0),
     fSize(0),
     fType(INSTRUCTION_TYPE_OTHER),
     fBreakpointAllowed(false),
@@ -17 +18 @@
 }
 
 
-InstructionInfo::InstructionInfo(target_addr_t address, target_size_t size,
+InstructionInfo::InstructionInfo(target_addr_t address,
+    target_addr_t targetAddress, target_size_t size,
     instruction_type type, bool breakpointAllowed,
     const BString& disassembledLine)
     :
     fAddress(address),
+    fTargetAddress(targetAddress),
     fSize(size),
     fType(type),
     fBreakpointAllowed(breakpointAllowed),
@@ -31 +34 @@
 
 
 bool
-InstructionInfo::SetTo(target_addr_t address, target_size_t size,
-    instruction_type type, bool breakpointAllowed,
+InstructionInfo::SetTo(target_addr_t address, target_addr_t targetAddress,
+    target_size_t size, instruction_type type, bool breakpointAllowed,
     const BString& disassembledLine)
 {
     fAddress = address;
+    fTargetAddress = targetAddress;
     fSize = size;
     fType = type;
     fBreakpointAllowed = breakpointAllowed;

src/apps/debugger/arch/InstructionInfo.h

@@ -20 +20 @@
 public:
                                 InstructionInfo();
                                 InstructionInfo(target_addr_t address,
+                                    target_addr_t targetAddress,
                                     target_size_t size, instruction_type type,
                                     bool breakpointAllowed,
                                     const BString& disassembledLine);
 
-            bool                SetTo(target_addr_t address, target_size_t size,
+            bool                SetTo(target_addr_t address,
+                                    target_addr_t targetAddress,
+                                    target_size_t size,
                                     instruction_type type,
                                     bool breakpointAllowed,
                                     const BString& disassembledLine);
 
             target_addr_t       Address() const     { return fAddress; }
+            target_addr_t       TargetAddress() const
+                                    { return fTargetAddress; }
             target_size_t       Size() const        { return fSize; }
             instruction_type    Type() const        { return fType; }
             bool                IsBreakpointAllowed() const
@@ -40 +45 @@
 
 private:
             target_addr_t       fAddress;
+            target_addr_t       fTargetAddress;
             target_size_t       fSize;
             instruction_type    fType;
             bool                fBreakpointAllowed;

src/apps/debugger/arch/x86/ArchitectureX86.cpp

@@ -23 +23 @@
 #include "StackFrame.h"
 #include "Statement.h"
 #include "TeamMemory.h"
+#include "ValueLocation.h"
 #include "X86AssemblyLanguage.h"
 
 #include "disasm/DisassemblerX86.h"
@@ -579 +580 @@
 ArchitectureX86::GetInstructionInfo(target_addr_t address,
     InstructionInfo& _info)
 {
-    // read the code
+    // read the code - maximum x86{-64} instruction size = 15 bytes
     uint8 buffer[16];
-        // TODO: What's the maximum instruction size?
     ssize_t bytesRead = fTeamMemory->ReadMemory(address, buffer,
         sizeof(buffer));
     if (bytesRead < 0)
@@ -596 +596 @@
     // disassemble the instruction
     BString line;
     target_addr_t instructionAddress;
+    target_addr_t targetAddress = 0;
     target_size_t instructionSize;
     bool breakpointAllowed;
     error = disassembler.GetNextInstruction(line, instructionAddress,
@@ -607 +608 @@
     if (buffer[0] == 0xff && (buffer[1] & 0x34) == 0x10) {
         // absolute call with r/m32
         instructionType = INSTRUCTION_TYPE_SUBROUTINE_CALL;
+        // TODO: retrieve target address (might be in a register)
     } else if (buffer[0] == 0xe8 && instructionSize == 5) {
         // relative call with rel32 -- don't categorize the call with 0 as
         // subroutine call, since it is only used to get the address of the GOT
         if (buffer[1] != 0 || buffer[2] != 0 || buffer[3] != 0
             || buffer[4] != 0) {
             instructionType = INSTRUCTION_TYPE_SUBROUTINE_CALL;
+            int32 offset;
+            memcpy(&offset, &buffer[1], 4);
+            targetAddress = instructionAddress + instructionSize + offset;
         }
     }
 
-    if (!_info.SetTo(instructionAddress, instructionSize, instructionType,
-            breakpointAllowed, line)) {
+    if (!_info.SetTo(instructionAddress, targetAddress, instructionSize,
+            instructionType, breakpointAllowed, line)) {
         return B_NO_MEMORY;
     }
 
@@ -643 +648 @@
 }
 
 
+status_t
+ArchitectureX86::GetReturnAddressLocation(StackFrame* frame,
+    target_size_t valueSize, ValueLocation*& _location)
+{
+    ValueLocation* location = new(std::nothrow) ValueLocation(
+        IsBigEndian());
+    if (location == NULL)
+        return B_NO_MEMORY;
+    BReference<ValueLocation> locationReference(location,
+        true);
+
+    if (valueSize <= 4) {
+        ValuePieceLocation piece;
+        piece.SetSize(valueSize);
+        piece.SetToRegister(X86_REGISTER_EAX);
+        if (!location->AddPiece(piece))
+            return B_NO_MEMORY;
+    } else if (valueSize <= 8) {
+        ValuePieceLocation piece;
+        piece.SetSize(4);
+        piece.SetToRegister(X86_REGISTER_EAX);
+        if (!location->AddPiece(piece))
+            return B_NO_MEMORY;
+        piece.SetToRegister(X86_REGISTER_EDX);
+        piece.SetSize(valueSize - 4);
+        if (!location->AddPiece(piece))
+            return B_NO_MEMORY;
+    } else {
+        ValuePieceLocation piece;
+        piece.SetToMemory(frame->GetCpuState()->StackPointer());
+        piece.SetSize(valueSize);
+        if (!location->AddPiece(piece))
+            return B_NO_MEMORY;
+    }
+
+    _location = locationReference.Detach();
+    return B_OK;
+}
+
+
 void
 ArchitectureX86::_AddRegister(int32 index, const char* name,
     uint32 bitSize, uint32 valueType, register_type type, bool calleePreserved)

src/apps/debugger/arch/x86/ArchitectureX86.h

@@ -66 +66 @@
                                     int32& _maxBytesPerRegister,
                                     uint8& _watchpointCapabilityFlags);
 
+    virtual status_t            GetReturnAddressLocation(
+                                    StackFrame* frame, target_size_t valueSize,
+                                    ValueLocation*& _location);
+
+
 private:
             struct ToDwarfRegisterMap;
             struct FromDwarfRegisterMap;

src/apps/debugger/arch/x86_64/ArchitectureX8664.cpp

@@ -487 +487 @@
     // disassemble the instruction
     BString line;
     target_addr_t instructionAddress;
+    target_addr_t targetAddress = 0;
     target_size_t instructionSize;
     bool breakpointAllowed;
     error = disassembler.GetNextInstruction(line, instructionAddress,
@@ -508 +509 @@
         }
     }
 
-    if (!_info.SetTo(instructionAddress, instructionSize, instructionType,
-            breakpointAllowed, line)) {
+    if (!_info.SetTo(instructionAddress, targetAddress, instructionSize,
+            instructionType, breakpointAllowed, line)) {
         return B_NO_MEMORY;
     }
 
@@ -534 +535 @@
 }
 
 
+status_t
+ArchitectureX8664::GetReturnAddressLocation(StackFrame* frame,
+    target_size_t valueSize, ValueLocation*& _location) {
+    return B_NOT_SUPPORTED;
+}
+
+
 void
 ArchitectureX8664::_AddRegister(int32 index, const char* name,
     uint32 bitSize, uint32 valueType, register_type type, bool calleePreserved)

src/apps/debugger/arch/x86_64/ArchitectureX8664.h

@@ -67 +67 @@
                                     int32& _maxBytesPerRegister,
                                     uint8& _watchpointCapabilityFlags);
 
+    virtual status_t            GetReturnAddressLocation(
+                                    StackFrame* frame, target_size_t valueSize,
+                                    ValueLocation*& _location);
+
 private:
             struct ToDwarfRegisterMap;
             struct FromDwarfRegisterMap;

src/apps/debugger/debug_info/DwarfImageDebugInfo.cpp

@@ -41 +41 @@
 #include "FunctionID.h"
 #include "FunctionInstance.h"
 #include "GlobalTypeLookup.h"
+#include "Image.h"
+#include "ImageDebugInfo.h"
 #include "InstructionInfo.h"
 #include "LocatableFile.h"
 #include "Register.h"
@@ -56 +58 @@
 #include "TypeLookupConstraints.h"
 #include "UnsupportedLanguage.h"
 #include "Variable.h"
+#include "ValueLocation.h"
 
 
 namespace {
@@ -672 +675 @@
         // call to see if we need to potentially retrieve a return value
         // as well
         if (instructionPointer > functionInstance->Address() - fRelocationDelta) {
-            _CreateReturnValue(functionInstance, function, frame,
+            _CreateReturnValue(functionInstance, image, function, frame,
                 *stackFrameDebugInfo, instructionPointer);
         }
     }
@@ -1085 +1088 @@
 
 status_t
 DwarfImageDebugInfo::_CreateReturnValue(FunctionInstance* functionInstance,
-    DwarfFunctionDebugInfo* function, StackFrame* frame,
+    Image* image, DwarfFunctionDebugInfo* function, StackFrame* frame,
     DwarfStackFrameDebugInfo& factory, target_addr_t instructionPointer)
 {
     DisassembledCode* sourceCode = NULL;
@@ -1111 +1114 @@
         previousStatementAddress);
     if (statement == NULL)
         return B_BAD_VALUE;
+    previousStatementAddress = statement->CoveringAddressRange().Start() - 1;
+    statement = sourceCode->StatementAtAddress(
+        previousStatementAddress);
+    if (statement == NULL)
+        return B_BAD_VALUE;
 
     TargetAddressRange range = statement->CoveringAddressRange();
     InstructionInfo info;
     if (fArchitecture->GetInstructionInfo(range.Start(), info) == B_OK
         && info.Type() == INSTRUCTION_TYPE_SUBROUTINE_CALL) {
-        // TODO: determine where the previous instruction actually jumps to,
-        // retrieve that function (could potentially be in another image),
-        // and use its return type to retrieve the return value (will need
-        // architecture support since function return value passing convention
-        // is arch-dependent).
+        target_addr_t targetAddress = info.TargetAddress();
+        if (targetAddress == 0)
+            return B_BAD_VALUE;
+
+        if (image->ContainsAddress(targetAddress)) {
+            FunctionInstance* targetFunction;
+            if (targetAddress >= fPLTSectionStart && targetAddress < fPLTSectionEnd) {
+                // TODO: resolve actual target address in the PIC case
+                // and adjust targetAddress accordingly
+            }
+            ImageDebugInfo* imageInfo = image->GetImageDebugInfo();
+            targetFunction = imageInfo->FunctionAtAddress(targetAddress);
+            if (targetFunction != NULL) {
+                DwarfFunctionDebugInfo* targetInfo =
+                    dynamic_cast<DwarfFunctionDebugInfo*>(
+                        targetFunction->GetFunctionDebugInfo());
+                if (targetInfo != NULL) {
+                    DIESubprogram* subProgram = targetInfo->SubprogramEntry();
+                    DIEType* returnType = subProgram->ReturnType();
+                    if (returnType == NULL) {
+                        // function doesn't return a value, we're done.
+                        return B_OK;
+                    }
+
+                    ValueLocation* location;
+                    result = fArchitecture->GetReturnAddressLocation(frame,
+                        returnType->ByteSize()->constant, location);
+                    if (result != B_OK)
+                        return result;
+                    BReference<ValueLocation> locationReference(location,
+                        true);
+                    Variable* variable = NULL;
+                    BReference<FunctionID> idReference(
+                        targetFunction->GetFunctionID(), true);
+                    result = factory.CreateReturnValue(idReference,
+                        returnType, location, variable);
+                    if (result != B_OK)
+                        return result;
+                    BReference<Variable> variableReference(variable, true);
+                    if (!frame->AddLocalVariable(variable))
+                        return B_NO_MEMORY;
+                }
+            }
+        }
     }
 
     return B_OK;

src/apps/debugger/debug_info/DwarfImageDebugInfo.h

@@ -104 +104 @@
                                     const EntryListWrapper& blockEntries);
 
             status_t            _CreateReturnValue(FunctionInstance* instance,
+                                    Image* image,
                                     DwarfFunctionDebugInfo* info,
                                     StackFrame* frame,
                                     DwarfStackFrameDebugInfo& factory,

src/apps/debugger/debug_info/DwarfStackFrameDebugInfo.cpp

@@ -1 +1 @@
 /*
+ * Copyright 2012, Rene Gollent, rene@gollent.com.
  * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
  * Distributed under the terms of the MIT License.
  */
@@ -23 +24 @@
 #include "LocalVariableID.h"
 #include "Register.h"
 #include "RegisterMap.h"
+#include "ReturnValueID.h"
 #include "StringUtils.h"
 #include "Tracing.h"
 #include "ValueLocation.h"
@@ -117 +119 @@
 };
 
 
+// #pragma mark - DwarfReturnValueID
+
+
+struct DwarfStackFrameDebugInfo::DwarfReturnValueID
+    : public ReturnValueID {
+
+    DwarfReturnValueID(FunctionID* functionID)
+        :
+        fFunctionID(functionID),
+        fName("(returned)")
+    {
+        fFunctionID->AcquireReference();
+    }
+
+    virtual ~DwarfReturnValueID()
+    {
+        fFunctionID->ReleaseReference();
+    }
+
+    virtual bool operator==(const ObjectID& other) const
+    {
+        const DwarfReturnValueID* returnValueID
+            = dynamic_cast<const DwarfReturnValueID*>(&other);
+        return returnValueID != NULL
+            && *fFunctionID == *returnValueID->fFunctionID
+            && fName == returnValueID->fName;
+    }
+
+protected:
+    virtual uint32 ComputeHashValue() const
+    {
+        uint32 hash = fFunctionID->HashValue();
+        return hash * 25 + StringUtils::HashValue(fName);
+    }
+
+private:
+    FunctionID*     fFunctionID;
+    const BString   fName;
+};
+
+
 // #pragma mark - DwarfStackFrameDebugInfo
 
 
@@ -235 +278 @@
 
 
 status_t
+DwarfStackFrameDebugInfo::CreateReturnValue(FunctionID* functionID,
+    DIEType* returnType, ValueLocation* location, Variable*& _variable)
+{
+    if (returnType == NULL)
+        return B_BAD_VALUE;
+
+    // create the type
+    DwarfType* type;
+    status_t error = fTypeFactory->CreateType(returnType, type);
+    if (error != B_OK)
+        return error;
+    BReference<DwarfType> typeReference(type, true);
+
+    DwarfReturnValueID* id = new(std::nothrow) DwarfReturnValueID(
+        functionID);
+    if (id == NULL)
+        return B_NO_MEMORY;
+
+    BString name;
+    name.SetToFormat("%s returned", functionID->FunctionName().String());
+
+    Variable* variable = new(std::nothrow) Variable(id, name,
+        type, location);
+    if (variable == NULL)
+        return B_NO_MEMORY;
+
+    _variable = variable;
+
+    return B_OK;
+}
+
+
+status_t
 DwarfStackFrameDebugInfo::_CreateVariable(ObjectID* id, const BString& name,
     DIEType* typeEntry, LocationDescription* locationDescription,
     Variable*& _variable)

src/apps/debugger/debug_info/DwarfStackFrameDebugInfo.h

@@ -1 +1 @@
 /*
+ * Copyright 2012, Rene Gollent, rene@gollent.com.
  * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
  * Distributed under the terms of the MIT License.
  */
@@ -56 +57 @@
                                     DIEVariable* variableEntry,
                                     Variable*& _variable);
                                     // returns reference
+            status_t            CreateReturnValue(FunctionID* functionID,
+                                    DIEType* returnType,
+                                    ValueLocation* location,
+                                    Variable*& _variable);
+                                    // returns reference
 
 private:
             struct DwarfFunctionParameterID;
             struct DwarfLocalVariableID;
+            struct DwarfReturnValueID;
 
 private:
             status_t            _CreateVariable(ObjectID* id,