contrib/llvm/tools/lldb/source/Expression/ClangFunction.cpp

   1 //===-- ClangFunction.cpp ---------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10
  11 // C Includes
  12 // C++ Includes
  13 // Other libraries and framework includes
  14 #include "clang/AST/ASTContext.h"
  15 #include "clang/AST/RecordLayout.h"
  16 #include "clang/CodeGen/CodeGenAction.h"
  17 #include "clang/CodeGen/ModuleBuilder.h"
  18 #include "clang/Frontend/CompilerInstance.h"
  19 #include "llvm/ADT/StringRef.h"
  20 #include "llvm/ADT/Triple.h"
  21 #include "llvm/ExecutionEngine/ExecutionEngine.h"
  22 #include "llvm/IR/Module.h"
  23
  24 // Project includes
  25 #include "lldb/Expression/ASTStructExtractor.h"
  26 #include "lldb/Expression/ClangExpressionParser.h"
  27 #include "lldb/Expression/ClangFunction.h"
  28 #include "lldb/Expression/IRExecutionUnit.h"
  29 #include "lldb/Symbol/Type.h"
  30 #include "lldb/Core/DataExtractor.h"
  31 #include "lldb/Core/State.h"
  32 #include "lldb/Core/ValueObject.h"
  33 #include "lldb/Core/ValueObjectList.h"
  34 #include "lldb/Interpreter/CommandReturnObject.h"
  35 #include "lldb/Symbol/ClangASTContext.h"
  36 #include "lldb/Symbol/Function.h"
  37 #include "lldb/Target/ExecutionContext.h"
  38 #include "lldb/Target/Process.h"
  39 #include "lldb/Target/RegisterContext.h"
  40 #include "lldb/Target/Target.h"
  41 #include "lldb/Target/Thread.h"
  42 #include "lldb/Target/ThreadPlan.h"
  43 #include "lldb/Target/ThreadPlanCallFunction.h"
  44 #include "lldb/Core/Log.h"
  45
  46 using namespace lldb_private;
  47
  48 //----------------------------------------------------------------------
  49 // ClangFunction constructor
  50 //----------------------------------------------------------------------
  51 ClangFunction::ClangFunction
  52 (
  53     ExecutionContextScope &exe_scope,
  54     const ClangASTType &return_type,
  55     const Address& functionAddress,
  56     const ValueList &arg_value_list
  57 ) :
  58     m_function_ptr (NULL),
  59     m_function_addr (functionAddress),
  60     m_function_return_type(return_type),
  61     m_wrapper_function_name ("__lldb_caller_function"),
  62     m_wrapper_struct_name ("__lldb_caller_struct"),
  63     m_wrapper_args_addrs (),
  64     m_arg_values (arg_value_list),
  65     m_compiled (false),
  66     m_JITted (false)
  67 {
  68     m_jit_process_wp = lldb::ProcessWP(exe_scope.CalculateProcess());
  69     // Can't make a ClangFunction without a process.
  70     assert (m_jit_process_wp.lock());
  71 }
  72
  73 ClangFunction::ClangFunction
  74 (
  75     ExecutionContextScope &exe_scope,
  76     Function &function,
  77     ClangASTContext *ast_context,
  78     const ValueList &arg_value_list
  79 ) :
  80     m_function_ptr (&function),
  81     m_function_addr (),
  82     m_function_return_type (),
  83     m_clang_ast_context (ast_context),
  84     m_wrapper_function_name ("__lldb_function_caller"),
  85     m_wrapper_struct_name ("__lldb_caller_struct"),
  86     m_wrapper_args_addrs (),
  87     m_arg_values (arg_value_list),
  88     m_compiled (false),
  89     m_JITted (false)
  90 {
  91     m_jit_process_wp = lldb::ProcessWP(exe_scope.CalculateProcess());
  92     // Can't make a ClangFunction without a process.
  93     assert (m_jit_process_wp.lock());
  94
  95     m_function_addr = m_function_ptr->GetAddressRange().GetBaseAddress();
  96     m_function_return_type = m_function_ptr->GetClangType().GetFunctionReturnType();
  97 }
  98
  99 //----------------------------------------------------------------------
 100 // Destructor
 101 //----------------------------------------------------------------------
 102 ClangFunction::~ClangFunction()
 103 {
 104 }
 105
 106 unsigned
 107 ClangFunction::CompileFunction (Stream &errors)
 108 {
 109     if (m_compiled)
 110         return 0;
 111
 112     // FIXME: How does clang tell us there's no return value?  We need to handle that case.
 113     unsigned num_errors = 0;
 114
 115     std::string return_type_str (m_function_return_type.GetTypeName());
 116
 117     // Cons up the function we're going to wrap our call in, then compile it...
 118     // We declare the function "extern "C"" because the compiler might be in C++
 119     // mode which would mangle the name and then we couldn't find it again...
 120     m_wrapper_function_text.clear();
 121     m_wrapper_function_text.append ("extern \"C\" void ");
 122     m_wrapper_function_text.append (m_wrapper_function_name);
 123     m_wrapper_function_text.append (" (void *input)\n{\n    struct ");
 124     m_wrapper_function_text.append (m_wrapper_struct_name);
 125     m_wrapper_function_text.append (" \n  {\n");
 126     m_wrapper_function_text.append ("    ");
 127     m_wrapper_function_text.append (return_type_str);
 128     m_wrapper_function_text.append (" (*fn_ptr) (");
 129
 130     // Get the number of arguments.  If we have a function type and it is prototyped,
 131     // trust that, otherwise use the values we were given.
 132
 133     // FIXME: This will need to be extended to handle Variadic functions.  We'll need
 134     // to pull the defined arguments out of the function, then add the types from the
 135     // arguments list for the variable arguments.
 136
 137     uint32_t num_args = UINT32_MAX;
 138     bool trust_function = false;
 139     // GetArgumentCount returns -1 for an unprototyped function.
 140     ClangASTType function_clang_type;
 141     if (m_function_ptr)
 142     {
 143         function_clang_type = m_function_ptr->GetClangType();
 144         if (function_clang_type)
 145         {
 146             int num_func_args = function_clang_type.GetFunctionArgumentCount();
 147             if (num_func_args >= 0)
 148             {
 149                 trust_function = true;
 150                 num_args = num_func_args;
 151             }
 152         }
 153     }
 154
 155     if (num_args == UINT32_MAX)
 156         num_args = m_arg_values.GetSize();
 157
 158     std::string args_buffer;  // This one stores the definition of all the args in "struct caller".
 159     std::string args_list_buffer;  // This one stores the argument list called from the structure.
 160     for (size_t i = 0; i < num_args; i++)
 161     {
 162         std::string type_name;
 163
 164         if (trust_function)
 165         {
 166             type_name = function_clang_type.GetFunctionArgumentTypeAtIndex(i).GetTypeName();
 167         }
 168         else
 169         {
 170             ClangASTType clang_qual_type = m_arg_values.GetValueAtIndex(i)->GetClangType ();
 171             if (clang_qual_type)
 172             {
 173                 type_name = clang_qual_type.GetTypeName();
 174             }
 175             else
 176             {
 177                 errors.Printf("Could not determine type of input value %lu.", i);
 178                 return 1;
 179             }
 180         }
 181
 182         m_wrapper_function_text.append (type_name);
 183         if (i < num_args - 1)
 184             m_wrapper_function_text.append (", ");
 185
 186         char arg_buf[32];
 187         args_buffer.append ("    ");
 188         args_buffer.append (type_name);
 189         snprintf(arg_buf, 31, "arg_%" PRIu64, (uint64_t)i);
 190         args_buffer.push_back (' ');
 191         args_buffer.append (arg_buf);
 192         args_buffer.append (";\n");
 193
 194         args_list_buffer.append ("__lldb_fn_data->");
 195         args_list_buffer.append (arg_buf);
 196         if (i < num_args - 1)
 197             args_list_buffer.append (", ");
 198
 199     }
 200     m_wrapper_function_text.append (");\n"); // Close off the function calling prototype.
 201
 202     m_wrapper_function_text.append (args_buffer);
 203
 204     m_wrapper_function_text.append ("    ");
 205     m_wrapper_function_text.append (return_type_str);
 206     m_wrapper_function_text.append (" return_value;");
 207     m_wrapper_function_text.append ("\n  };\n  struct ");
 208     m_wrapper_function_text.append (m_wrapper_struct_name);
 209     m_wrapper_function_text.append ("* __lldb_fn_data = (struct ");
 210     m_wrapper_function_text.append (m_wrapper_struct_name);
 211     m_wrapper_function_text.append (" *) input;\n");
 212
 213     m_wrapper_function_text.append ("  __lldb_fn_data->return_value = __lldb_fn_data->fn_ptr (");
 214     m_wrapper_function_text.append (args_list_buffer);
 215     m_wrapper_function_text.append (");\n}\n");
 216
 217     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 218     if (log)
 219         log->Printf ("Expression: \n\n%s\n\n", m_wrapper_function_text.c_str());
 220
 221     // Okay, now compile this expression
 222
 223     lldb::ProcessSP jit_process_sp(m_jit_process_wp.lock());
 224     if (jit_process_sp)
 225     {
 226         m_parser.reset(new ClangExpressionParser(jit_process_sp.get(), *this));
 227
 228         num_errors = m_parser->Parse (errors);
 229     }
 230     else
 231     {
 232         errors.Printf("no process - unable to inject function");
 233         num_errors = 1;
 234     }
 235
 236     m_compiled = (num_errors == 0);
 237
 238     if (!m_compiled)
 239         return num_errors;
 240
 241     return num_errors;
 242 }
 243
 244 bool
 245 ClangFunction::WriteFunctionWrapper (ExecutionContext &exe_ctx, Stream &errors)
 246 {
 247     Process *process = exe_ctx.GetProcessPtr();
 248
 249     if (!process)
 250         return false;
 251
 252     lldb::ProcessSP jit_process_sp(m_jit_process_wp.lock());
 253
 254     if (process != jit_process_sp.get())
 255         return false;
 256
 257     if (!m_compiled)
 258         return false;
 259
 260     if (m_JITted)
 261         return true;
 262
 263     bool can_interpret = false; // should stay that way
 264
 265     Error jit_error (m_parser->PrepareForExecution (m_jit_start_addr,
 266                                                     m_jit_end_addr,
 267                                                     m_execution_unit_ap,
 268                                                     exe_ctx,
 269                                                     can_interpret,
 270                                                     eExecutionPolicyAlways));
 271
 272     if (!jit_error.Success())
 273         return false;
 274
 275     if (process && m_jit_start_addr)
 276         m_jit_process_wp = lldb::ProcessWP(process->shared_from_this());
 277
 278     m_JITted = true;
 279
 280     return true;
 281 }
 282
 283 bool
 284 ClangFunction::WriteFunctionArguments (ExecutionContext &exe_ctx, lldb::addr_t &args_addr_ref, Stream &errors)
 285 {
 286     return WriteFunctionArguments(exe_ctx, args_addr_ref, m_function_addr, m_arg_values, errors);
 287 }
 288
 289 // FIXME: Assure that the ValueList we were passed in is consistent with the one that defined this function.
 290
 291 bool
 292 ClangFunction::WriteFunctionArguments (ExecutionContext &exe_ctx,
 293                                        lldb::addr_t &args_addr_ref,
 294                                        Address function_address,
 295                                        ValueList &arg_values,
 296                                        Stream &errors)
 297 {
 298     // All the information to reconstruct the struct is provided by the
 299     // StructExtractor.
 300     if (!m_struct_valid)
 301     {
 302         errors.Printf("Argument information was not correctly parsed, so the function cannot be called.");
 303         return false;
 304     }
 305
 306     Error error;
 307     using namespace clang;
 308     ExecutionResults return_value = eExecutionSetupError;
 309
 310     Process *process = exe_ctx.GetProcessPtr();
 311
 312     if (process == NULL)
 313         return return_value;
 314
 315     lldb::ProcessSP jit_process_sp(m_jit_process_wp.lock());
 316
 317     if (process != jit_process_sp.get())
 318         return false;
 319
 320     if (args_addr_ref == LLDB_INVALID_ADDRESS)
 321     {
 322         args_addr_ref = process->AllocateMemory(m_struct_size, lldb::ePermissionsReadable|lldb::ePermissionsWritable, error);
 323         if (args_addr_ref == LLDB_INVALID_ADDRESS)
 324             return false;
 325         m_wrapper_args_addrs.push_back (args_addr_ref);
 326     }
 327     else
 328     {
 329         // Make sure this is an address that we've already handed out.
 330         if (find (m_wrapper_args_addrs.begin(), m_wrapper_args_addrs.end(), args_addr_ref) == m_wrapper_args_addrs.end())
 331         {
 332             return false;
 333         }
 334     }
 335
 336     // TODO: verify fun_addr needs to be a callable address
 337     Scalar fun_addr (function_address.GetCallableLoadAddress(exe_ctx.GetTargetPtr()));
 338     uint64_t first_offset = m_member_offsets[0];
 339     process->WriteScalarToMemory(args_addr_ref + first_offset, fun_addr, process->GetAddressByteSize(), error);
 340
 341     // FIXME: We will need to extend this for Variadic functions.
 342
 343     Error value_error;
 344
 345     size_t num_args = arg_values.GetSize();
 346     if (num_args != m_arg_values.GetSize())
 347     {
 348         errors.Printf ("Wrong number of arguments - was: %lu should be: %lu", num_args, m_arg_values.GetSize());
 349         return false;
 350     }
 351
 352     for (size_t i = 0; i < num_args; i++)
 353     {
 354         // FIXME: We should sanity check sizes.
 355
 356         uint64_t offset = m_member_offsets[i+1]; // Clang sizes are in bytes.
 357         Value *arg_value = arg_values.GetValueAtIndex(i);
 358
 359         // FIXME: For now just do scalars:
 360
 361         // Special case: if it's a pointer, don't do anything (the ABI supports passing cstrings)
 362
 363         if (arg_value->GetValueType() == Value::eValueTypeHostAddress &&
 364             arg_value->GetContextType() == Value::eContextTypeInvalid &&
 365             arg_value->GetClangType().IsPointerType())
 366             continue;
 367
 368         const Scalar &arg_scalar = arg_value->ResolveValue(&exe_ctx);
 369
 370         if (!process->WriteScalarToMemory(args_addr_ref + offset, arg_scalar, arg_scalar.GetByteSize(), error))
 371             return false;
 372     }
 373
 374     return true;
 375 }
 376
 377 bool
 378 ClangFunction::InsertFunction (ExecutionContext &exe_ctx, lldb::addr_t &args_addr_ref, Stream &errors)
 379 {
 380     using namespace clang;
 381
 382     if (CompileFunction(errors) != 0)
 383         return false;
 384     if (!WriteFunctionWrapper(exe_ctx, errors))
 385         return false;
 386     if (!WriteFunctionArguments(exe_ctx, args_addr_ref, errors))
 387         return false;
 388
 389     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
 390     if (log)
 391         log->Printf ("Call Address: 0x%" PRIx64 " Struct Address: 0x%" PRIx64 ".\n", m_jit_start_addr, args_addr_ref);
 392
 393     return true;
 394 }
 395
 396 ThreadPlan *
 397 ClangFunction::GetThreadPlanToCallFunction (ExecutionContext &exe_ctx,
 398                                             lldb::addr_t func_addr,
 399                                             lldb::addr_t &args_addr,
 400                                             Stream &errors,
 401                                             bool stop_others,
 402                                             bool unwind_on_error,
 403                                             bool ignore_breakpoints,
 404                                             lldb::addr_t *this_arg,
 405                                             lldb::addr_t *cmd_arg)
 406 {
 407     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EXPRESSIONS | LIBLLDB_LOG_STEP));
 408
 409     if (log)
 410         log->Printf("-- [ClangFunction::GetThreadPlanToCallFunction] Creating thread plan to call function --");
 411
 412     // FIXME: Use the errors Stream for better error reporting.
 413     Thread *thread = exe_ctx.GetThreadPtr();
 414     if (thread == NULL)
 415     {
 416         errors.Printf("Can't call a function without a valid thread.");
 417         return NULL;
 418     }
 419
 420     // Okay, now run the function:
 421
 422     Address wrapper_address (func_addr);
 423     ThreadPlan *new_plan = new ThreadPlanCallFunction (*thread,
 424                                                        wrapper_address,
 425                                                        ClangASTType(),
 426                                                        args_addr,
 427                                                        stop_others,
 428                                                        unwind_on_error,
 429                                                        ignore_breakpoints,
 430                                                        this_arg,
 431                                                        cmd_arg);
 432     new_plan->SetIsMasterPlan(true);
 433     new_plan->SetOkayToDiscard (false);
 434     return new_plan;
 435 }
 436
 437 bool
 438 ClangFunction::FetchFunctionResults (ExecutionContext &exe_ctx, lldb::addr_t args_addr, Value &ret_value)
 439 {
 440     // Read the return value - it is the last field in the struct:
 441     // FIXME: How does clang tell us there's no return value?  We need to handle that case.
 442     // FIXME: Create our ThreadPlanCallFunction with the return ClangASTType, and then use GetReturnValueObject
 443     // to fetch the value.  That way we can fetch any values we need.
 444
 445     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EXPRESSIONS | LIBLLDB_LOG_STEP));
 446
 447     if (log)
 448         log->Printf("-- [ClangFunction::FetchFunctionResults] Fetching function results --");
 449
 450     Process *process = exe_ctx.GetProcessPtr();
 451
 452     if (process == NULL)
 453         return false;
 454
 455     lldb::ProcessSP jit_process_sp(m_jit_process_wp.lock());
 456
 457     if (process != jit_process_sp.get())
 458         return false;
 459
 460     Error error;
 461     ret_value.GetScalar() = process->ReadUnsignedIntegerFromMemory (args_addr + m_return_offset, m_return_size, 0, error);
 462
 463     if (error.Fail())
 464         return false;
 465
 466     ret_value.SetClangType(m_function_return_type);
 467     ret_value.SetValueType(Value::eValueTypeScalar);
 468     return true;
 469 }
 470
 471 void
 472 ClangFunction::DeallocateFunctionResults (ExecutionContext &exe_ctx, lldb::addr_t args_addr)
 473 {
 474     std::list<lldb::addr_t>::iterator pos;
 475     pos = std::find(m_wrapper_args_addrs.begin(), m_wrapper_args_addrs.end(), args_addr);
 476     if (pos != m_wrapper_args_addrs.end())
 477         m_wrapper_args_addrs.erase(pos);
 478
 479     exe_ctx.GetProcessRef().DeallocateMemory(args_addr);
 480 }
 481
 482 ExecutionResults
 483 ClangFunction::ExecuteFunction(ExecutionContext &exe_ctx, Stream &errors, Value &results)
 484 {
 485     return ExecuteFunction (exe_ctx, errors, 1000, true, results);
 486 }
 487
 488 ExecutionResults
 489 ClangFunction::ExecuteFunction(ExecutionContext &exe_ctx, Stream &errors, bool stop_others, Value &results)
 490 {
 491     const bool try_all_threads = false;
 492     const bool unwind_on_error = true;
 493     const bool ignore_breakpoints = true;
 494     return ExecuteFunction (exe_ctx, NULL, errors, stop_others, 0UL, try_all_threads,
 495                             unwind_on_error, ignore_breakpoints, results);
 496 }
 497
 498 ExecutionResults
 499 ClangFunction::ExecuteFunction(
 500         ExecutionContext &exe_ctx,
 501         Stream &errors,
 502         uint32_t timeout_usec,
 503         bool try_all_threads,
 504         Value &results)
 505 {
 506     const bool stop_others = true;
 507     const bool unwind_on_error = true;
 508     const bool ignore_breakpoints = true;
 509     return ExecuteFunction (exe_ctx, NULL, errors, stop_others, timeout_usec,
 510                             try_all_threads, unwind_on_error, ignore_breakpoints, results);
 511 }
 512
 513 // This is the static function
 514 ExecutionResults
 515 ClangFunction::ExecuteFunction (
 516         ExecutionContext &exe_ctx,
 517         lldb::addr_t function_address,
 518         lldb::addr_t &void_arg,
 519         bool stop_others,
 520         bool try_all_threads,
 521         bool unwind_on_error,
 522         bool ignore_breakpoints,
 523         uint32_t timeout_usec,
 524         Stream &errors,
 525         lldb::addr_t *this_arg)
 526 {
 527     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EXPRESSIONS | LIBLLDB_LOG_STEP));
 528
 529     if (log)
 530         log->Printf("== [ClangFunction::ExecuteFunction] Executing function ==");
 531
 532     lldb::ThreadPlanSP call_plan_sp (ClangFunction::GetThreadPlanToCallFunction (exe_ctx,
 533                                                                                  function_address,
 534                                                                                  void_arg,
 535                                                                                  errors,
 536                                                                                  stop_others,
 537                                                                                  unwind_on_error,
 538                                                                                  ignore_breakpoints,
 539                                                                                  this_arg));
 540     if (!call_plan_sp)
 541         return eExecutionSetupError;
 542
 543     // <rdar://problem/12027563> we need to make sure we record the fact that we are running an expression here
 544     // otherwise this fact will fail to be recorded when fetching an Objective-C object description
 545     if (exe_ctx.GetProcessPtr())
 546         exe_ctx.GetProcessPtr()->SetRunningUserExpression(true);
 547
 548     ExecutionResults results = exe_ctx.GetProcessRef().RunThreadPlan (exe_ctx, call_plan_sp,
 549                                                                       stop_others,
 550                                                                       try_all_threads,
 551                                                                       unwind_on_error,
 552                                                                       ignore_breakpoints,
 553                                                                       timeout_usec,
 554                                                                       errors);
 555
 556     if (log)
 557     {
 558         if (results != eExecutionCompleted)
 559         {
 560             log->Printf("== [ClangFunction::ExecuteFunction] Execution completed abnormally ==");
 561         }
 562         else
 563         {
 564             log->Printf("== [ClangFunction::ExecuteFunction] Execution completed normally ==");
 565         }
 566     }
 567
 568     if (exe_ctx.GetProcessPtr())
 569         exe_ctx.GetProcessPtr()->SetRunningUserExpression(false);
 570
 571     return results;
 572 }
 573
 574 ExecutionResults
 575 ClangFunction::ExecuteFunction(
 576         ExecutionContext &exe_ctx,
 577         lldb::addr_t *args_addr_ptr,
 578         Stream &errors,
 579         bool stop_others,
 580         uint32_t timeout_usec,
 581         bool try_all_threads,
 582         bool unwind_on_error,
 583         bool ignore_breakpoints,
 584         Value &results)
 585 {
 586     using namespace clang;
 587     ExecutionResults return_value = eExecutionSetupError;
 588
 589     lldb::addr_t args_addr;
 590
 591     if (args_addr_ptr != NULL)
 592         args_addr = *args_addr_ptr;
 593     else
 594         args_addr = LLDB_INVALID_ADDRESS;
 595
 596     if (CompileFunction(errors) != 0)
 597         return eExecutionSetupError;
 598
 599     if (args_addr == LLDB_INVALID_ADDRESS)
 600     {
 601         if (!InsertFunction(exe_ctx, args_addr, errors))
 602             return eExecutionSetupError;
 603     }
 604
 605     return_value = ClangFunction::ExecuteFunction (exe_ctx,
 606                                                    m_jit_start_addr,
 607                                                    args_addr,
 608                                                    stop_others,
 609                                                    try_all_threads,
 610                                                    unwind_on_error,
 611                                                    ignore_breakpoints,
 612                                                    timeout_usec,
 613                                                    errors);
 614
 615     if (args_addr_ptr != NULL)
 616         *args_addr_ptr = args_addr;
 617
 618     if (return_value != eExecutionCompleted)
 619         return return_value;
 620
 621     FetchFunctionResults(exe_ctx, args_addr, results);
 622
 623     if (args_addr_ptr == NULL)
 624         DeallocateFunctionResults(exe_ctx, args_addr);
 625
 626     return eExecutionCompleted;
 627 }
 628
 629 clang::ASTConsumer *
 630 ClangFunction::ASTTransformer (clang::ASTConsumer *passthrough)
 631 {
 632     return new ASTStructExtractor(passthrough, m_wrapper_struct_name.c_str(), *this);
 633 }