Remove hardcoded registers from Hexagon ABI

[ted]

Summary

The Hexagon ABI plugin uses hardcoded registers when setting up function calls. This is OK for the Hexagon simulator, but the register numbers are different on the gdbserver running on hardware. Change the hardcoded registers to LLDB generic registers.

[clayborg]

You want to check if each reg num is not LLDB_INVALID_REGNUM and return an appropriate error.

[ted]

Updated to check for invalid register numbers.

source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.cpp

 
 // AD 06/05/2014
 //  . how do we adhere to the stack alignment requirements
 
 // AD 06/05/2014
 //  . handle 64bit values and their register / stack requirements
 
 */
-#define HEX_ABI_DEBUG 1
+#define HEX_ABI_DEBUG 0
 bool
 ABISysV_hexagon::PrepareTrivialCall ( Thread &thread, 
                                       lldb::addr_t  sp  , 
                                       lldb::addr_t  pc  , 
                                       lldb::addr_t  ra  , 
                                       llvm::Type   &prototype,
                                       llvm::ArrayRef<ABI::CallArgument> args) const
 {
     // default number of register passed arguments for varg functions
     const int nVArgRegParams = 1;
     Error error;
 
     // grab the process so we have access to the memory for spilling
     lldb::ProcessSP proc = thread.GetProcess( );
 
+    // get the register context for modifying all of the registers
+    RegisterContext *reg_ctx = thread.GetRegisterContext().get();
+    if (!reg_ctx)
+        return false;
+    
+    uint32_t pc_reg = reg_ctx->ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
+    if (pc_reg == LLDB_INVALID_REGNUM)
+        return false;
+
+    uint32_t ra_reg = reg_ctx->ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA);
+    if (ra_reg == LLDB_INVALID_REGNUM)
+        return false;
+
+    uint32_t sp_reg = reg_ctx->ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP);
+    if (sp_reg == LLDB_INVALID_REGNUM)
+        return false;
+
     // push host data onto target
     for ( size_t i = 0; i < args.size( ); i++ )
     {
         const ABI::CallArgument &arg = args[i];
         // skip over target values
         if ( arg.type == ABI::CallArgument::TargetValue )
             continue;
         // round up to 8 byte multiple

 #endif
 
     // make sure number of parameters matches prototype
     assert( prototype.getFunctionNumParams( ) == args.size( ) );
 
     // check if this is a variable argument function
     bool isVArg = prototype.isFunctionVarArg();
 
-    // get the register context for modifying all of the registers
-    RegisterContext *reg_ctx = thread.GetRegisterContext().get();
-    if (!reg_ctx)
-        return false;
-    
     // number of arguments passed by register
     int nRegArgs = nVArgRegParams;
     if (! isVArg )
     {
         // number of arguments is limited by [R0 : R5] space
         nRegArgs = args.size( );
         if ( nRegArgs > 6 )
             nRegArgs = 6;
for ( size_t i = nRegArgs, offs=0; i < args.size( ); i++ )
         proc->WriteMemory( sp + offs, (void*)&param, sizeof( param ), error );
         if ( !error.Success( ) )
             return false;
         // 
         offs += 4;
     }
 
     // update registers with current function call state
-    reg_ctx->WriteRegisterFromUnsigned ( 41, pc );
-    reg_ctx->WriteRegisterFromUnsigned ( 31, ra );
-    reg_ctx->WriteRegisterFromUnsigned ( 29, sp );
-//  reg_ctx->WriteRegisterFromUnsigned ( FP ??? );
+    reg_ctx->WriteRegisterFromUnsigned(pc_reg, pc);
+    reg_ctx->WriteRegisterFromUnsigned(ra_reg, ra);
+    reg_ctx->WriteRegisterFromUnsigned(sp_reg, sp);
 
 #if HEX_ABI_DEBUG
     // quick and dirty stack dumper for debugging
     for ( int i = -8; i < 8; i++ )
     {
         uint32_t data = 0;
         lldb::addr_t addr = sp + i * 4;
         proc->ReadMemory( addr, (void*)&data, sizeof( data ), error );