const CompilerType &result_type,
const CompilerType *args,
unsigned num_args, bool is_variadic,
- unsigned type_quals);
+ unsigned type_quals,
+ clang::CallingConv cc);
+
+ static CompilerType CreateFunctionType(clang::ASTContext *ast,
+ const CompilerType &result_type,
+ const CompilerType *args,
+ unsigned num_args, bool is_variadic,
+ unsigned type_quals) {
+ return ClangASTContext::CreateFunctionType(
+ ast, result_type, args, num_args, is_variadic, type_quals, clang::CC_C);
+ }
CompilerType CreateFunctionType(const CompilerType &result_type,
const CompilerType *args, unsigned num_args,
getASTContext(), result_type, args, num_args, is_variadic, type_quals);
}
+ CompilerType CreateFunctionType(const CompilerType &result_type,
+ const CompilerType *args, unsigned num_args,
+ bool is_variadic, unsigned type_quals,
+ clang::CallingConv cc) {
+ return ClangASTContext::CreateFunctionType(getASTContext(), result_type,
+ args, num_args, is_variadic,
+ type_quals, cc);
+ }
+
clang::ParmVarDecl *CreateParameterDeclaration(const char *name,
const CompilerType ¶m_type,
int storage);
--- /dev/null
+int FuncCCall() { return 0; }
+auto FuncCCallPtr = &FuncCCall;
+
+int __stdcall FuncStdCall() { return 0; }
+auto FuncStdCallPtr = &FuncStdCall;
+
+int __fastcall FuncFastCall() { return 0; }
+auto FuncFastCallPtr = &FuncFastCall;
+
+int __vectorcall FuncVectorCall() { return 0; }
+auto FuncVectorCallPtr = &FuncVectorCall;
+
+struct S {
+ int FuncThisCall() { return 0; }
+};
+auto FuncThisCallPtr = &S::FuncThisCall;
+
+int main() {
+ return 0;
+}
--- /dev/null
+REQUIRES: windows, lld
+RUN: clang-cl -m32 /Zi /GS- /c %S/Inputs/CallingConventionsTest.cpp /o %t.obj
+RUN: lld-link /debug:full /nodefaultlib /entry:main %t.obj /out:%t.exe
+RUN: lldb-test symbols -dump-ast %t.exe | FileCheck %s
+
+CHECK: Module: {{.*}}
+CHECK-DAG: int (*FuncCCallPtr)();
+CHECK-DAG: int (*FuncStdCallPtr)() __attribute__((stdcall));
+CHECK-DAG: int (*FuncFastCallPtr)() __attribute__((fastcall));
+CHECK-DAG: int (*FuncVectorCallPtr)() __attribute__((vectorcall));
+CHECK-DAG: int (S::*FuncThisCallPtr)() __attribute__((thiscall));
MAIN: Variable{{.*}}, name = "p_member_field"
MAIN-SAME: (int ST::*), scope = local
MAIN: Variable{{.*}}, name = "p_member_method"
-MAIN-SAME: (int (ST::*)(int)), scope = local
+MAIN-SAME: (int (ST::*)(int) __attribute__((thiscall))), scope = local
F: Function{[[FID2:.*]]}, demangled = {{.*}}f(int)
F-NEXT: Block{[[FID2]]}
return name == "`anonymous namespace'" || name == "`anonymous-namespace'";
}
+static clang::CallingConv TranslateCallingConvention(PDB_CallingConv pdb_cc) {
+ switch (pdb_cc) {
+ case llvm::codeview::CallingConvention::NearC:
+ return clang::CC_C;
+ case llvm::codeview::CallingConvention::NearStdCall:
+ return clang::CC_X86StdCall;
+ case llvm::codeview::CallingConvention::NearFast:
+ return clang::CC_X86FastCall;
+ case llvm::codeview::CallingConvention::ThisCall:
+ return clang::CC_X86ThisCall;
+ case llvm::codeview::CallingConvention::NearVector:
+ return clang::CC_X86VectorCall;
+ case llvm::codeview::CallingConvention::NearPascal:
+ return clang::CC_X86Pascal;
+ default:
+ assert(false && "Unknown calling convention");
+ return clang::CC_C;
+ }
+}
+
PDBASTParser::PDBASTParser(lldb_private::ClangASTContext &ast) : m_ast(ast) {}
PDBASTParser::~PDBASTParser() {}
type_quals |= clang::Qualifiers::Const;
if (func_sig->isVolatileType())
type_quals |= clang::Qualifiers::Volatile;
+ auto cc = TranslateCallingConvention(func_sig->getCallingConvention());
CompilerType func_sig_ast_type =
m_ast.CreateFunctionType(return_ast_type, arg_list.data(),
- arg_list.size(), is_variadic, type_quals);
+ arg_list.size(), is_variadic, type_quals, cc);
GetDeclarationForSymbol(type, decl);
return std::make_shared<lldb_private::Type>(
CompilerType ClangASTContext::CreateFunctionType(
ASTContext *ast, const CompilerType &result_type, const CompilerType *args,
- unsigned num_args, bool is_variadic, unsigned type_quals) {
+ unsigned num_args, bool is_variadic, unsigned type_quals,
+ clang::CallingConv cc) {
if (ast == nullptr)
return CompilerType(); // invalid AST
// TODO: Detect calling convention in DWARF?
FunctionProtoType::ExtProtoInfo proto_info;
+ proto_info.ExtInfo = cc;
proto_info.Variadic = is_variadic;
proto_info.ExceptionSpec = EST_None;
proto_info.TypeQuals = type_quals;