Skip to content

WIP: Add arm interrupt calling conventions #2387

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
wants to merge 1 commit into from
Closed

WIP: Add arm interrupt calling conventions #2387

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 6 additions & 0 deletions src/all_types.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -479,6 +479,12 @@ enum CallingConvention {
CallingConventionNaked,
CallingConventionStdcall,
CallingConventionAsync,
CallingConventionArmInterruptGeneric,
CallingConventionArmInterruptIRQ,
CallingConventionArmInterruptFIQ,
CallingConventionArmInterruptSWI,
CallingConventionArmInterruptABORT,
CallingConventionArmInterruptUNDEF,
};

struct AstNodeFnProto {
Expand Down
18 changes: 18 additions & 0 deletions src/analyze.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -796,6 +796,12 @@ const char *calling_convention_name(CallingConvention cc) {
case CallingConventionNaked: return "nakedcc";
case CallingConventionStdcall: return "stdcallcc";
case CallingConventionAsync: return "async";
case CallingConventionArmInterruptGeneric: return "arminterruptcc";
case CallingConventionArmInterruptIRQ: return "armirqcc";
case CallingConventionArmInterruptFIQ: return "armfiqcc";
case CallingConventionArmInterruptSWI: return "armswicc";
case CallingConventionArmInterruptABORT: return "armabortcc";
case CallingConventionArmInterruptUNDEF: return "armundefcc";
}
zig_unreachable();
}
Expand All @@ -808,6 +814,12 @@ static const char *calling_convention_fn_type_str(CallingConvention cc) {
case CallingConventionNaked: return "nakedcc ";
case CallingConventionStdcall: return "stdcallcc ";
case CallingConventionAsync: return "async ";
case CallingConventionArmInterruptGeneric: return "arminterruptcc ";
case CallingConventionArmInterruptIRQ: return "armirqcc ";
case CallingConventionArmInterruptFIQ: return "armfiqcc ";
case CallingConventionArmInterruptSWI: return "armswicc ";
case CallingConventionArmInterruptABORT: return "armabortcc ";
case CallingConventionArmInterruptUNDEF: return "armundefcc ";
}
zig_unreachable();
}
Expand All @@ -821,6 +833,12 @@ bool calling_convention_allows_zig_types(CallingConvention cc) {
case CallingConventionCold:
case CallingConventionNaked:
case CallingConventionStdcall:
case CallingConventionArmInterruptGeneric:
case CallingConventionArmInterruptIRQ:
case CallingConventionArmInterruptFIQ:
case CallingConventionArmInterruptSWI:
case CallingConventionArmInterruptABORT:
case CallingConventionArmInterruptUNDEF:
return false;
}
zig_unreachable();
Expand Down
6 changes: 6 additions & 0 deletions src/ast_render.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -120,6 +120,12 @@ static const char *export_string(bool is_export) {
// case CallingConventionCold: return "coldcc ";
// case CallingConventionNaked: return "nakedcc ";
// case CallingConventionStdcall: return "stdcallcc ";
// case CallingConventionArmInterruptGeneric: return "arminterruptcc";
// case CallingConventionArmInterruptIRQ: return "armirqcc";
// case CallingConventionArmInterruptFIQ: return "armfiqcc";
// case CallingConventionArmInterruptSWI: return "armswicc";
// case CallingConventionArmInterruptABORT: return "armabortcc";
// case CallingConventionArmInterruptUNDEF: return "armundefcc";
// }
// zig_unreachable();
//}
Expand Down
74 changes: 69 additions & 5 deletions src/codegen.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -379,6 +379,12 @@ static LLVMCallConv get_llvm_cc(CodeGen *g, CallingConvention cc) {
}
break;
case CallingConventionNaked:
case CallingConventionArmInterruptGeneric:
case CallingConventionArmInterruptIRQ:
case CallingConventionArmInterruptFIQ:
case CallingConventionArmInterruptSWI:
case CallingConventionArmInterruptABORT:
case CallingConventionArmInterruptUNDEF:
zig_unreachable();
case CallingConventionStdcall:
// stdcall calling convention only works on x86.
Expand Down Expand Up @@ -447,6 +453,12 @@ static void maybe_import_dll(CodeGen *g, LLVMValueRef global_value, GlobalLinkag
static bool cc_want_sret_attr(CallingConvention cc) {
switch (cc) {
case CallingConventionNaked:
case CallingConventionArmInterruptGeneric:
case CallingConventionArmInterruptIRQ:
case CallingConventionArmInterruptFIQ:
case CallingConventionArmInterruptSWI:
case CallingConventionArmInterruptABORT:
case CallingConventionArmInterruptUNDEF:
zig_unreachable();
case CallingConventionC:
case CallingConventionCold:
Expand Down Expand Up @@ -549,11 +561,33 @@ static LLVMValueRef fn_llvm_value(CodeGen *g, ZigFn *fn_table_entry) {
break;
}

if (cc == CallingConventionNaked) {
addLLVMFnAttr(fn_table_entry->llvm_value, "naked");
} else {
LLVMSetFunctionCallConv(fn_table_entry->llvm_value, get_llvm_cc(g, fn_type->data.fn.fn_type_id.cc));
}
switch (cc) {
case CallingConventionNaked:
addLLVMFnAttr(fn_table_entry->llvm_value, "naked");
break;
case CallingConventionArmInterruptGeneric:
addLLVMFnAttrStr(fn_table_entry->llvm_value, "interrupt", "");
break;
case CallingConventionArmInterruptIRQ:
addLLVMFnAttrStr(fn_table_entry->llvm_value, "interrupt", "IRQ");
break;
case CallingConventionArmInterruptFIQ:
addLLVMFnAttrStr(fn_table_entry->llvm_value, "interrupt", "FIQ");
break;
case CallingConventionArmInterruptSWI:
addLLVMFnAttrStr(fn_table_entry->llvm_value, "interrupt", "SWI");
break;
case CallingConventionArmInterruptABORT:
addLLVMFnAttrStr(fn_table_entry->llvm_value, "interrupt", "ABORT");
break;
case CallingConventionArmInterruptUNDEF:
addLLVMFnAttrStr(fn_table_entry->llvm_value, "interrupt", "UNDEF");
break;
default:
LLVMSetFunctionCallConv(fn_table_entry->llvm_value, get_llvm_cc(g, fn_type->data.fn.fn_type_id.cc));
break;
};

if (cc == CallingConventionAsync) {
addLLVMFnAttr(fn_table_entry->llvm_value, "optnone");
addLLVMFnAttr(fn_table_entry->llvm_value, "noinline");
Expand Down Expand Up @@ -594,6 +628,24 @@ static LLVMValueRef fn_llvm_value(CodeGen *g, ZigFn *fn_table_entry) {

if (fn_table_entry->alignstack_value != 0) {
addLLVMFnAttrInt(fn_table_entry->llvm_value, "alignstack", fn_table_entry->alignstack_value);
} else {
switch (cc) {
// AAPCS guarantees that sp will be 8-byte aligned on any public interface,
// however this is not necessarily true on taking any interrupt. Instruct
// the backend to perform a realignment as part of the function prologue.
// NOTE: Clang only does this for AAPCS, but it won't hurt APCS, and
// can be overriden by @setAlignStack if required by user
case CallingConventionArmInterruptGeneric:
case CallingConventionArmInterruptIRQ:
case CallingConventionArmInterruptFIQ:
case CallingConventionArmInterruptSWI:
case CallingConventionArmInterruptABORT:
case CallingConventionArmInterruptUNDEF:
addLLVMFnAttrInt(fn_table_entry->llvm_value, "alignstack", 8);
break;
default:
break;
};
}

addLLVMFnAttr(fn_table_entry->llvm_value, "nounwind");
Expand Down Expand Up @@ -7693,6 +7745,12 @@ Buf *codegen_generate_builtin_source(CodeGen *g) {
" Naked,\n"
" Stdcall,\n"
" Async,\n"
" ArmInterruptGeneric,\n"
" ArmInterruptIRQ,\n"
" ArmInterruptFIQ,\n"
" ArmInterruptSWI,\n"
" ArmInterruptABORT,\n"
" ArmInterruptUNDEF,\n"
" };\n"
"\n"
" pub const FnArg = struct {\n"
Expand Down Expand Up @@ -7759,6 +7817,12 @@ Buf *codegen_generate_builtin_source(CodeGen *g) {
assert(CallingConventionNaked == 3);
assert(CallingConventionStdcall == 4);
assert(CallingConventionAsync == 5);
assert(CallingConventionArmInterruptGeneric == 6);
assert(CallingConventionArmInterruptIRQ == 7);
assert(CallingConventionArmInterruptFIQ == 8);
assert(CallingConventionArmInterruptSWI == 9);
assert(CallingConventionArmInterruptABORT == 10);
assert(CallingConventionArmInterruptUNDEF == 11);

assert(FnInlineAuto == 0);
assert(FnInlineAlways == 1);
Expand Down
6 changes: 6 additions & 0 deletions src/ir.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -13633,6 +13633,12 @@ static IrInstruction *ir_analyze_instruction_export(IrAnalyze *ira, IrInstructio
case CallingConventionNaked:
case CallingConventionCold:
case CallingConventionStdcall:
case CallingConventionArmInterruptGeneric:
case CallingConventionArmInterruptIRQ:
case CallingConventionArmInterruptFIQ:
case CallingConventionArmInterruptSWI:
case CallingConventionArmInterruptABORT:
case CallingConventionArmInterruptUNDEF:
add_fn_export(ira->codegen, fn_entry, symbol_name, global_linkage_id, cc == CallingConventionC);
break;
}
Expand Down
24 changes: 24 additions & 0 deletions src/parser.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2032,6 +2032,30 @@ static Optional<AstNodeFnProto> ast_parse_fn_cc(ParseContext *pc) {
expect_token(pc, TokenIdCmpGreaterThan);
return Optional<AstNodeFnProto>::some(res);
}
if (eat_token_if(pc, TokenIdKeywordArmInterruptCC) != nullptr) {
res.cc = CallingConventionArmInterruptGeneric;
return Optional<AstNodeFnProto>::some(res);
}
if (eat_token_if(pc, TokenIdKeywordArmIrqCC) != nullptr) {
res.cc = CallingConventionArmInterruptIRQ;
return Optional<AstNodeFnProto>::some(res);
}
if (eat_token_if(pc, TokenIdKeywordArmFiqCC) != nullptr) {
res.cc = CallingConventionArmInterruptFIQ;
return Optional<AstNodeFnProto>::some(res);
}
if (eat_token_if(pc, TokenIdKeywordArmSwiCC) != nullptr) {
res.cc = CallingConventionArmInterruptSWI;
return Optional<AstNodeFnProto>::some(res);
}
if (eat_token_if(pc, TokenIdKeywordArmAbortCC) != nullptr) {
res.cc = CallingConventionArmInterruptABORT;
return Optional<AstNodeFnProto>::some(res);
}
if (eat_token_if(pc, TokenIdKeywordArmUndefCC) != nullptr) {
res.cc = CallingConventionArmInterruptUNDEF;
return Optional<AstNodeFnProto>::some(res);
}

return Optional<AstNodeFnProto>::none();
}
Expand Down
12 changes: 12 additions & 0 deletions src/tokenizer.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -110,6 +110,12 @@ static const struct ZigKeyword zig_keywords[] = {
{"allowzero", TokenIdKeywordAllowZero},
{"and", TokenIdKeywordAnd},
{"anyerror", TokenIdKeywordAnyerror},
{"arminterruptcc", TokenIdKeywordArmInterruptCC},
{"armirqcc", TokenIdKeywordArmIrqCC},
{"armfiqcc", TokenIdKeywordArmFiqCC},
{"armswicc", TokenIdKeywordArmSwiCC},
{"armabortcc", TokenIdKeywordArmAbortCC},
{"armundefcc", TokenIdKeywordArmUndefCC},
{"asm", TokenIdKeywordAsm},
{"async", TokenIdKeywordAsync},
{"await", TokenIdKeywordAwait},
Expand Down Expand Up @@ -1496,6 +1502,12 @@ const char * token_name(TokenId id) {
case TokenIdIntLiteral: return "IntLiteral";
case TokenIdKeywordAsync: return "async";
case TokenIdKeywordAnyerror: return "anyerror";
case TokenIdKeywordArmInterruptCC: return "arminterruptcc";
case TokenIdKeywordArmIrqCC: return "armirqcc";
case TokenIdKeywordArmFiqCC: return "armfiqcc";
case TokenIdKeywordArmSwiCC: return "armswicc";
case TokenIdKeywordArmAbortCC: return "armabortcc";
case TokenIdKeywordArmUndefCC: return "armundefcc";
case TokenIdKeywordAllowZero: return "allowzero";
case TokenIdKeywordAwait: return "await";
case TokenIdKeywordResume: return "resume";
Expand Down
6 changes: 6 additions & 0 deletions src/tokenizer.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -53,6 +53,12 @@ enum TokenId {
TokenIdKeywordAllowZero,
TokenIdKeywordAnd,
TokenIdKeywordAnyerror,
TokenIdKeywordArmInterruptCC,
TokenIdKeywordArmIrqCC,
TokenIdKeywordArmFiqCC,
TokenIdKeywordArmSwiCC,
TokenIdKeywordArmAbortCC,
TokenIdKeywordArmUndefCC,
TokenIdKeywordAsm,
TokenIdKeywordAsync,
TokenIdKeywordAwait,
Expand Down