From 93388a3757523a6d645bf4476c64b63521ab560a Mon Sep 17 00:00:00 2001 From: prime Date: Mon, 28 Dec 2015 02:29:17 +0900 Subject: [PATCH 01/51] Add code_generator.h --- src/code_generator/code_generator.h | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 src/code_generator/code_generator.h diff --git a/src/code_generator/code_generator.h b/src/code_generator/code_generator.h new file mode 100644 index 00000000..9c616f31 --- /dev/null +++ b/src/code_generator/code_generator.h @@ -0,0 +1,4 @@ +#ifndef KMC_C89_COMPILER_CODE_GENERATOR_H +#define KMC_C89_COMPILER_CODE_GENERATOR_H + +#endif /* KMC_C89_COMPILER_CODE_GENERATOR_H */ From bf4598cf6d8880526cf42938268f93671646e4ae Mon Sep 17 00:00:00 2001 From: prime Date: Tue, 29 Dec 2015 20:33:57 +0900 Subject: [PATCH 02/51] add declarations in header --- src/code_generator/code_generator.h | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/src/code_generator/code_generator.h b/src/code_generator/code_generator.h index 9c616f31..145f8426 100644 --- a/src/code_generator/code_generator.h +++ b/src/code_generator/code_generator.h @@ -1,4 +1,21 @@ #ifndef KMC_C89_COMPILER_CODE_GENERATOR_H #define KMC_C89_COMPILER_CODE_GENERATOR_H +#include +#include "ast.h" +#include "ast/external_definitions.h" +#include "utility.h" +#include "vector.h" + +#define ParameterTypeFunc(func) VECTORFUNC(LLVMTypeRef, func) + +DECLARE_VECTOR(LLVMTypeRef) + +typedef VECTORREF(LLVMTypeRef) ParameterTypeRef; + +void translation_unit(LLVMModuleRef module, AstTranslationUnitRef translation_unit); +LLVMTypeRef get_type(AstRef ast); +ParameterTypeRef get_parameter_types(AstRef ast); +void build_block(LLVMModuleRef module, LLVMBuilderRef builder, AstRef ast); + #endif /* KMC_C89_COMPILER_CODE_GENERATOR_H */ From 6ca86630c4ceb6dd7ed42994d506a3de94f5cf99 Mon Sep 17 00:00:00 2001 From: prime Date: Tue, 29 Dec 2015 20:10:52 +0900 Subject: [PATCH 03/51] add code_generator/statements.c --- src/code_generator/statements.c | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 src/code_generator/statements.c diff --git a/src/code_generator/statements.c b/src/code_generator/statements.c new file mode 100644 index 00000000..50bf522e --- /dev/null +++ b/src/code_generator/statements.c @@ -0,0 +1,11 @@ +#include "code_generator.h" +#include "ast/is_method.h" +#include "ast/get_method.h" +#include "ast/ast_impl.h" + +void build_block(LLVMModuleRef module, LLVMBuilderRef builder, AstRef ast) { + switch (ast->tag) { + case AST_COMPOUND_STATEMENT: + default: + } +} From ae0d6d4ad5767985e7748c81382568464bc3b469 Mon Sep 17 00:00:00 2001 From: prime Date: Tue, 29 Dec 2015 20:13:56 +0900 Subject: [PATCH 04/51] add code_generator/translation_unit.c --- src/code_generator/translation_unit.c | 52 +++++++++++++++++++++++++++ 1 file changed, 52 insertions(+) create mode 100644 src/code_generator/translation_unit.c diff --git a/src/code_generator/translation_unit.c b/src/code_generator/translation_unit.c new file mode 100644 index 00000000..2ac8e686 --- /dev/null +++ b/src/code_generator/translation_unit.c @@ -0,0 +1,52 @@ +#include "code_generator.h" +#include "ast/external_definitions_impl.h" +#include "stdstring.h" +#include "ast/is_method.h" +#include "ast/get_method.h" +#include "ast/ast_impl.h" + +LLVMTypeRef get_function_type(AstFunctionDefinitionRef function_definition); +StringRef get_function_name(AstFunctionDefinitionRef function_definition); + +LLVMTypeRef get_type(AstRef ast) { + switch (ast->tag) { + case AST_DECLARATION_SPECIFIER_LIST: + return LLVMInt32Type(); + default: + return NULL; + } +} + +LLVMTypeRef get_function_type(AstFunctionDefinitionRef function_definition) { + LLVMTypeRef return_type = get_type(function_definition->declaration_specifier_list); + ParameterTypeRef parameter_types = get_parameter_types(function_definition->declarator); + return LLVMFunctionType( + return_type, + ParameterTypeFunc(data)(parameter_types), + ParameterTypeFunc(size)(parameter_types), + false); +} + +void define_function(LLVMModuleRef module, LLVMBuilderRef builder, + AstFunctionDefinitionRef function_definition) { + StringRef name = get_function_name(function_definition); + LLVMTypeRef type = get_function_type(function_definition); + LLVMValueRef func = LLVMAddFunction(module, string_data(name), type); + LLVMBasicBlockRef entry = LLVMAppendBasicBlock(func, "entry"); + LLVMPositionBuilderAtEnd(builder, entry); + build_block(module, builder, function_definition->compound_statement); +} + +void translation_unit(LLVMModuleRef module, AstTranslationUnitRef translation_unit) { + AstVectorRef vector = translation_unit->external_declaration_vector; + LLVMBuilderRef builder = LLVMCreateBuilder(); + int i; + for (i = 0; i < (int)AST_VECTOR_FUNC(size)(vector); ++i) { + AstRef external_declaration = AST_VECTOR_FUNC(at)(vector, i); + if (ast_is_function_definition(external_declaration)) { + define_function(module, builder, ast_get_function_definition(external_declaration)); + } else { + /* declaration(ast_get_declaration(external_declaration)); */ + } + } +} From b5c4fd0552ab7c9932e48020f2e0cbe2aa89bd66 Mon Sep 17 00:00:00 2001 From: prime Date: Tue, 29 Dec 2015 20:51:12 +0900 Subject: [PATCH 05/51] add parameter_type.c --- src/code_generator/parameter_type.c | 60 +++++++++++++++++++++++++++++ 1 file changed, 60 insertions(+) create mode 100644 src/code_generator/parameter_type.c diff --git a/src/code_generator/parameter_type.c b/src/code_generator/parameter_type.c new file mode 100644 index 00000000..8b81cd7b --- /dev/null +++ b/src/code_generator/parameter_type.c @@ -0,0 +1,60 @@ +#include "code_generator.h" +#include "ast/declarations_impl.h" +#include "ast/is_method.h" +#include "ast/get_method.h" +#include "ast/ast_impl.h" + +DEFINE_VECTOR(LLVMTypeRef) + +ParameterTypeRef get_parameter_types_declarator(AstDeclaratorRef declarator) { + return get_parameter_types(declarator->direct_declarator); +} + +ParameterTypeRef get_parameter_types_direct_declarator(AstDirectDeclaratorRef direct_declarator) { + return get_parameter_types(direct_declarator->direct_declarator); +} + +ParameterTypeRef get_parameter_types_function_declarator(AstFunctionDeclaratorRef function_declarator) { + return get_parameter_types(function_declarator->parameter_type_list); +} + +ParameterTypeRef get_parameter_types_parameter_type_list(AstParameterTypeListRef parameter_type_list) { + return get_parameter_types(parameter_type_list->parameter_type_list); +} + +ParameterTypeRef get_parameter_types_parameter_list(AstParameterListRef parameter_list) { + AstVectorRef parameter_vector = parameter_list->parameter_declaration_vector; + ParameterTypeRef parameter_types = ParameterTypeFunc(ctor)(NULL); + int i; + for (i = 0; i < (int)AST_VECTOR_FUNC(size)(parameter_vector); i++) { + AstParameterDeclarationRef parameter_declaration = + ast_get_parameter_declaration(AST_VECTOR_FUNC(at)(parameter_vector, i)); + if (ast_is_parameter_concrete_declaration( + parameter_declaration->parameter_declaration)) { + AstParameterConcreteDeclarationRef parameter_concrete_declaration = + ast_get_parameter_concrete_declaration(parameter_declaration->parameter_declaration); + ParameterTypeFunc(push_back)(parameter_types, + get_type(parameter_concrete_declaration->declaration_specifier_list)); + } else { + return NULL; + } + } + return parameter_types; +} + +ParameterTypeRef get_parameter_types(AstRef ast) { + switch (ast->tag) { + case AST_DECLARATOR: + return get_parameter_types_declarator(ast_get_declarator(ast)); + case AST_DIRECT_DECLARATOR: + return get_parameter_types_direct_declarator(ast_get_direct_declarator(ast)); + case AST_FUNCTION_DECLARATOR: + return get_parameter_types_function_declarator(ast_get_function_declarator(ast)); + case AST_PARAMETER_TYPE_LIST: + return get_parameter_types_parameter_type_list(ast_get_parameter_type_list(ast)); + case AST_PARAMETER_LIST: + return get_parameter_types_parameter_list(ast_get_parameter_list(ast)); + default: + return NULL; + } +} From 33baf49fe13de37adefc7b81b96c409b0c0a1cb4 Mon Sep 17 00:00:00 2001 From: prime Date: Tue, 29 Dec 2015 22:58:32 +0900 Subject: [PATCH 06/51] write build_block --- src/code_generator/statements.c | 44 +++++++++++++++++++++++++++++++++ 1 file changed, 44 insertions(+) diff --git a/src/code_generator/statements.c b/src/code_generator/statements.c index 50bf522e..b3ae4747 100644 --- a/src/code_generator/statements.c +++ b/src/code_generator/statements.c @@ -3,9 +3,53 @@ #include "ast/get_method.h" #include "ast/ast_impl.h" +void build_block_compound_statement( + LLVMModuleRef module, LLVMBuilderRef builder, + AstCompoundStatementRef compound_statement) { + build_block(module, builder, compound_statement->declaration_list); + build_block(module, builder, compound_statement->statement_list); +} + +void build_block_declaration_list( + LLVMModuleRef module, LLVMBuilderRef builder, + AstDeclarationListRef declaration_list) { + AstVectorRef declaration_vector = declaration_list->declaration_vector; + int i; + for (i = 0; i < AST_VECTOR_FUNC(size)(declaration_vector); i++) { + build_block(AST_VECTOR_FUNC(at)(declaration_vector, i)); + } +} + +void build_block_statement_list( + LLVMModuleRef module, LLVMBuilderRef builder, + AstStatementListRef statement_list) { + AstVectorRef statement_vector = statement_list->statement_vector; + int i; + for (i = 0; i < AST_VECTOR_FUNC(size)(statement_vector); i++) { + build_block(AST_VECTOR_FUNC(at)(statement_vector, i)); + } +} + +void build_block_statement_list( + LLVMModuleRef module, LLVMBuilderRef builder, + AstStatementListRef statement_list) { +} + +void build_block_statement( + LLVMModuleRef module, LLVMBuilderRef builder, + AstStatement statement) { +} + void build_block(LLVMModuleRef module, LLVMBuilderRef builder, AstRef ast) { switch (ast->tag) { case AST_COMPOUND_STATEMENT: + build_block_compound_statement(module, builder, ast_get_compound_statement(ast)); break; + case AST_DECLARATION_LIST: + build_block_declaration_list(module, builder, ast_get_declaration_list(ast)); break; + case AST_STATEMENT_LIST: + build_block_statement_list(module, builder, ast_get_statement_list(ast)); break; + case AST_STATEMENT: + build_block_statement(module, builder, ast_get_statement(ast)); break; default: } } From 68f951eba68ab645d1216b2b5a67ffb73d637953 Mon Sep 17 00:00:00 2001 From: prime Date: Tue, 29 Dec 2015 22:58:42 +0900 Subject: [PATCH 07/51] fix Makefile --- src/Makefile | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/Makefile b/src/Makefile index f2d17681..0c559e18 100644 --- a/src/Makefile +++ b/src/Makefile @@ -10,6 +10,10 @@ AST_DIR := ast AST_SRCS := $(wildcard $(AST_DIR)/*.c) AST_OBJS := $(AST_SRCS:.c=.o) +CODEGEN_DIR := code_generator +CODEGEN_SRCS := $(wildcard $(CODEGEN_DIR)/*.c) +CODEGEN_OBJS := $(CODEGEN_SRCS:.c=.o) + LEX_SRC := lexer.l LEX_INTERMEDIATE := lex.yy.c LEX_TARGET := lex.yy.o @@ -23,6 +27,7 @@ YACC := bison YACC_OPTION := -d TARGET := kmc89 OBJS += $(AST_OBJS) +OBJS += $(CODEGEN_OBJS) OBJS += $(LEX_TARGET) $(YACC_TARGET) CLEAN_OBJS += $(LEX_INTERMEDIATE) $(YACC_INTERMEDIATE) From fc3c97580d15da2bfc78c05691b2778a85564630 Mon Sep 17 00:00:00 2001 From: prime Date: Tue, 29 Dec 2015 23:36:25 +0900 Subject: [PATCH 08/51] move get_type and prototype declarations --- src/code_generator/code_generator.h | 2 ++ src/code_generator/translation_unit.c | 12 ------------ src/code_generator/type.c | 14 ++++++++++++++ 3 files changed, 16 insertions(+), 12 deletions(-) create mode 100644 src/code_generator/type.c diff --git a/src/code_generator/code_generator.h b/src/code_generator/code_generator.h index 145f8426..9520a208 100644 --- a/src/code_generator/code_generator.h +++ b/src/code_generator/code_generator.h @@ -16,6 +16,8 @@ typedef VECTORREF(LLVMTypeRef) ParameterTypeRef; void translation_unit(LLVMModuleRef module, AstTranslationUnitRef translation_unit); LLVMTypeRef get_type(AstRef ast); ParameterTypeRef get_parameter_types(AstRef ast); +LLVMTypeRef get_function_type(AstFunctionDefinitionRef function_definition); +StringRef get_function_name(AstFunctionDefinitionRef function_definition); void build_block(LLVMModuleRef module, LLVMBuilderRef builder, AstRef ast); #endif /* KMC_C89_COMPILER_CODE_GENERATOR_H */ diff --git a/src/code_generator/translation_unit.c b/src/code_generator/translation_unit.c index 2ac8e686..2d723f6d 100644 --- a/src/code_generator/translation_unit.c +++ b/src/code_generator/translation_unit.c @@ -5,18 +5,6 @@ #include "ast/get_method.h" #include "ast/ast_impl.h" -LLVMTypeRef get_function_type(AstFunctionDefinitionRef function_definition); -StringRef get_function_name(AstFunctionDefinitionRef function_definition); - -LLVMTypeRef get_type(AstRef ast) { - switch (ast->tag) { - case AST_DECLARATION_SPECIFIER_LIST: - return LLVMInt32Type(); - default: - return NULL; - } -} - LLVMTypeRef get_function_type(AstFunctionDefinitionRef function_definition) { LLVMTypeRef return_type = get_type(function_definition->declaration_specifier_list); ParameterTypeRef parameter_types = get_parameter_types(function_definition->declarator); diff --git a/src/code_generator/type.c b/src/code_generator/type.c new file mode 100644 index 00000000..d35c193f --- /dev/null +++ b/src/code_generator/type.c @@ -0,0 +1,14 @@ +#include "code_generator.h" +#include "stdstring.h" +#include "ast/is_method.h" +#include "ast/get_method.h" +#include "ast/ast_impl.h" + +LLVMTypeRef get_type(AstRef ast) { + switch (ast->tag) { + case AST_DECLARATION_SPECIFIER_LIST: + return LLVMInt32Type(); + default: + return NULL; + } +} From e88361dba374d049074b6361542afa7222d90a9e Mon Sep 17 00:00:00 2001 From: prime Date: Tue, 29 Dec 2015 23:41:46 +0900 Subject: [PATCH 09/51] add header --- src/code_generator/code_generator.h | 1 + 1 file changed, 1 insertion(+) diff --git a/src/code_generator/code_generator.h b/src/code_generator/code_generator.h index 9520a208..b1034b6b 100644 --- a/src/code_generator/code_generator.h +++ b/src/code_generator/code_generator.h @@ -6,6 +6,7 @@ #include "ast/external_definitions.h" #include "utility.h" #include "vector.h" +#include "stdstring.h" #define ParameterTypeFunc(func) VECTORFUNC(LLVMTypeRef, func) From 43021f35dd2a9b99b1f0c18351175eaf7dfb5730 Mon Sep 17 00:00:00 2001 From: prime Date: Tue, 29 Dec 2015 23:42:29 +0900 Subject: [PATCH 10/51] add header --- src/code_generator/statements.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/code_generator/statements.c b/src/code_generator/statements.c index b3ae4747..c90bdece 100644 --- a/src/code_generator/statements.c +++ b/src/code_generator/statements.c @@ -1,4 +1,5 @@ #include "code_generator.h" +#include "ast/statements_impl.h" #include "ast/is_method.h" #include "ast/get_method.h" #include "ast/ast_impl.h" From 6ccb665c57d960e183fd1b18aa96e48d3c30cdef Mon Sep 17 00:00:00 2001 From: prime Date: Tue, 29 Dec 2015 23:44:52 +0900 Subject: [PATCH 11/51] fix code --- src/code_generator/statements.c | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/src/code_generator/statements.c b/src/code_generator/statements.c index c90bdece..95b9fbcb 100644 --- a/src/code_generator/statements.c +++ b/src/code_generator/statements.c @@ -17,7 +17,7 @@ void build_block_declaration_list( AstVectorRef declaration_vector = declaration_list->declaration_vector; int i; for (i = 0; i < AST_VECTOR_FUNC(size)(declaration_vector); i++) { - build_block(AST_VECTOR_FUNC(at)(declaration_vector, i)); + build_block(module, builder, AST_VECTOR_FUNC(at)(declaration_vector, i)); } } @@ -27,18 +27,21 @@ void build_block_statement_list( AstVectorRef statement_vector = statement_list->statement_vector; int i; for (i = 0; i < AST_VECTOR_FUNC(size)(statement_vector); i++) { - build_block(AST_VECTOR_FUNC(at)(statement_vector, i)); + build_block(module, builder, AST_VECTOR_FUNC(at)(statement_vector, i)); } } -void build_block_statement_list( +void build_block_statement( LLVMModuleRef module, LLVMBuilderRef builder, - AstStatementListRef statement_list) { + AstStatementRef statement) { + build_block(module, builder, statement->statement); } -void build_block_statement( +void build_block_expression_statement( LLVMModuleRef module, LLVMBuilderRef builder, - AstStatement statement) { + AstExpressionStatementRef expression_statement) { + if (expression_statement->expression != NULL) + build_expression(module, builder, expression_statement->expression); } void build_block(LLVMModuleRef module, LLVMBuilderRef builder, AstRef ast) { @@ -51,6 +54,8 @@ void build_block(LLVMModuleRef module, LLVMBuilderRef builder, AstRef ast) { build_block_statement_list(module, builder, ast_get_statement_list(ast)); break; case AST_STATEMENT: build_block_statement(module, builder, ast_get_statement(ast)); break; - default: + case AST_EXPRESSION_STATEMENT: + build_block_expression_statement(module, builder, ast_get_expression_statement(ast)); break; + default:; } } From 222d70efafb1386d22f9829dacc328418185d234 Mon Sep 17 00:00:00 2001 From: prime Date: Tue, 29 Dec 2015 23:45:46 +0900 Subject: [PATCH 12/51] add prototype declaration --- src/code_generator/code_generator.h | 1 + 1 file changed, 1 insertion(+) diff --git a/src/code_generator/code_generator.h b/src/code_generator/code_generator.h index b1034b6b..11929c6a 100644 --- a/src/code_generator/code_generator.h +++ b/src/code_generator/code_generator.h @@ -20,5 +20,6 @@ ParameterTypeRef get_parameter_types(AstRef ast); LLVMTypeRef get_function_type(AstFunctionDefinitionRef function_definition); StringRef get_function_name(AstFunctionDefinitionRef function_definition); void build_block(LLVMModuleRef module, LLVMBuilderRef builder, AstRef ast); +LLVMValueRef build_expression(LLVMModuleRef module, LLVMBuilderRef builder, AstRef ast); #endif /* KMC_C89_COMPILER_CODE_GENERATOR_H */ From edbefa9b6ba72dc1d4a224c5ae5ad860ab8a111a Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 00:54:31 +0900 Subject: [PATCH 13/51] add expression.c --- src/code_generator/expression.c | 50 +++++++++++++++++++++++++++++++++ 1 file changed, 50 insertions(+) create mode 100644 src/code_generator/expression.c diff --git a/src/code_generator/expression.c b/src/code_generator/expression.c new file mode 100644 index 00000000..6e149358 --- /dev/null +++ b/src/code_generator/expression.c @@ -0,0 +1,50 @@ +#include "code_generator.h" +#include "ast/expressions_impl.h" +#include "ast/is_method.h" +#include "ast/get_method.h" +#include "ast/ast_impl.h" + +LLVMValueRef build_expression_expression( + LLVMModuleRef module, LLVMBuilderRef builder, + AstExpressionRef expression) { + return build_expression(module, builder, expression->expression); +} + +LLVMValueRef build_expression_comma_expression( + LLVMModuleRef module, LLVMBuilderRef builder, + AstCommaExpressionRef comma_expression) { + build_expression(module, builder, comma_expression->expression); + return build_expression(module, builder, comma_expression->expression); +} + +LLVMValueRef build_expression_assignment_expression( + LLVMModuleRef module, LLVMBuilderRef builder, + AstAssignmentExpressionRef expression) { + return build_expression(module, builder, expression->expression); +} + +LLVMValueRef get_value(AstRef); + +LLVMValueRef build_expression_basic_assignment_expression( + LLVMModuleRef module, LLVMBuilderRef builder, + AstBasicAssignmentExpressionRef expression) { + LLVMValueRef rhs = build_expression(module, builder, expression->assignment); + return LLVMBuildStore(builder, rhs, get_value(expression->unary)); +} + +LLVMValueRef build_expression( + LLVMModuleRef module, LLVMBuilderRef builder, AstRef ast) { + switch (ast->tag) { + case AST_EXPRESSION: + return build_expression_expression(module, builder, ast_get_expression(ast)); + case AST_COMMA_EXPRESSION: + return build_expression_comma_expression(module, builder, ast_get_comma_expression(ast)); + case AST_ASSIGNMENT_EXPRESSION: + return build_expression_assignment_expression(module, builder, ast_get_assignment_expression(ast)); + case AST_BASIC_ASSIGNMENT_EXPRESSION: + return build_expression_basic_assignment_expression(module, builder, ast_get_basic_assignment_expression(ast)); + case AST_CONDITIONAL_EXPRESSION:; + default:; + } + return NULL; +} From bdbf7326a6c54d7af1f22cb8115e357e711d1425 Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 01:54:32 +0900 Subject: [PATCH 14/51] add parameter variable_set --- src/code_generator/code_generator.h | 5 +++-- src/code_generator/expression.c | 33 +++++++++++++-------------- src/code_generator/statements.c | 35 +++++++++++++++-------------- 3 files changed, 37 insertions(+), 36 deletions(-) diff --git a/src/code_generator/code_generator.h b/src/code_generator/code_generator.h index 11929c6a..209c77f6 100644 --- a/src/code_generator/code_generator.h +++ b/src/code_generator/code_generator.h @@ -7,6 +7,7 @@ #include "utility.h" #include "vector.h" #include "stdstring.h" +#include "variable_set.h" #define ParameterTypeFunc(func) VECTORFUNC(LLVMTypeRef, func) @@ -19,7 +20,7 @@ LLVMTypeRef get_type(AstRef ast); ParameterTypeRef get_parameter_types(AstRef ast); LLVMTypeRef get_function_type(AstFunctionDefinitionRef function_definition); StringRef get_function_name(AstFunctionDefinitionRef function_definition); -void build_block(LLVMModuleRef module, LLVMBuilderRef builder, AstRef ast); -LLVMValueRef build_expression(LLVMModuleRef module, LLVMBuilderRef builder, AstRef ast); +void build_block(LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstRef ast); +LLVMValueRef build_expression(LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstRef ast); #endif /* KMC_C89_COMPILER_CODE_GENERATOR_H */ diff --git a/src/code_generator/expression.c b/src/code_generator/expression.c index 6e149358..63e8223f 100644 --- a/src/code_generator/expression.c +++ b/src/code_generator/expression.c @@ -1,48 +1,47 @@ #include "code_generator.h" +#include "variable_set.h" #include "ast/expressions_impl.h" #include "ast/is_method.h" #include "ast/get_method.h" #include "ast/ast_impl.h" LLVMValueRef build_expression_expression( - LLVMModuleRef module, LLVMBuilderRef builder, + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstExpressionRef expression) { - return build_expression(module, builder, expression->expression); + return build_expression(module, builder, variable_set, expression->expression); } LLVMValueRef build_expression_comma_expression( - LLVMModuleRef module, LLVMBuilderRef builder, + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstCommaExpressionRef comma_expression) { - build_expression(module, builder, comma_expression->expression); - return build_expression(module, builder, comma_expression->expression); + build_expression(module, builder, variable_set, comma_expression->expression); + return build_expression(module, builder, variable_set, comma_expression->expression); } LLVMValueRef build_expression_assignment_expression( - LLVMModuleRef module, LLVMBuilderRef builder, + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstAssignmentExpressionRef expression) { - return build_expression(module, builder, expression->expression); + return build_expression(module, builder, variable_set, expression->expression); } -LLVMValueRef get_value(AstRef); - LLVMValueRef build_expression_basic_assignment_expression( - LLVMModuleRef module, LLVMBuilderRef builder, + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstBasicAssignmentExpressionRef expression) { - LLVMValueRef rhs = build_expression(module, builder, expression->assignment); - return LLVMBuildStore(builder, rhs, get_value(expression->unary)); + LLVMValueRef rhs = build_expression(module, builder, variable_set, expression->assignment); + return LLVMBuildStore(builder, rhs, get_variable(variable_set, expression->unary)->value); } LLVMValueRef build_expression( - LLVMModuleRef module, LLVMBuilderRef builder, AstRef ast) { + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstRef ast) { switch (ast->tag) { case AST_EXPRESSION: - return build_expression_expression(module, builder, ast_get_expression(ast)); + return build_expression_expression(module, builder, variable_set, ast_get_expression(ast)); case AST_COMMA_EXPRESSION: - return build_expression_comma_expression(module, builder, ast_get_comma_expression(ast)); + return build_expression_comma_expression(module, builder, variable_set, ast_get_comma_expression(ast)); case AST_ASSIGNMENT_EXPRESSION: - return build_expression_assignment_expression(module, builder, ast_get_assignment_expression(ast)); + return build_expression_assignment_expression(module, builder, variable_set, ast_get_assignment_expression(ast)); case AST_BASIC_ASSIGNMENT_EXPRESSION: - return build_expression_basic_assignment_expression(module, builder, ast_get_basic_assignment_expression(ast)); + return build_expression_basic_assignment_expression(module, builder, variable_set, ast_get_basic_assignment_expression(ast)); case AST_CONDITIONAL_EXPRESSION:; default:; } diff --git a/src/code_generator/statements.c b/src/code_generator/statements.c index 95b9fbcb..a195c8b2 100644 --- a/src/code_generator/statements.c +++ b/src/code_generator/statements.c @@ -1,61 +1,62 @@ #include "code_generator.h" +#include "variable_set.h" #include "ast/statements_impl.h" #include "ast/is_method.h" #include "ast/get_method.h" #include "ast/ast_impl.h" void build_block_compound_statement( - LLVMModuleRef module, LLVMBuilderRef builder, + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstCompoundStatementRef compound_statement) { - build_block(module, builder, compound_statement->declaration_list); - build_block(module, builder, compound_statement->statement_list); + build_block(module, builder, variable_set, compound_statement->declaration_list); + build_block(module, builder, variable_set, compound_statement->statement_list); } void build_block_declaration_list( - LLVMModuleRef module, LLVMBuilderRef builder, + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstDeclarationListRef declaration_list) { AstVectorRef declaration_vector = declaration_list->declaration_vector; int i; for (i = 0; i < AST_VECTOR_FUNC(size)(declaration_vector); i++) { - build_block(module, builder, AST_VECTOR_FUNC(at)(declaration_vector, i)); + build_block(module, builder, variable_set, AST_VECTOR_FUNC(at)(declaration_vector, i)); } } void build_block_statement_list( - LLVMModuleRef module, LLVMBuilderRef builder, + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstStatementListRef statement_list) { AstVectorRef statement_vector = statement_list->statement_vector; int i; for (i = 0; i < AST_VECTOR_FUNC(size)(statement_vector); i++) { - build_block(module, builder, AST_VECTOR_FUNC(at)(statement_vector, i)); + build_block(module, builder, variable_set, AST_VECTOR_FUNC(at)(statement_vector, i)); } } void build_block_statement( - LLVMModuleRef module, LLVMBuilderRef builder, + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstStatementRef statement) { - build_block(module, builder, statement->statement); + build_block(module, builder, variable_set, statement->statement); } void build_block_expression_statement( - LLVMModuleRef module, LLVMBuilderRef builder, + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstExpressionStatementRef expression_statement) { if (expression_statement->expression != NULL) - build_expression(module, builder, expression_statement->expression); + build_expression(module, builder, variable_set, expression_statement->expression); } -void build_block(LLVMModuleRef module, LLVMBuilderRef builder, AstRef ast) { +void build_block(LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstRef ast) { switch (ast->tag) { case AST_COMPOUND_STATEMENT: - build_block_compound_statement(module, builder, ast_get_compound_statement(ast)); break; + build_block_compound_statement(module, builder, variable_set, ast_get_compound_statement(ast)); break; case AST_DECLARATION_LIST: - build_block_declaration_list(module, builder, ast_get_declaration_list(ast)); break; + build_block_declaration_list(module, builder, variable_set, ast_get_declaration_list(ast)); break; case AST_STATEMENT_LIST: - build_block_statement_list(module, builder, ast_get_statement_list(ast)); break; + build_block_statement_list(module, builder, variable_set, ast_get_statement_list(ast)); break; case AST_STATEMENT: - build_block_statement(module, builder, ast_get_statement(ast)); break; + build_block_statement(module, builder, variable_set, ast_get_statement(ast)); break; case AST_EXPRESSION_STATEMENT: - build_block_expression_statement(module, builder, ast_get_expression_statement(ast)); break; + build_block_expression_statement(module, builder, variable_set, ast_get_expression_statement(ast)); break; default:; } } From 3c0641b529e1bb02168cb27c5a03ee4e1161cad3 Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 01:54:51 +0900 Subject: [PATCH 15/51] add variable_set.* --- src/code_generator/variable_set.c | 43 +++++++++++++++++++++++++++++++ src/code_generator/variable_set.h | 25 ++++++++++++++++++ 2 files changed, 68 insertions(+) create mode 100644 src/code_generator/variable_set.c create mode 100644 src/code_generator/variable_set.h diff --git a/src/code_generator/variable_set.c b/src/code_generator/variable_set.c new file mode 100644 index 00000000..f61432d4 --- /dev/null +++ b/src/code_generator/variable_set.c @@ -0,0 +1,43 @@ +#include "variable_set.h" +#include "vector_impl.h" +#include "ast/get_method.h" +#include "ast/lexical_elements_impl.h" +#include "ast/expressions_impl.h" +#include "ast/ast_impl.h" + +DEFINE_VECTOR(VariableRef) + +VariableRef get_variable_identifier( + VariableSetRef variable_set, AstIdentifierRef name) { + AstTokenRef name_str = ast_get_token(name->token); + int i; + for (i = 0; i < VariableSetFunc(size)(variable_set); i++) { + VariableRef variable = VariableSetFunc(at)(variable_set, i); + if (string_compare(variable->name, name_str) == 0) + return variable; + } + return NULL; +} + +VariableRef get_variable_unary_expression( + VariableSetRef variable_set, AstUnaryExpressionRef unary) { + return get_variable(variable_set, unary->unary); +} + +VariableRef get_variable_postfix_expression( + VariableSetRef variable_set, AstPostfixExpressionRef postfix) { + return get_variable(variable_set, postfix->postfix); +} + +VariableRef get_variable(VariableSetRef variable_set, AstRef ast) { + switch (ast->tag) { + case AST_UNARY_EXPRESSION: + return get_variable_unary_expression(variable_set, ast_get_unary_expression(ast)); + case AST_POSTFIX_EXPRESSION: + return get_variable_postfix_expression(variable_set, ast_get_postfix_expression(ast)); + case AST_IDENTIFIER: + return get_variable_identifier(variable_set, ast_get_identifier(ast)); + default:; + } + return NULL; +} diff --git a/src/code_generator/variable_set.h b/src/code_generator/variable_set.h new file mode 100644 index 00000000..fcb506e8 --- /dev/null +++ b/src/code_generator/variable_set.h @@ -0,0 +1,25 @@ +#ifndef KMC_C89_COMPILER_VARIABLE_SET_H +#define KMC_C89_COMPILER_VARIABLE_SET_H + +#include +#include "ast.h" +#include "vector.h" +#include "stdstring.h" + +struct Variable { + AstTokenRef name; + LLVMTypeRef type; + LLVMValueRef value; +}; + +typedef struct Variable *VariableRef; + +#define VariableSetFunc(func) VECTORFUNC(VariableRef, func) + +DECLARE_VECTOR(VariableRef) + +typedef VECTORREF(VariableRef) VariableSetRef; + +VariableRef get_variable(VariableSetRef variable_set, AstRef ast); + +#endif /* KMC_C89_COMPILER_VARIABLE_SET_H */ From 3b419e3de35866552fb5978907572067008735a4 Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 02:06:10 +0900 Subject: [PATCH 16/51] rename function --- src/code_generator/code_generator.h | 2 +- src/code_generator/translation_unit.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/code_generator/code_generator.h b/src/code_generator/code_generator.h index 209c77f6..26a6e104 100644 --- a/src/code_generator/code_generator.h +++ b/src/code_generator/code_generator.h @@ -19,7 +19,7 @@ void translation_unit(LLVMModuleRef module, AstTranslationUnitRef translation_un LLVMTypeRef get_type(AstRef ast); ParameterTypeRef get_parameter_types(AstRef ast); LLVMTypeRef get_function_type(AstFunctionDefinitionRef function_definition); -StringRef get_function_name(AstFunctionDefinitionRef function_definition); +AstTokenRef get_name(AstRef ast); void build_block(LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstRef ast); LLVMValueRef build_expression(LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstRef ast); diff --git a/src/code_generator/translation_unit.c b/src/code_generator/translation_unit.c index 2d723f6d..9e1cbcf8 100644 --- a/src/code_generator/translation_unit.c +++ b/src/code_generator/translation_unit.c @@ -17,7 +17,7 @@ LLVMTypeRef get_function_type(AstFunctionDefinitionRef function_definition) { void define_function(LLVMModuleRef module, LLVMBuilderRef builder, AstFunctionDefinitionRef function_definition) { - StringRef name = get_function_name(function_definition); + StringRef name = get_name(function_definition->declarator); LLVMTypeRef type = get_function_type(function_definition); LLVMValueRef func = LLVMAddFunction(module, string_data(name), type); LLVMBasicBlockRef entry = LLVMAppendBasicBlock(func, "entry"); From a0117f8f684c3fc882c5b6e0cde9d99a94de9e5d Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 02:06:51 +0900 Subject: [PATCH 17/51] fix for modified signature of build_block --- src/code_generator/translation_unit.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/code_generator/translation_unit.c b/src/code_generator/translation_unit.c index 9e1cbcf8..83ce6c4c 100644 --- a/src/code_generator/translation_unit.c +++ b/src/code_generator/translation_unit.c @@ -21,8 +21,9 @@ void define_function(LLVMModuleRef module, LLVMBuilderRef builder, LLVMTypeRef type = get_function_type(function_definition); LLVMValueRef func = LLVMAddFunction(module, string_data(name), type); LLVMBasicBlockRef entry = LLVMAppendBasicBlock(func, "entry"); + VariableSetRef variable_set = VariableSetFunc(ctor)(NULL); LLVMPositionBuilderAtEnd(builder, entry); - build_block(module, builder, function_definition->compound_statement); + build_block(module, builder, variable_set, function_definition->compound_statement); } void translation_unit(LLVMModuleRef module, AstTranslationUnitRef translation_unit) { From fbbe7346fe9e088f3036fe48495f460b7f9e9d37 Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 02:08:01 +0900 Subject: [PATCH 18/51] add name.c --- src/code_generator/name.c | 38 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 src/code_generator/name.c diff --git a/src/code_generator/name.c b/src/code_generator/name.c new file mode 100644 index 00000000..669d8c5c --- /dev/null +++ b/src/code_generator/name.c @@ -0,0 +1,38 @@ +#include "code_generator.h" +#include "stdstring.h" +#include "ast/lexical_elements_impl.h" +#include "ast/expressions_impl.h" +#include "ast/is_method.h" +#include "ast/get_method.h" +#include "ast/ast_impl.h" + +AstTokenRef get_name_identifier(AstIdentifierRef identifier) { + return ast_get_token(identifier->token); +} + +AstTokenRef get_name_primary_expression(AstPrimaryExpressionRef primary) { + return get_name(primary->primary_expression); +} + +AstTokenRef get_name_postfix_expression(AstPostfixExpressionRef postfix) { + return get_name(postfix->postfix); +} + +AstTokenRef get_name_unary_expression(AstUnaryExpressionRef unary) { + return get_name(unary->unary); +} + +AstTokenRef get_name(AstRef ast) { + switch (ast->tag) { + case AST_IDENTIFIER: + return get_name_identifier(ast_get_identifier(ast)); + case AST_PRIMARY_EXPRESSION: + return get_name_primary_expression(ast_get_primary_expression(ast)); + case AST_POSTFIX_EXPRESSION: + return get_name_postfix_expression(ast_get_postfix_expression(ast)); + case AST_UNARY_EXPRESSION: + return get_name_unary_expression(ast_get_unary_expression(ast)); + default: + return NULL; + } +} From f54e92fe486713307e02335507787c7925880504 Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 03:51:00 +0900 Subject: [PATCH 19/51] implement trivial build_expression_* --- src/code_generator/expression.c | 121 +++++++++++++++++++++++++++++++- 1 file changed, 120 insertions(+), 1 deletion(-) diff --git a/src/code_generator/expression.c b/src/code_generator/expression.c index 63e8223f..af801c3a 100644 --- a/src/code_generator/expression.c +++ b/src/code_generator/expression.c @@ -31,6 +31,90 @@ LLVMValueRef build_expression_basic_assignment_expression( return LLVMBuildStore(builder, rhs, get_variable(variable_set, expression->unary)->value); } +LLVMValueRef build_expression_conditional_expression( + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + AstConditionalExpressionRef expression) { + return build_expression(module, builder, variable_set, expression->expression); +} + +LLVMValueRef build_expression_logical_or_expression( + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + AstLogicalOrExpressionRef expression) { + return build_expression(module, builder, variable_set, expression->expression); +} + +LLVMValueRef build_expression_logical_and_expression( + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + AstLogicalAndExpressionRef expression) { + return build_expression(module, builder, variable_set, expression->expression); +} + +LLVMValueRef build_expression_bitwise_or_expression( + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + AstBitwiseOrExpressionRef expression) { + return build_expression(module, builder, variable_set, expression->expression); +} + +LLVMValueRef build_expression_bitwise_xor_expression( + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + AstBitwiseXorExpressionRef expression) { + return build_expression(module, builder, variable_set, expression->expression); +} + +LLVMValueRef build_expression_bitwise_and_expression( + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + AstBitwiseAndExpressionRef expression) { + return build_expression(module, builder, variable_set, expression->expression); +} + +LLVMValueRef build_expression_equality_expression( + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + AstEqualityExpressionRef expression) { + return build_expression(module, builder, variable_set, expression->expression); +} + +LLVMValueRef build_expression_relarional_expression( + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + AstRelationalExpressionRef expression) { + return build_expression(module, builder, variable_set, expression->expression); +} + +LLVMValueRef build_expression_shift_expression( + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + AstShiftExpressionRef expression) { + return build_expression(module, builder, variable_set, expression->expression); +} + +LLVMValueRef build_expression_additive_expression( + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + AstAdditiveExpressionRef expression) { + return build_expression(module, builder, variable_set, expression->expression); +} + +LLVMValueRef build_expression_multiplicative_expression( + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + AstMultiplicativeExpressionRef expression) { + return build_expression(module, builder, variable_set, expression->expression); +} + +LLVMValueRef build_expression_cast_expression( + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + AstCastExpressionRef cast) { + return build_expression(module, builder, variable_set, cast->cast); +} + +LLVMValueRef build_expression_unary_expression( + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + AstUnaryExpressionRef unary) { + return build_expression(module, builder, variable_set, unary->unary); +} + +LLVMValueRef build_expression_postfix_expression( + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + AstPostfixExpressionRef postfix) { + return build_expression(module, builder, variable_set, postfix->postfix); +} + LLVMValueRef build_expression( LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstRef ast) { switch (ast->tag) { @@ -42,7 +126,42 @@ LLVMValueRef build_expression( return build_expression_assignment_expression(module, builder, variable_set, ast_get_assignment_expression(ast)); case AST_BASIC_ASSIGNMENT_EXPRESSION: return build_expression_basic_assignment_expression(module, builder, variable_set, ast_get_basic_assignment_expression(ast)); - case AST_CONDITIONAL_EXPRESSION:; + case AST_CONDITIONAL_EXPRESSION: + return build_expression_conditional_expression(module, builder, variable_set, ast_get_conditional_expression(ast)); + case AST_LOGICAL_OR_EXPRESSION: + return build_expression_logical_or_expression(module, builder, variable_set, ast_get_logical_or_expression(ast)); + case AST_LOGICAL_AND_EXPRESSION: + return build_expression_logical_and_expression(module, builder, variable_set, ast_get_logical_and_expression(ast)); + case AST_BITWISE_OR_EXPRESSION: + return build_expression_bitwise_or_expression(module, builder, variable_set, ast_get_bitwise_or_expression(ast)); + case AST_BITWISE_XOR_EXPRESSION: + return build_expression_bitwise_xor_expression(module, builder, variable_set, ast_get_bitwise_xor_expression(ast)); + case AST_BITWISE_AND_EXPRESSION: + return build_expression_bitwise_and_expression(module, builder, variable_set, ast_get_bitwise_and_expression(ast)); + case AST_EQUALITY_EXPRESSION: + return build_expression_equality_expression(module, builder, variable_set, ast_get_equality_expression(ast)); + case AST_RELATIONAL_EXPRESSION: + return build_expression_relarional_expression(module, builder, variable_set, ast_get_relational_expression(ast)); + case AST_SHIFT_EXPRESSION: + return build_expression_shift_expression(module, builder, variable_set, ast_get_shift_expression(ast)); + case AST_ADDITIVE_EXPRESSION: + return build_expression_additive_expression(module, builder, variable_set, ast_get_additive_expression(ast)); + case AST_MULTIPLICATIVE_EXPRESSION: + return build_expression_multiplicative_expression(module, builder, variable_set, ast_get_multiplicative_expression(ast)); + case AST_CAST_EXPRESSION: + return build_expression_cast_expression(module, builder, variable_set, ast_get_cast_expression(ast)); + case AST_UNARY_EXPRESSION: + return build_expression_unary_expression(module, builder, variable_set, ast_get_unary_expression(ast)); + case AST_POSTFIX_EXPRESSION: + return build_expression_postfix_expression(module, builder, variable_set, ast_get_postfix_expression(ast)); + case AST_FUNCTION_CALL_EXPRESSION: + return build_expression_function_call_expression(module, builder, variable_set, ast_get_function_call_expression(ast)); + case AST_PRIMARY_EXPRESSION: + return build_expression_primary_expression(module, builder, variable_set, ast_get_primary_expression(ast)); + case AST_CONSTANT: + return build_expression_constant(module, builder, variable_set, ast_get_constant(ast)); + case AST_IDENTIFIER: + return build_expression_identifier(module, builder, variable_set, ast_get_identifier(ast)); default:; } return NULL; From 043a5cf0d75b3466213ad51351e723849c442c9e Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 05:09:46 +0900 Subject: [PATCH 20/51] rename ParameterTypeRef to TypeVectorRef --- src/code_generator/code_generator.h | 4 ++-- src/code_generator/parameter_type.c | 14 +++++++------- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/src/code_generator/code_generator.h b/src/code_generator/code_generator.h index 26a6e104..b1158813 100644 --- a/src/code_generator/code_generator.h +++ b/src/code_generator/code_generator.h @@ -12,12 +12,12 @@ #define ParameterTypeFunc(func) VECTORFUNC(LLVMTypeRef, func) DECLARE_VECTOR(LLVMTypeRef) +typedef VECTORREF(LLVMTypeRef) TypeVectorRef; -typedef VECTORREF(LLVMTypeRef) ParameterTypeRef; void translation_unit(LLVMModuleRef module, AstTranslationUnitRef translation_unit); LLVMTypeRef get_type(AstRef ast); -ParameterTypeRef get_parameter_types(AstRef ast); +TypeVectorRef get_parameter_types(AstRef ast); LLVMTypeRef get_function_type(AstFunctionDefinitionRef function_definition); AstTokenRef get_name(AstRef ast); void build_block(LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstRef ast); diff --git a/src/code_generator/parameter_type.c b/src/code_generator/parameter_type.c index 8b81cd7b..39ed63b2 100644 --- a/src/code_generator/parameter_type.c +++ b/src/code_generator/parameter_type.c @@ -6,25 +6,25 @@ DEFINE_VECTOR(LLVMTypeRef) -ParameterTypeRef get_parameter_types_declarator(AstDeclaratorRef declarator) { +TypeVectorRef get_parameter_types_declarator(AstDeclaratorRef declarator) { return get_parameter_types(declarator->direct_declarator); } -ParameterTypeRef get_parameter_types_direct_declarator(AstDirectDeclaratorRef direct_declarator) { +TypeVectorRef get_parameter_types_direct_declarator(AstDirectDeclaratorRef direct_declarator) { return get_parameter_types(direct_declarator->direct_declarator); } -ParameterTypeRef get_parameter_types_function_declarator(AstFunctionDeclaratorRef function_declarator) { +TypeVectorRef get_parameter_types_function_declarator(AstFunctionDeclaratorRef function_declarator) { return get_parameter_types(function_declarator->parameter_type_list); } -ParameterTypeRef get_parameter_types_parameter_type_list(AstParameterTypeListRef parameter_type_list) { +TypeVectorRef get_parameter_types_parameter_type_list(AstParameterTypeListRef parameter_type_list) { return get_parameter_types(parameter_type_list->parameter_type_list); } -ParameterTypeRef get_parameter_types_parameter_list(AstParameterListRef parameter_list) { +TypeVectorRef get_parameter_types_parameter_list(AstParameterListRef parameter_list) { AstVectorRef parameter_vector = parameter_list->parameter_declaration_vector; - ParameterTypeRef parameter_types = ParameterTypeFunc(ctor)(NULL); + TypeVectorRef parameter_types = ParameterTypeFunc(ctor)(NULL); int i; for (i = 0; i < (int)AST_VECTOR_FUNC(size)(parameter_vector); i++) { AstParameterDeclarationRef parameter_declaration = @@ -42,7 +42,7 @@ ParameterTypeRef get_parameter_types_parameter_list(AstParameterListRef paramete return parameter_types; } -ParameterTypeRef get_parameter_types(AstRef ast) { +TypeVectorRef get_parameter_types(AstRef ast) { switch (ast->tag) { case AST_DECLARATOR: return get_parameter_types_declarator(ast_get_declarator(ast)); From 60dcb98573b41d1d63526df8b6a9c16519bfbe25 Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 05:10:14 +0900 Subject: [PATCH 21/51] declare ValueVectorRef --- src/code_generator/code_generator.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/code_generator/code_generator.h b/src/code_generator/code_generator.h index b1158813..5c2ec6a4 100644 --- a/src/code_generator/code_generator.h +++ b/src/code_generator/code_generator.h @@ -14,6 +14,8 @@ DECLARE_VECTOR(LLVMTypeRef) typedef VECTORREF(LLVMTypeRef) TypeVectorRef; +DECLARE_VECTOR(LLVMValueRef) +typedef VECTORREF(LLVMValueRef) ValueVectorRef; void translation_unit(LLVMModuleRef module, AstTranslationUnitRef translation_unit); LLVMTypeRef get_type(AstRef ast); From 2e67ed8af346d4cbab6ddabf40f0a35a6acd35ff Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 05:20:53 +0900 Subject: [PATCH 22/51] rename ParameterTypeFunc to TypeVectorFunc --- src/code_generator/code_generator.h | 2 +- src/code_generator/parameter_type.c | 4 ++-- src/code_generator/translation_unit.c | 4 ++-- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/code_generator/code_generator.h b/src/code_generator/code_generator.h index 5c2ec6a4..4095f7ea 100644 --- a/src/code_generator/code_generator.h +++ b/src/code_generator/code_generator.h @@ -9,7 +9,7 @@ #include "stdstring.h" #include "variable_set.h" -#define ParameterTypeFunc(func) VECTORFUNC(LLVMTypeRef, func) +#define TypeVectorFunc(func) VECTORFUNC(LLVMTypeRef, func) DECLARE_VECTOR(LLVMTypeRef) typedef VECTORREF(LLVMTypeRef) TypeVectorRef; diff --git a/src/code_generator/parameter_type.c b/src/code_generator/parameter_type.c index 39ed63b2..f9463aa4 100644 --- a/src/code_generator/parameter_type.c +++ b/src/code_generator/parameter_type.c @@ -24,7 +24,7 @@ TypeVectorRef get_parameter_types_parameter_type_list(AstParameterTypeListRef pa TypeVectorRef get_parameter_types_parameter_list(AstParameterListRef parameter_list) { AstVectorRef parameter_vector = parameter_list->parameter_declaration_vector; - TypeVectorRef parameter_types = ParameterTypeFunc(ctor)(NULL); + TypeVectorRef parameter_types = TypeVectorFunc(ctor)(NULL); int i; for (i = 0; i < (int)AST_VECTOR_FUNC(size)(parameter_vector); i++) { AstParameterDeclarationRef parameter_declaration = @@ -33,7 +33,7 @@ TypeVectorRef get_parameter_types_parameter_list(AstParameterListRef parameter_l parameter_declaration->parameter_declaration)) { AstParameterConcreteDeclarationRef parameter_concrete_declaration = ast_get_parameter_concrete_declaration(parameter_declaration->parameter_declaration); - ParameterTypeFunc(push_back)(parameter_types, + TypeVectorFunc(push_back)(parameter_types, get_type(parameter_concrete_declaration->declaration_specifier_list)); } else { return NULL; diff --git a/src/code_generator/translation_unit.c b/src/code_generator/translation_unit.c index 83ce6c4c..30bb5d69 100644 --- a/src/code_generator/translation_unit.c +++ b/src/code_generator/translation_unit.c @@ -10,8 +10,8 @@ LLVMTypeRef get_function_type(AstFunctionDefinitionRef function_definition) { ParameterTypeRef parameter_types = get_parameter_types(function_definition->declarator); return LLVMFunctionType( return_type, - ParameterTypeFunc(data)(parameter_types), - ParameterTypeFunc(size)(parameter_types), + TypeVectorFunc(data)(parameter_types), + TypeVectorFunc(size)(parameter_types), false); } From e631a0f51abea7ba548d5fd238389ebb06926397 Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 05:25:28 +0900 Subject: [PATCH 23/51] define ValueVectorFunc --- src/code_generator/code_generator.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/code_generator/code_generator.h b/src/code_generator/code_generator.h index 4095f7ea..9332d90c 100644 --- a/src/code_generator/code_generator.h +++ b/src/code_generator/code_generator.h @@ -14,6 +14,8 @@ DECLARE_VECTOR(LLVMTypeRef) typedef VECTORREF(LLVMTypeRef) TypeVectorRef; +#define ValueVectorFunc(func) VECTORFUNC(LLVMValueRef, func) + DECLARE_VECTOR(LLVMValueRef) typedef VECTORREF(LLVMValueRef) ValueVectorRef; From e5f8d4c626c52bc9d8ccf8b1e513acfea60b8ba3 Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 05:49:35 +0900 Subject: [PATCH 24/51] rename ParameterTypeRef to TypeVectorRef --- src/code_generator/translation_unit.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/code_generator/translation_unit.c b/src/code_generator/translation_unit.c index 30bb5d69..d4bc6289 100644 --- a/src/code_generator/translation_unit.c +++ b/src/code_generator/translation_unit.c @@ -7,7 +7,7 @@ LLVMTypeRef get_function_type(AstFunctionDefinitionRef function_definition) { LLVMTypeRef return_type = get_type(function_definition->declaration_specifier_list); - ParameterTypeRef parameter_types = get_parameter_types(function_definition->declarator); + TypeVectorRef parameter_types = get_parameter_types(function_definition->declarator); return LLVMFunctionType( return_type, TypeVectorFunc(data)(parameter_types), From 1a13a49958b1f0a45d5b7babf850c824761e85c2 Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 05:50:47 +0900 Subject: [PATCH 25/51] implement build_expression_function_call --- src/code_generator/expression.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/src/code_generator/expression.c b/src/code_generator/expression.c index af801c3a..47c197f3 100644 --- a/src/code_generator/expression.c +++ b/src/code_generator/expression.c @@ -109,6 +109,20 @@ LLVMValueRef build_expression_unary_expression( return build_expression(module, builder, variable_set, unary->unary); } +LLVMValueRef build_expression_function_call_expression( + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + AstFunctionCallExpressionRef function_call) { + AstTokenRef function_name = get_name(function_call->function); + LLVMValueRef function = LLVMGetNamedFunction(module, string_data(function_name)); + LLVMTypeRef function_type = LLVMGetElementType(LLVMTypeOf(function)); + int parameter_count = LLVMCountParamTypes(function_type); + ValueVectorRef argument_vec = get_arguments(variable_set, function_call->argument_list); + int argument_count = ValueVectorFunc(size)(argument_vec); + if (parameter_count != argument_count) return NULL; + LLVMBuildCall(builder, function, ValueVectorFunc(data)(argument_vec), + ValueVectorFunc(size)(argument_vec), string_data(function_name)); +} + LLVMValueRef build_expression_postfix_expression( LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstPostfixExpressionRef postfix) { From f135aaed90b5ac05bd6c50c3360a43058b21450a Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 06:35:45 +0900 Subject: [PATCH 26/51] move point to define TypeVectorRef functions --- src/code_generator/parameter_type.c | 2 -- src/code_generator/type.c | 2 ++ 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/code_generator/parameter_type.c b/src/code_generator/parameter_type.c index f9463aa4..e998190d 100644 --- a/src/code_generator/parameter_type.c +++ b/src/code_generator/parameter_type.c @@ -4,8 +4,6 @@ #include "ast/get_method.h" #include "ast/ast_impl.h" -DEFINE_VECTOR(LLVMTypeRef) - TypeVectorRef get_parameter_types_declarator(AstDeclaratorRef declarator) { return get_parameter_types(declarator->direct_declarator); } diff --git a/src/code_generator/type.c b/src/code_generator/type.c index d35c193f..3c3ea7fe 100644 --- a/src/code_generator/type.c +++ b/src/code_generator/type.c @@ -4,6 +4,8 @@ #include "ast/get_method.h" #include "ast/ast_impl.h" +DEFINE_VECTOR(LLVMTypeRef) + LLVMTypeRef get_type(AstRef ast) { switch (ast->tag) { case AST_DECLARATION_SPECIFIER_LIST: From 4f7de1ffdba64a3085e1eeb5d1fdfec064391aa3 Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 06:36:58 +0900 Subject: [PATCH 27/51] add value.c --- src/code_generator/value.c | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 src/code_generator/value.c diff --git a/src/code_generator/value.c b/src/code_generator/value.c new file mode 100644 index 00000000..8d361efd --- /dev/null +++ b/src/code_generator/value.c @@ -0,0 +1,22 @@ +#include "code_generator.h" +#include "variable_set.h" +#include "stdstring.h" +#include "ast/expressions_impl.h" +#include "ast/is_method.h" +#include "ast/get_method.h" +#include "ast/ast_impl.h" + +DEFINE_VECTOR(LLVMValueRef) + +ValueVectorRef get_arguments( + VariableSetRef variable_set, + AstArgumentExpressionListRef argument_expression_list) { + AstVectorRef argument_list = argument_expression_list->argument_list; + int i; + ValueVectorRef value_vec = ValueVectorFunc(ctor)(NULL); + for (i = 0; i < (int)AST_VECTOR_FUNC(size)(argument_list); i++) { + ValueVectorFunc(push_back)(value_vec, + get_variable(variable_set, AST_VECTOR_FUNC(at)(argument_list, i))->value); + } + return value_vec; +} From 8cbeafb3cfb4432dfb06c5a8d9870f4b2a8bd1cf Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 06:37:17 +0900 Subject: [PATCH 28/51] add get_arguments --- src/code_generator/code_generator.h | 1 + 1 file changed, 1 insertion(+) diff --git a/src/code_generator/code_generator.h b/src/code_generator/code_generator.h index 9332d90c..d0283f22 100644 --- a/src/code_generator/code_generator.h +++ b/src/code_generator/code_generator.h @@ -24,6 +24,7 @@ LLVMTypeRef get_type(AstRef ast); TypeVectorRef get_parameter_types(AstRef ast); LLVMTypeRef get_function_type(AstFunctionDefinitionRef function_definition); AstTokenRef get_name(AstRef ast); +ValueVectorRef get_arguments(VariableSetRef variable_set, AstArgumentExpressionListRef ast); void build_block(LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstRef ast); LLVMValueRef build_expression(LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstRef ast); From b7bec6578e9e5a58df0366bede61942ac3e8c05f Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 06:49:08 +0900 Subject: [PATCH 29/51] fix for modified signature of get_arguments --- src/code_generator/expression.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/code_generator/expression.c b/src/code_generator/expression.c index 47c197f3..f096ca64 100644 --- a/src/code_generator/expression.c +++ b/src/code_generator/expression.c @@ -116,7 +116,10 @@ LLVMValueRef build_expression_function_call_expression( LLVMValueRef function = LLVMGetNamedFunction(module, string_data(function_name)); LLVMTypeRef function_type = LLVMGetElementType(LLVMTypeOf(function)); int parameter_count = LLVMCountParamTypes(function_type); - ValueVectorRef argument_vec = get_arguments(variable_set, function_call->argument_list); + ValueVectorRef argument_vec = + get_arguments( + variable_set, + ast_get_argument_expression_list(function_call->argument_list)); int argument_count = ValueVectorFunc(size)(argument_vec); if (parameter_count != argument_count) return NULL; LLVMBuildCall(builder, function, ValueVectorFunc(data)(argument_vec), From 3edac5043ff243d627d2740df138343d54f4e325 Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 06:49:53 +0900 Subject: [PATCH 30/51] implement trivial build_expression_* --- src/code_generator/expression.c | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/code_generator/expression.c b/src/code_generator/expression.c index f096ca64..e0a40b31 100644 --- a/src/code_generator/expression.c +++ b/src/code_generator/expression.c @@ -132,6 +132,18 @@ LLVMValueRef build_expression_postfix_expression( return build_expression(module, builder, variable_set, postfix->postfix); } +LLVMValueRef build_expression_primary_expression( + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + AstPrimaryExpressionRef primary) { + return build_expression(module, builder, variable_set, primary->primary_expression); +} + +LLVMValueRef build_expression_constant( + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + AstConstantRef constant) { + return build_expression(module, builder, variable_set, constant->constant); +} + LLVMValueRef build_expression( LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstRef ast) { switch (ast->tag) { From dffc26d33cfe5c7a32ef104b071c990f8b74ed30 Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 06:50:17 +0900 Subject: [PATCH 31/51] implement build_expression_integer_constant --- src/code_generator/expression.c | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/code_generator/expression.c b/src/code_generator/expression.c index e0a40b31..2f8f4b6c 100644 --- a/src/code_generator/expression.c +++ b/src/code_generator/expression.c @@ -144,6 +144,13 @@ LLVMValueRef build_expression_constant( return build_expression(module, builder, variable_set, constant->constant); } +LLVMValueRef build_expression_integer_constant( + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + AstIntegerConstantRef constant) { + return LLVMConstIntOfString( + LLVMInt32Type(), string_data(ast_get_token(constant->token)), 10); +} + LLVMValueRef build_expression( LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstRef ast) { switch (ast->tag) { @@ -189,6 +196,8 @@ LLVMValueRef build_expression( return build_expression_primary_expression(module, builder, variable_set, ast_get_primary_expression(ast)); case AST_CONSTANT: return build_expression_constant(module, builder, variable_set, ast_get_constant(ast)); + case AST_INTEGER_CONSTANT: + return build_expression_integer_constant(module, builder, variable_set, ast_get_integer_constant(ast)); case AST_IDENTIFIER: return build_expression_identifier(module, builder, variable_set, ast_get_identifier(ast)); default:; From 63f407b9e7b8df7c66dad30b2e32a9aca9c3a25d Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 07:18:03 +0900 Subject: [PATCH 32/51] add header --- src/code_generator/expression.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/code_generator/expression.c b/src/code_generator/expression.c index 2f8f4b6c..ce4ccd24 100644 --- a/src/code_generator/expression.c +++ b/src/code_generator/expression.c @@ -1,5 +1,6 @@ #include "code_generator.h" #include "variable_set.h" +#include "ast/lexical_elements_impl.h" #include "ast/expressions_impl.h" #include "ast/is_method.h" #include "ast/get_method.h" From c847e104029a856b9c7107a90c3a6aeef64568b1 Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 07:19:00 +0900 Subject: [PATCH 33/51] fix to return in build_expression_function_call_expression --- src/code_generator/expression.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/code_generator/expression.c b/src/code_generator/expression.c index ce4ccd24..c86faf8b 100644 --- a/src/code_generator/expression.c +++ b/src/code_generator/expression.c @@ -123,7 +123,7 @@ LLVMValueRef build_expression_function_call_expression( ast_get_argument_expression_list(function_call->argument_list)); int argument_count = ValueVectorFunc(size)(argument_vec); if (parameter_count != argument_count) return NULL; - LLVMBuildCall(builder, function, ValueVectorFunc(data)(argument_vec), + return LLVMBuildCall(builder, function, ValueVectorFunc(data)(argument_vec), ValueVectorFunc(size)(argument_vec), string_data(function_name)); } From ee9be4f10bb16ed8f0c5727881ff374426bd8403 Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 07:20:56 +0900 Subject: [PATCH 34/51] add prototype declaration fot get_variable_identifier --- src/code_generator/variable_set.h | 1 + 1 file changed, 1 insertion(+) diff --git a/src/code_generator/variable_set.h b/src/code_generator/variable_set.h index fcb506e8..62d70a23 100644 --- a/src/code_generator/variable_set.h +++ b/src/code_generator/variable_set.h @@ -21,5 +21,6 @@ DECLARE_VECTOR(VariableRef) typedef VECTORREF(VariableRef) VariableSetRef; VariableRef get_variable(VariableSetRef variable_set, AstRef ast); +VariableRef get_variable_identifier(VariableSetRef variable_set, AstIdentifierRef ast); #endif /* KMC_C89_COMPILER_VARIABLE_SET_H */ From 6ad540745210235a3f72ee43bc1dfaa6e80ba5af Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 07:21:14 +0900 Subject: [PATCH 35/51] implement build_expression_identifier --- src/code_generator/expression.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/code_generator/expression.c b/src/code_generator/expression.c index c86faf8b..6417d22d 100644 --- a/src/code_generator/expression.c +++ b/src/code_generator/expression.c @@ -152,6 +152,12 @@ LLVMValueRef build_expression_integer_constant( LLVMInt32Type(), string_data(ast_get_token(constant->token)), 10); } +LLVMValueRef build_expression_identifier( + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + AstIdentifierRef identifier) { + return get_variable_identifier(variable_set, identifier)->value; +} + LLVMValueRef build_expression( LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstRef ast) { switch (ast->tag) { From 7f918ef35a9e8b45ba9c65907215c5e85700aeb8 Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 07:46:06 +0900 Subject: [PATCH 36/51] implement get_type_declaration_specifier_list --- src/code_generator/type.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/code_generator/type.c b/src/code_generator/type.c index 3c3ea7fe..cabcdcf9 100644 --- a/src/code_generator/type.c +++ b/src/code_generator/type.c @@ -6,10 +6,15 @@ DEFINE_VECTOR(LLVMTypeRef) +LLVMTypeRef get_type_declaration_specifier_list( + AstDeclarationSpecifierListRef declaration_specifier_list) { + return LLVMInt32Type(); +} + LLVMTypeRef get_type(AstRef ast) { switch (ast->tag) { case AST_DECLARATION_SPECIFIER_LIST: - return LLVMInt32Type(); + return get_type_declaration_specifier_list(ast_get_declaration_specifier_list(ast)); default: return NULL; } From e6ea3c8f2c4b16592f85cf52e1b1bb54b0a2037e Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 08:32:48 +0900 Subject: [PATCH 37/51] use iterator --- src/code_generator/value.c | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/code_generator/value.c b/src/code_generator/value.c index 8d361efd..ee18e9d3 100644 --- a/src/code_generator/value.c +++ b/src/code_generator/value.c @@ -12,11 +12,13 @@ ValueVectorRef get_arguments( VariableSetRef variable_set, AstArgumentExpressionListRef argument_expression_list) { AstVectorRef argument_list = argument_expression_list->argument_list; - int i; ValueVectorRef value_vec = ValueVectorFunc(ctor)(NULL); - for (i = 0; i < (int)AST_VECTOR_FUNC(size)(argument_list); i++) { + AstRef *itr; + AstRef *begin = AST_VECTOR_FUNC(begin)(argument_list); + AstRef *end = AST_VECTOR_FUNC(end)(argument_list); + for (itr = begin; itr != end; itr++) { ValueVectorFunc(push_back)(value_vec, - get_variable(variable_set, AST_VECTOR_FUNC(at)(argument_list, i))->value); + get_variable(variable_set, *itr)->value); } return value_vec; } From e21e89763e563529b1fcdc1a1b58137468e0d506 Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 08:38:56 +0900 Subject: [PATCH 38/51] use iterator --- src/code_generator/variable_set.c | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/src/code_generator/variable_set.c b/src/code_generator/variable_set.c index f61432d4..c845cc39 100644 --- a/src/code_generator/variable_set.c +++ b/src/code_generator/variable_set.c @@ -10,11 +10,12 @@ DEFINE_VECTOR(VariableRef) VariableRef get_variable_identifier( VariableSetRef variable_set, AstIdentifierRef name) { AstTokenRef name_str = ast_get_token(name->token); - int i; - for (i = 0; i < VariableSetFunc(size)(variable_set); i++) { - VariableRef variable = VariableSetFunc(at)(variable_set, i); - if (string_compare(variable->name, name_str) == 0) - return variable; + VariableRef *itr; + VariableRef *begin = VariableSetFunc(begin)(variable_set); + VariableRef *end = VariableSetFunc(end)(variable_set); + for (itr = begin; itr != end; itr++) { + if (string_compare((*itr)->name, name_str) == 0) + return *itr; } return NULL; } From eb21889141b013be264565fa126ed23f3c0d3ffb Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 08:42:51 +0900 Subject: [PATCH 39/51] use iterator --- src/code_generator/translation_unit.c | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/src/code_generator/translation_unit.c b/src/code_generator/translation_unit.c index d4bc6289..e4ef614e 100644 --- a/src/code_generator/translation_unit.c +++ b/src/code_generator/translation_unit.c @@ -29,11 +29,12 @@ void define_function(LLVMModuleRef module, LLVMBuilderRef builder, void translation_unit(LLVMModuleRef module, AstTranslationUnitRef translation_unit) { AstVectorRef vector = translation_unit->external_declaration_vector; LLVMBuilderRef builder = LLVMCreateBuilder(); - int i; - for (i = 0; i < (int)AST_VECTOR_FUNC(size)(vector); ++i) { - AstRef external_declaration = AST_VECTOR_FUNC(at)(vector, i); - if (ast_is_function_definition(external_declaration)) { - define_function(module, builder, ast_get_function_definition(external_declaration)); + AstRef *itr; + AstRef *begin = AST_VECTOR_FUNC(begin)(vector); + AstRef *end = AST_VECTOR_FUNC(end)(vector); + for (itr = begin; itr != end; itr++) { + if (ast_is_function_definition(*itr)) { + define_function(module, builder, ast_get_function_definition(*itr)); } else { /* declaration(ast_get_declaration(external_declaration)); */ } From 924f050fa7b1b7800b1f7ac54034d2fb8a53ba01 Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 09:09:05 +0900 Subject: [PATCH 40/51] implement build_block_declaration --- src/code_generator/statements.c | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/code_generator/statements.c b/src/code_generator/statements.c index a195c8b2..2fcb2c43 100644 --- a/src/code_generator/statements.c +++ b/src/code_generator/statements.c @@ -1,6 +1,7 @@ #include "code_generator.h" #include "variable_set.h" #include "ast/statements_impl.h" +#include "ast/declarations_impl.h" #include "ast/is_method.h" #include "ast/get_method.h" #include "ast/ast_impl.h" @@ -22,6 +23,13 @@ void build_block_declaration_list( } } +void build_block_declaration( + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + AstDeclarationRef declaration) { + LLVMTypeRef type = get_type(declaration->declaration_specifier_list); + build_block_type(module, builder, variable_set, type, declaration->init_declarator_list); +} + void build_block_statement_list( LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstStatementListRef statement_list) { @@ -51,6 +59,8 @@ void build_block(LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef va build_block_compound_statement(module, builder, variable_set, ast_get_compound_statement(ast)); break; case AST_DECLARATION_LIST: build_block_declaration_list(module, builder, variable_set, ast_get_declaration_list(ast)); break; + case AST_DECLARATION: + build_block_declaration(module, builder, variable_set, ast_get_declaration(ast)); break; case AST_STATEMENT_LIST: build_block_statement_list(module, builder, variable_set, ast_get_statement_list(ast)); break; case AST_STATEMENT: From db6df1888a79b995af6c0504c7e26864931f2909 Mon Sep 17 00:00:00 2001 From: prime Date: Wed, 30 Dec 2015 17:12:47 +0900 Subject: [PATCH 41/51] use iterator --- src/code_generator/statements.c | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/src/code_generator/statements.c b/src/code_generator/statements.c index 2fcb2c43..d4a1c831 100644 --- a/src/code_generator/statements.c +++ b/src/code_generator/statements.c @@ -17,9 +17,11 @@ void build_block_declaration_list( LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstDeclarationListRef declaration_list) { AstVectorRef declaration_vector = declaration_list->declaration_vector; - int i; - for (i = 0; i < AST_VECTOR_FUNC(size)(declaration_vector); i++) { - build_block(module, builder, variable_set, AST_VECTOR_FUNC(at)(declaration_vector, i)); + AstRef *itr; + AstRef *begin = AST_VECTOR_FUNC(begin)(declaration_vector); + AstRef *end = AST_VECTOR_FUNC(end)(declaration_vector); + for (itr = begin; itr != end; itr++) { + build_block(module, builder, variable_set, *itr); } } @@ -34,9 +36,11 @@ void build_block_statement_list( LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstStatementListRef statement_list) { AstVectorRef statement_vector = statement_list->statement_vector; - int i; - for (i = 0; i < AST_VECTOR_FUNC(size)(statement_vector); i++) { - build_block(module, builder, variable_set, AST_VECTOR_FUNC(at)(statement_vector, i)); + AstRef *itr; + AstRef *begin = AST_VECTOR_FUNC(begin)(statement_vector); + AstRef *end = AST_VECTOR_FUNC(end)(statement_vector); + for (itr = begin; itr != end; itr++) { + build_block(module, builder, variable_set, *itr); } } From 4412d66b1f117877d3770f9e3e404dcdbe2753ef Mon Sep 17 00:00:00 2001 From: prime Date: Thu, 31 Dec 2015 02:12:43 +0900 Subject: [PATCH 42/51] rename build_block_type to build_block_with_type --- src/code_generator/statements.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/code_generator/statements.c b/src/code_generator/statements.c index d4a1c831..28ab9756 100644 --- a/src/code_generator/statements.c +++ b/src/code_generator/statements.c @@ -29,7 +29,7 @@ void build_block_declaration( LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstDeclarationRef declaration) { LLVMTypeRef type = get_type(declaration->declaration_specifier_list); - build_block_type(module, builder, variable_set, type, declaration->init_declarator_list); + build_block_with_type(module, builder, variable_set, type, declaration->init_declarator_list); } void build_block_statement_list( From 2b565682892cd7b76fc1f13eddaf5d74e54021c3 Mon Sep 17 00:00:00 2001 From: prime Date: Thu, 31 Dec 2015 02:25:05 +0900 Subject: [PATCH 43/51] add pool.* --- src/code_generator/code_generator.h | 13 +++---------- src/code_generator/pool.c | 21 +++++++++++++++++++++ src/code_generator/pool.h | 24 ++++++++++++++++++++++++ src/code_generator/translation_unit.c | 1 + src/code_generator/type.c | 2 -- src/code_generator/value.c | 3 +-- src/code_generator/variable_set.c | 3 +-- src/code_generator/variable_set.h | 4 +--- 8 files changed, 52 insertions(+), 19 deletions(-) create mode 100644 src/code_generator/pool.c create mode 100644 src/code_generator/pool.h diff --git a/src/code_generator/code_generator.h b/src/code_generator/code_generator.h index d0283f22..5ae0c0da 100644 --- a/src/code_generator/code_generator.h +++ b/src/code_generator/code_generator.h @@ -8,16 +8,9 @@ #include "vector.h" #include "stdstring.h" #include "variable_set.h" - -#define TypeVectorFunc(func) VECTORFUNC(LLVMTypeRef, func) - -DECLARE_VECTOR(LLVMTypeRef) -typedef VECTORREF(LLVMTypeRef) TypeVectorRef; - -#define ValueVectorFunc(func) VECTORFUNC(LLVMValueRef, func) - -DECLARE_VECTOR(LLVMValueRef) -typedef VECTORREF(LLVMValueRef) ValueVectorRef; +#include "pool.h" +typedef struct VECTOR(LLVMTypeRef) *TypeVectorRef; +typedef struct VECTOR(LLVMValueRef) *ValueVectorRef; void translation_unit(LLVMModuleRef module, AstTranslationUnitRef translation_unit); LLVMTypeRef get_type(AstRef ast); diff --git a/src/code_generator/pool.c b/src/code_generator/pool.c new file mode 100644 index 00000000..b651d54a --- /dev/null +++ b/src/code_generator/pool.c @@ -0,0 +1,21 @@ +#include "pool.h" +#include + +static MemoryPoolRef g_codegen_pool = NULL; + +void codegen_pool_ctor(void) { + assert(!g_codegen_pool); + g_codegen_pool = memory_pool_ctor(CODEGEN_POOL_CHUNK_SIZE); +} + +void codegen_pool_dtor(void) { + memory_pool_dtor(&g_codegen_pool); +} + +MemoryPoolRef codegen_pool(void) { + return g_codegen_pool; +} + +DEFINE_VECTOR(LLVMTypeRef) +DEFINE_VECTOR(LLVMValueRef) +DEFINE_VECTOR(VariableRef) diff --git a/src/code_generator/pool.h b/src/code_generator/pool.h new file mode 100644 index 00000000..be760ed1 --- /dev/null +++ b/src/code_generator/pool.h @@ -0,0 +1,24 @@ +#ifndef KMC_C89_COMPILER_CODE_GENERATOR_POOL_H +#define KMC_C89_COMPILER_CODE_GENERATOR_POOL_H + +#include "memory_pool.h" +#include "vector.h" +#include "stdstring.h" +#include "variable_set.h" + +#define codegen_palloc(type) \ + palloc(type, codegen_pool(), 1) + +static const size_t CODEGEN_POOL_CHUNK_SIZE = 1024; + +void codegen_pool_ctor(void); +void codegen_pool_dtor(void); +MemoryPoolRef codegen_pool(void); + +#define TypeVectorFunc(func) VECTORFUNC(LLVMTypeRef, func) +DECLARE_VECTOR(LLVMTypeRef) + +#define ValueVectorFunc(func) VECTORFUNC(LLVMValueRef, func) +DECLARE_VECTOR(LLVMValueRef) + +#endif /* KMC_C89_COMPILER_CODE_GENERATOR_POOL_H */ diff --git a/src/code_generator/translation_unit.c b/src/code_generator/translation_unit.c index e4ef614e..0a0e76b3 100644 --- a/src/code_generator/translation_unit.c +++ b/src/code_generator/translation_unit.c @@ -1,4 +1,5 @@ #include "code_generator.h" +#include "pool.h" #include "ast/external_definitions_impl.h" #include "stdstring.h" #include "ast/is_method.h" diff --git a/src/code_generator/type.c b/src/code_generator/type.c index cabcdcf9..03dd58c3 100644 --- a/src/code_generator/type.c +++ b/src/code_generator/type.c @@ -4,8 +4,6 @@ #include "ast/get_method.h" #include "ast/ast_impl.h" -DEFINE_VECTOR(LLVMTypeRef) - LLVMTypeRef get_type_declaration_specifier_list( AstDeclarationSpecifierListRef declaration_specifier_list) { return LLVMInt32Type(); diff --git a/src/code_generator/value.c b/src/code_generator/value.c index ee18e9d3..4ac70f70 100644 --- a/src/code_generator/value.c +++ b/src/code_generator/value.c @@ -1,13 +1,12 @@ #include "code_generator.h" #include "variable_set.h" +#include "pool.h" #include "stdstring.h" #include "ast/expressions_impl.h" #include "ast/is_method.h" #include "ast/get_method.h" #include "ast/ast_impl.h" -DEFINE_VECTOR(LLVMValueRef) - ValueVectorRef get_arguments( VariableSetRef variable_set, AstArgumentExpressionListRef argument_expression_list) { diff --git a/src/code_generator/variable_set.c b/src/code_generator/variable_set.c index c845cc39..27284033 100644 --- a/src/code_generator/variable_set.c +++ b/src/code_generator/variable_set.c @@ -1,12 +1,11 @@ #include "variable_set.h" #include "vector_impl.h" +#include "pool.h" #include "ast/get_method.h" #include "ast/lexical_elements_impl.h" #include "ast/expressions_impl.h" #include "ast/ast_impl.h" -DEFINE_VECTOR(VariableRef) - VariableRef get_variable_identifier( VariableSetRef variable_set, AstIdentifierRef name) { AstTokenRef name_str = ast_get_token(name->token); diff --git a/src/code_generator/variable_set.h b/src/code_generator/variable_set.h index 62d70a23..44cd3e90 100644 --- a/src/code_generator/variable_set.h +++ b/src/code_generator/variable_set.h @@ -4,7 +4,6 @@ #include #include "ast.h" #include "vector.h" -#include "stdstring.h" struct Variable { AstTokenRef name; @@ -15,10 +14,9 @@ struct Variable { typedef struct Variable *VariableRef; #define VariableSetFunc(func) VECTORFUNC(VariableRef, func) - DECLARE_VECTOR(VariableRef) -typedef VECTORREF(VariableRef) VariableSetRef; +typedef struct VECTOR(VariableRef) *VariableSetRef; VariableRef get_variable(VariableSetRef variable_set, AstRef ast); VariableRef get_variable_identifier(VariableSetRef variable_set, AstIdentifierRef ast); From 4b8a6ca97a22ada3a45e75671e1d867782e0db3e Mon Sep 17 00:00:00 2001 From: prime Date: Thu, 31 Dec 2015 02:25:59 +0900 Subject: [PATCH 44/51] implement build_block_with_type --- src/code_generator/statements.c | 60 +++++++++++++++++++++++++++++++ src/code_generator/variable_set.h | 1 + 2 files changed, 61 insertions(+) diff --git a/src/code_generator/statements.c b/src/code_generator/statements.c index 28ab9756..436aed3c 100644 --- a/src/code_generator/statements.c +++ b/src/code_generator/statements.c @@ -6,6 +6,66 @@ #include "ast/get_method.h" #include "ast/ast_impl.h" +void build_block_with_type( + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMTypeRef base_type, AstRef ast); + +void build_block_with_type_init_declarator_list( + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMTypeRef base_type, AstInitDeclaratorListRef init_declarator_list) { + AstVectorRef vector = init_declarator_list->init_declarator_vector; + AstRef *itr; + AstRef *begin = AST_VECTOR_FUNC(begin)(vector); + AstRef *end = AST_VECTOR_FUNC(end)(vector); + for (itr = begin; itr != end; itr++) { + build_block_with_type(module, builder, variable_set, base_type, *itr); + } +} + +void build_block_with_type_init_declarator( + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMTypeRef base_type, AstInitDeclaratorRef init_declarator) { + build_block_with_type( + module, builder, variable_set, base_type, + init_declarator->init_declarator); +} + +void build_block_with_type_declarator( + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMTypeRef base_type, AstDeclaratorRef declarator) { + AstTokenRef name = get_name(declarator->direct_declarator); + LLVMTypeRef type = base_type; /* get_type_with_base_type(declarator->direct_declarator); */ + make_variable(variable_set, name, type, NULL); +} + +void build_block_with_type( + LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMTypeRef base_type, AstRef ast) { + switch (ast->tag) { + case AST_INIT_DECLARATOR_LIST: + build_block_with_type_init_declarator_list( + module, builder, variable_set, base_type, + ast_get_init_declarator_list(ast)); + break; + case AST_INIT_DECLARATOR: + build_block_with_type_init_declarator( + module, builder, variable_set, base_type, + ast_get_init_declarator(ast)); + break; + case AST_DECLARATOR: + build_block_with_type_declarator( + module, builder, variable_set, base_type, + ast_get_declarator(ast)); + break; + case AST_DECLARATOR_WITH_INITIALIZER: + build_block_with_type_declarator_with_initializer( + module, builder, variable_set, base_type, + ast_get_declarator_with_initializer(ast)); + break; + default:; + } +} + void build_block_compound_statement( LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstCompoundStatementRef compound_statement) { diff --git a/src/code_generator/variable_set.h b/src/code_generator/variable_set.h index 44cd3e90..b8cc1721 100644 --- a/src/code_generator/variable_set.h +++ b/src/code_generator/variable_set.h @@ -20,5 +20,6 @@ typedef struct VECTOR(VariableRef) *VariableSetRef; VariableRef get_variable(VariableSetRef variable_set, AstRef ast); VariableRef get_variable_identifier(VariableSetRef variable_set, AstIdentifierRef ast); +void make_variable(VariableSetRef variable_set, AstTokenRef name, LLVMTypeRef type, LLVMValueRef value); #endif /* KMC_C89_COMPILER_VARIABLE_SET_H */ From 49abf5fca552f793ed3fba51debadce721abe9c7 Mon Sep 17 00:00:00 2001 From: prime Date: Thu, 31 Dec 2015 02:26:15 +0900 Subject: [PATCH 45/51] implement make_variable --- src/code_generator/variable_set.c | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/code_generator/variable_set.c b/src/code_generator/variable_set.c index 27284033..bed62865 100644 --- a/src/code_generator/variable_set.c +++ b/src/code_generator/variable_set.c @@ -41,3 +41,11 @@ VariableRef get_variable(VariableSetRef variable_set, AstRef ast) { } return NULL; } + +void make_variable(VariableSetRef variable_set, AstTokenRef name, LLVMTypeRef type, LLVMValueRef value) { + VariableRef variable = codegen_palloc(struct Variable); + variable->name = name; + variable->type = type; + variable->value = value; + VariableSetFunc(push_back)(variable_set, variable); +} From d01c774fdb58e5a3196cd8b3df591d59e0991b14 Mon Sep 17 00:00:00 2001 From: prime Date: Thu, 31 Dec 2015 08:02:48 +0900 Subject: [PATCH 46/51] remove VariableRef, VariableSetRef --- src/code_generator/code_generator.h | 6 ++-- src/code_generator/expression.c | 52 +++++++++++++-------------- src/code_generator/pool.c | 1 - src/code_generator/statements.c | 24 ++++++------- src/code_generator/translation_unit.c | 2 +- src/code_generator/value.c | 4 +-- src/code_generator/variable_set.c | 32 +++++++---------- src/code_generator/variable_set.h | 20 ++--------- 8 files changed, 60 insertions(+), 81 deletions(-) diff --git a/src/code_generator/code_generator.h b/src/code_generator/code_generator.h index 5ae0c0da..99a12f3d 100644 --- a/src/code_generator/code_generator.h +++ b/src/code_generator/code_generator.h @@ -17,8 +17,8 @@ LLVMTypeRef get_type(AstRef ast); TypeVectorRef get_parameter_types(AstRef ast); LLVMTypeRef get_function_type(AstFunctionDefinitionRef function_definition); AstTokenRef get_name(AstRef ast); -ValueVectorRef get_arguments(VariableSetRef variable_set, AstArgumentExpressionListRef ast); -void build_block(LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstRef ast); -LLVMValueRef build_expression(LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstRef ast); +ValueVectorRef get_arguments(ValueVectorRef variable_set, AstArgumentExpressionListRef ast); +void build_block(LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstRef ast); +LLVMValueRef build_expression(LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstRef ast); #endif /* KMC_C89_COMPILER_CODE_GENERATOR_H */ diff --git a/src/code_generator/expression.c b/src/code_generator/expression.c index 6417d22d..f1a1854c 100644 --- a/src/code_generator/expression.c +++ b/src/code_generator/expression.c @@ -7,111 +7,111 @@ #include "ast/ast_impl.h" LLVMValueRef build_expression_expression( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstExpressionRef expression) { return build_expression(module, builder, variable_set, expression->expression); } LLVMValueRef build_expression_comma_expression( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstCommaExpressionRef comma_expression) { build_expression(module, builder, variable_set, comma_expression->expression); return build_expression(module, builder, variable_set, comma_expression->expression); } LLVMValueRef build_expression_assignment_expression( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstAssignmentExpressionRef expression) { return build_expression(module, builder, variable_set, expression->expression); } LLVMValueRef build_expression_basic_assignment_expression( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstBasicAssignmentExpressionRef expression) { LLVMValueRef rhs = build_expression(module, builder, variable_set, expression->assignment); - return LLVMBuildStore(builder, rhs, get_variable(variable_set, expression->unary)->value); + return LLVMBuildStore(builder, rhs, get_variable(variable_set, expression->unary)); } LLVMValueRef build_expression_conditional_expression( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstConditionalExpressionRef expression) { return build_expression(module, builder, variable_set, expression->expression); } LLVMValueRef build_expression_logical_or_expression( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstLogicalOrExpressionRef expression) { return build_expression(module, builder, variable_set, expression->expression); } LLVMValueRef build_expression_logical_and_expression( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstLogicalAndExpressionRef expression) { return build_expression(module, builder, variable_set, expression->expression); } LLVMValueRef build_expression_bitwise_or_expression( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstBitwiseOrExpressionRef expression) { return build_expression(module, builder, variable_set, expression->expression); } LLVMValueRef build_expression_bitwise_xor_expression( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstBitwiseXorExpressionRef expression) { return build_expression(module, builder, variable_set, expression->expression); } LLVMValueRef build_expression_bitwise_and_expression( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstBitwiseAndExpressionRef expression) { return build_expression(module, builder, variable_set, expression->expression); } LLVMValueRef build_expression_equality_expression( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstEqualityExpressionRef expression) { return build_expression(module, builder, variable_set, expression->expression); } LLVMValueRef build_expression_relarional_expression( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstRelationalExpressionRef expression) { return build_expression(module, builder, variable_set, expression->expression); } LLVMValueRef build_expression_shift_expression( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstShiftExpressionRef expression) { return build_expression(module, builder, variable_set, expression->expression); } LLVMValueRef build_expression_additive_expression( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstAdditiveExpressionRef expression) { return build_expression(module, builder, variable_set, expression->expression); } LLVMValueRef build_expression_multiplicative_expression( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstMultiplicativeExpressionRef expression) { return build_expression(module, builder, variable_set, expression->expression); } LLVMValueRef build_expression_cast_expression( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstCastExpressionRef cast) { return build_expression(module, builder, variable_set, cast->cast); } LLVMValueRef build_expression_unary_expression( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstUnaryExpressionRef unary) { return build_expression(module, builder, variable_set, unary->unary); } LLVMValueRef build_expression_function_call_expression( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstFunctionCallExpressionRef function_call) { AstTokenRef function_name = get_name(function_call->function); LLVMValueRef function = LLVMGetNamedFunction(module, string_data(function_name)); @@ -128,38 +128,38 @@ LLVMValueRef build_expression_function_call_expression( } LLVMValueRef build_expression_postfix_expression( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstPostfixExpressionRef postfix) { return build_expression(module, builder, variable_set, postfix->postfix); } LLVMValueRef build_expression_primary_expression( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstPrimaryExpressionRef primary) { return build_expression(module, builder, variable_set, primary->primary_expression); } LLVMValueRef build_expression_constant( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstConstantRef constant) { return build_expression(module, builder, variable_set, constant->constant); } LLVMValueRef build_expression_integer_constant( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstIntegerConstantRef constant) { return LLVMConstIntOfString( LLVMInt32Type(), string_data(ast_get_token(constant->token)), 10); } LLVMValueRef build_expression_identifier( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstIdentifierRef identifier) { - return get_variable_identifier(variable_set, identifier)->value; + return get_variable_identifier(variable_set, identifier); } LLVMValueRef build_expression( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstRef ast) { + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstRef ast) { switch (ast->tag) { case AST_EXPRESSION: return build_expression_expression(module, builder, variable_set, ast_get_expression(ast)); diff --git a/src/code_generator/pool.c b/src/code_generator/pool.c index b651d54a..7aa5f108 100644 --- a/src/code_generator/pool.c +++ b/src/code_generator/pool.c @@ -18,4 +18,3 @@ MemoryPoolRef codegen_pool(void) { DEFINE_VECTOR(LLVMTypeRef) DEFINE_VECTOR(LLVMValueRef) -DEFINE_VECTOR(VariableRef) diff --git a/src/code_generator/statements.c b/src/code_generator/statements.c index 436aed3c..fe3d1fc0 100644 --- a/src/code_generator/statements.c +++ b/src/code_generator/statements.c @@ -7,11 +7,11 @@ #include "ast/ast_impl.h" void build_block_with_type( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, LLVMTypeRef base_type, AstRef ast); void build_block_with_type_init_declarator_list( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, LLVMTypeRef base_type, AstInitDeclaratorListRef init_declarator_list) { AstVectorRef vector = init_declarator_list->init_declarator_vector; AstRef *itr; @@ -23,7 +23,7 @@ void build_block_with_type_init_declarator_list( } void build_block_with_type_init_declarator( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, LLVMTypeRef base_type, AstInitDeclaratorRef init_declarator) { build_block_with_type( module, builder, variable_set, base_type, @@ -31,7 +31,7 @@ void build_block_with_type_init_declarator( } void build_block_with_type_declarator( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, LLVMTypeRef base_type, AstDeclaratorRef declarator) { AstTokenRef name = get_name(declarator->direct_declarator); LLVMTypeRef type = base_type; /* get_type_with_base_type(declarator->direct_declarator); */ @@ -39,7 +39,7 @@ void build_block_with_type_declarator( } void build_block_with_type( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, LLVMTypeRef base_type, AstRef ast) { switch (ast->tag) { case AST_INIT_DECLARATOR_LIST: @@ -67,14 +67,14 @@ void build_block_with_type( } void build_block_compound_statement( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstCompoundStatementRef compound_statement) { build_block(module, builder, variable_set, compound_statement->declaration_list); build_block(module, builder, variable_set, compound_statement->statement_list); } void build_block_declaration_list( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstDeclarationListRef declaration_list) { AstVectorRef declaration_vector = declaration_list->declaration_vector; AstRef *itr; @@ -86,14 +86,14 @@ void build_block_declaration_list( } void build_block_declaration( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstDeclarationRef declaration) { LLVMTypeRef type = get_type(declaration->declaration_specifier_list); build_block_with_type(module, builder, variable_set, type, declaration->init_declarator_list); } void build_block_statement_list( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstStatementListRef statement_list) { AstVectorRef statement_vector = statement_list->statement_vector; AstRef *itr; @@ -105,19 +105,19 @@ void build_block_statement_list( } void build_block_statement( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstStatementRef statement) { build_block(module, builder, variable_set, statement->statement); } void build_block_expression_statement( - LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstExpressionStatementRef expression_statement) { if (expression_statement->expression != NULL) build_expression(module, builder, variable_set, expression_statement->expression); } -void build_block(LLVMModuleRef module, LLVMBuilderRef builder, VariableSetRef variable_set, AstRef ast) { +void build_block(LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstRef ast) { switch (ast->tag) { case AST_COMPOUND_STATEMENT: build_block_compound_statement(module, builder, variable_set, ast_get_compound_statement(ast)); break; diff --git a/src/code_generator/translation_unit.c b/src/code_generator/translation_unit.c index 0a0e76b3..52878fc8 100644 --- a/src/code_generator/translation_unit.c +++ b/src/code_generator/translation_unit.c @@ -22,7 +22,7 @@ void define_function(LLVMModuleRef module, LLVMBuilderRef builder, LLVMTypeRef type = get_function_type(function_definition); LLVMValueRef func = LLVMAddFunction(module, string_data(name), type); LLVMBasicBlockRef entry = LLVMAppendBasicBlock(func, "entry"); - VariableSetRef variable_set = VariableSetFunc(ctor)(NULL); + ValueVectorRef variable_set = ValueVectorFunc(ctor)(NULL); LLVMPositionBuilderAtEnd(builder, entry); build_block(module, builder, variable_set, function_definition->compound_statement); } diff --git a/src/code_generator/value.c b/src/code_generator/value.c index 4ac70f70..820c06df 100644 --- a/src/code_generator/value.c +++ b/src/code_generator/value.c @@ -8,7 +8,7 @@ #include "ast/ast_impl.h" ValueVectorRef get_arguments( - VariableSetRef variable_set, + ValueVectorRef variable_set, AstArgumentExpressionListRef argument_expression_list) { AstVectorRef argument_list = argument_expression_list->argument_list; ValueVectorRef value_vec = ValueVectorFunc(ctor)(NULL); @@ -17,7 +17,7 @@ ValueVectorRef get_arguments( AstRef *end = AST_VECTOR_FUNC(end)(argument_list); for (itr = begin; itr != end; itr++) { ValueVectorFunc(push_back)(value_vec, - get_variable(variable_set, *itr)->value); + get_variable(variable_set, *itr)); } return value_vec; } diff --git a/src/code_generator/variable_set.c b/src/code_generator/variable_set.c index bed62865..82854d90 100644 --- a/src/code_generator/variable_set.c +++ b/src/code_generator/variable_set.c @@ -1,35 +1,37 @@ #include "variable_set.h" +#include #include "vector_impl.h" #include "pool.h" #include "ast/get_method.h" #include "ast/lexical_elements_impl.h" #include "ast/expressions_impl.h" #include "ast/ast_impl.h" +#include "stdstring.h" -VariableRef get_variable_identifier( - VariableSetRef variable_set, AstIdentifierRef name) { +LLVMValueRef get_variable_identifier( + ValueVectorRef variable_set, AstIdentifierRef name) { AstTokenRef name_str = ast_get_token(name->token); - VariableRef *itr; - VariableRef *begin = VariableSetFunc(begin)(variable_set); - VariableRef *end = VariableSetFunc(end)(variable_set); + LLVMValueRef *itr; + LLVMValueRef *begin = ValueVectorFunc(begin)(variable_set); + LLVMValueRef *end = ValueVectorFunc(end)(variable_set); for (itr = begin; itr != end; itr++) { - if (string_compare((*itr)->name, name_str) == 0) + if (strcmp(LLVMGetValueName(*itr), string_data(name_str)) == 0) return *itr; } return NULL; } -VariableRef get_variable_unary_expression( - VariableSetRef variable_set, AstUnaryExpressionRef unary) { +LLVMValueRef get_variable_unary_expression( + ValueVectorRef variable_set, AstUnaryExpressionRef unary) { return get_variable(variable_set, unary->unary); } -VariableRef get_variable_postfix_expression( - VariableSetRef variable_set, AstPostfixExpressionRef postfix) { +LLVMValueRef get_variable_postfix_expression( + ValueVectorRef variable_set, AstPostfixExpressionRef postfix) { return get_variable(variable_set, postfix->postfix); } -VariableRef get_variable(VariableSetRef variable_set, AstRef ast) { +LLVMValueRef get_variable(ValueVectorRef variable_set, AstRef ast) { switch (ast->tag) { case AST_UNARY_EXPRESSION: return get_variable_unary_expression(variable_set, ast_get_unary_expression(ast)); @@ -41,11 +43,3 @@ VariableRef get_variable(VariableSetRef variable_set, AstRef ast) { } return NULL; } - -void make_variable(VariableSetRef variable_set, AstTokenRef name, LLVMTypeRef type, LLVMValueRef value) { - VariableRef variable = codegen_palloc(struct Variable); - variable->name = name; - variable->type = type; - variable->value = value; - VariableSetFunc(push_back)(variable_set, variable); -} diff --git a/src/code_generator/variable_set.h b/src/code_generator/variable_set.h index b8cc1721..506a604c 100644 --- a/src/code_generator/variable_set.h +++ b/src/code_generator/variable_set.h @@ -3,23 +3,9 @@ #include #include "ast.h" -#include "vector.h" +#include "pool.h" -struct Variable { - AstTokenRef name; - LLVMTypeRef type; - LLVMValueRef value; -}; - -typedef struct Variable *VariableRef; - -#define VariableSetFunc(func) VECTORFUNC(VariableRef, func) -DECLARE_VECTOR(VariableRef) - -typedef struct VECTOR(VariableRef) *VariableSetRef; - -VariableRef get_variable(VariableSetRef variable_set, AstRef ast); -VariableRef get_variable_identifier(VariableSetRef variable_set, AstIdentifierRef ast); -void make_variable(VariableSetRef variable_set, AstTokenRef name, LLVMTypeRef type, LLVMValueRef value); +LLVMValueRef get_variable(ValueVectorRef variable_set, AstRef ast); +LLVMValueRef get_variable_identifier(ValueVectorRef variable_set, AstIdentifierRef ast); #endif /* KMC_C89_COMPILER_VARIABLE_SET_H */ From c30b511cd97c3c686dfbf6412d61dd0b57d6ef0d Mon Sep 17 00:00:00 2001 From: prime Date: Thu, 31 Dec 2015 08:15:45 +0900 Subject: [PATCH 47/51] move definition ValueVectorRef, TypeVectorRef --- src/code_generator/code_generator.h | 2 -- src/code_generator/pool.h | 5 ++++- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/code_generator/code_generator.h b/src/code_generator/code_generator.h index 99a12f3d..baf97339 100644 --- a/src/code_generator/code_generator.h +++ b/src/code_generator/code_generator.h @@ -9,8 +9,6 @@ #include "stdstring.h" #include "variable_set.h" #include "pool.h" -typedef struct VECTOR(LLVMTypeRef) *TypeVectorRef; -typedef struct VECTOR(LLVMValueRef) *ValueVectorRef; void translation_unit(LLVMModuleRef module, AstTranslationUnitRef translation_unit); LLVMTypeRef get_type(AstRef ast); diff --git a/src/code_generator/pool.h b/src/code_generator/pool.h index be760ed1..73eec305 100644 --- a/src/code_generator/pool.h +++ b/src/code_generator/pool.h @@ -1,6 +1,7 @@ #ifndef KMC_C89_COMPILER_CODE_GENERATOR_POOL_H #define KMC_C89_COMPILER_CODE_GENERATOR_POOL_H +#include #include "memory_pool.h" #include "vector.h" #include "stdstring.h" @@ -17,8 +18,10 @@ MemoryPoolRef codegen_pool(void); #define TypeVectorFunc(func) VECTORFUNC(LLVMTypeRef, func) DECLARE_VECTOR(LLVMTypeRef) - +typedef struct VECTOR(LLVMTypeRef) *TypeVectorRef; + #define ValueVectorFunc(func) VECTORFUNC(LLVMValueRef, func) DECLARE_VECTOR(LLVMValueRef) +typedef struct VECTOR(LLVMValueRef) *ValueVectorRef; #endif /* KMC_C89_COMPILER_CODE_GENERATOR_POOL_H */ From 096749f81d732a2631396d3f8d51a1a17fa73716 Mon Sep 17 00:00:00 2001 From: prime Date: Thu, 31 Dec 2015 08:17:08 +0900 Subject: [PATCH 48/51] fix headers --- src/code_generator/pool.c | 1 + src/code_generator/pool.h | 2 -- src/code_generator/variable_set.c | 1 - 3 files changed, 1 insertion(+), 3 deletions(-) diff --git a/src/code_generator/pool.c b/src/code_generator/pool.c index 7aa5f108..6fb5e928 100644 --- a/src/code_generator/pool.c +++ b/src/code_generator/pool.c @@ -1,4 +1,5 @@ #include "pool.h" +#include "vector_impl.h" #include static MemoryPoolRef g_codegen_pool = NULL; diff --git a/src/code_generator/pool.h b/src/code_generator/pool.h index 73eec305..6bc4e864 100644 --- a/src/code_generator/pool.h +++ b/src/code_generator/pool.h @@ -4,8 +4,6 @@ #include #include "memory_pool.h" #include "vector.h" -#include "stdstring.h" -#include "variable_set.h" #define codegen_palloc(type) \ palloc(type, codegen_pool(), 1) diff --git a/src/code_generator/variable_set.c b/src/code_generator/variable_set.c index 82854d90..57bbec37 100644 --- a/src/code_generator/variable_set.c +++ b/src/code_generator/variable_set.c @@ -1,7 +1,6 @@ #include "variable_set.h" #include #include "vector_impl.h" -#include "pool.h" #include "ast/get_method.h" #include "ast/lexical_elements_impl.h" #include "ast/expressions_impl.h" From 62e3bc5c98062fb49e0fe8028ec46f572fa00d60 Mon Sep 17 00:00:00 2001 From: prime Date: Thu, 31 Dec 2015 08:18:22 +0900 Subject: [PATCH 49/51] implement build_block_with_type_declarator{,_with_initializer} --- src/code_generator/statements.c | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/src/code_generator/statements.c b/src/code_generator/statements.c index fe3d1fc0..c90ba50e 100644 --- a/src/code_generator/statements.c +++ b/src/code_generator/statements.c @@ -34,8 +34,20 @@ void build_block_with_type_declarator( LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, LLVMTypeRef base_type, AstDeclaratorRef declarator) { AstTokenRef name = get_name(declarator->direct_declarator); - LLVMTypeRef type = base_type; /* get_type_with_base_type(declarator->direct_declarator); */ - make_variable(variable_set, name, type, NULL); + LLVMTypeRef type = base_type; /* get_type_with_type(declarator->direct_declarator); */ + LLVMValueRef variable = LLVMGetUndef(type); + LLVMSetValueName(variable, string_data(name)); + ValueVectorFunc(push_back)(variable_set, variable); +} + +void build_block_with_type_declarator_with_initializer( + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, + LLVMTypeRef base_type, AstDeclaratorWithInitializerRef declarator) { + AstTokenRef name = get_name(declarator->declarator); + LLVMTypeRef type = base_type; /* get_type_with_type(declarator->declarator); */ + LLVMValueRef variable = make_value(module, builder, variable_set, type, declarator->initializer); + LLVMSetValueName(variable, string_data(name)); + ValueVectorFunc(push_back)(variable_set, variable); } void build_block_with_type( From 4881c5e087a69906cc920df6557a449f03ed809c Mon Sep 17 00:00:00 2001 From: prime Date: Thu, 31 Dec 2015 08:18:44 +0900 Subject: [PATCH 50/51] implement make_value --- src/code_generator/code_generator.h | 1 + src/code_generator/value.c | 54 +++++++++++++++++++++++++++++ 2 files changed, 55 insertions(+) diff --git a/src/code_generator/code_generator.h b/src/code_generator/code_generator.h index baf97339..559f7bdf 100644 --- a/src/code_generator/code_generator.h +++ b/src/code_generator/code_generator.h @@ -18,5 +18,6 @@ AstTokenRef get_name(AstRef ast); ValueVectorRef get_arguments(ValueVectorRef variable_set, AstArgumentExpressionListRef ast); void build_block(LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstRef ast); LLVMValueRef build_expression(LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, AstRef ast); +LLVMValueRef make_value(LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, LLVMTypeRef type, AstRef ast); #endif /* KMC_C89_COMPILER_CODE_GENERATOR_H */ diff --git a/src/code_generator/value.c b/src/code_generator/value.c index 820c06df..d670058e 100644 --- a/src/code_generator/value.c +++ b/src/code_generator/value.c @@ -3,6 +3,7 @@ #include "pool.h" #include "stdstring.h" #include "ast/expressions_impl.h" +#include "ast/declarations_impl.h" #include "ast/is_method.h" #include "ast/get_method.h" #include "ast/ast_impl.h" @@ -21,3 +22,56 @@ ValueVectorRef get_arguments( } return value_vec; } + +LLVMValueRef make_value_initializer( + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, + LLVMTypeRef type, AstInitializerRef initializer) { + return make_value(module, builder, variable_set, type, initializer->initializer); +} + +LLVMValueRef make_value_assignment_expression( + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, + LLVMTypeRef type, AstAssignmentExpressionRef expression) { + return build_expression(module, builder, variable_set, expression->expression); +} + +LLVMValueRef make_value_initializer_list( + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, + LLVMTypeRef type, AstInitializerListRef initializer_list) { + ValueVectorRef value_vec = ValueVectorFunc(ctor)(NULL); + AstRef *itr; + AstRef *begin = AST_VECTOR_FUNC(begin)(initializer_list->initializer_vector); + AstRef *end = AST_VECTOR_FUNC(end)(initializer_list->initializer_vector); + for (itr = begin; itr != end; itr++) { + ValueVectorFunc(push_back)( + value_vec, make_value(module, builder, variable_set, type, *itr)); + } + switch (LLVMGetTypeKind(type)) { + case LLVMStructTypeKind: + return LLVMConstStruct( + ValueVectorFunc(data)(value_vec), ValueVectorFunc(size)(value_vec), false); + case LLVMArrayTypeKind: + return LLVMConstArray( + LLVMGetElementType(type), ValueVectorFunc(data)(value_vec), + ValueVectorFunc(size)(value_vec)); + default: + return NULL; + } +} + +LLVMValueRef make_value( + LLVMModuleRef module, LLVMBuilderRef builder, ValueVectorRef variable_set, + LLVMTypeRef type, AstRef ast) { + switch (ast->tag) { + case AST_INITIALIZER: + return make_value_initializer(module, builder, variable_set, type, + ast_get_initializer(ast)); + case AST_ASSIGNMENT_EXPRESSION: + return make_value_assignment_expression(module, builder, variable_set, type, + ast_get_assignment_expression(ast)); + case AST_INITIALIZER_LIST: + return make_value_initializer_list(module, builder, variable_set, type, + ast_get_initializer_list(ast)); + default:; + } +} From 391d5a8a119f273961bdb77269d6db0edae12598 Mon Sep 17 00:00:00 2001 From: prime Date: Thu, 31 Dec 2015 10:15:11 +0900 Subject: [PATCH 51/51] implement get_type_with_type --- src/code_generator/code_generator.h | 1 + src/code_generator/type.c | 41 +++++++++++++++++++++++++++++ 2 files changed, 42 insertions(+) diff --git a/src/code_generator/code_generator.h b/src/code_generator/code_generator.h index 559f7bdf..ec162939 100644 --- a/src/code_generator/code_generator.h +++ b/src/code_generator/code_generator.h @@ -12,6 +12,7 @@ void translation_unit(LLVMModuleRef module, AstTranslationUnitRef translation_unit); LLVMTypeRef get_type(AstRef ast); +LLVMTypeRef get_type_with_type(LLVMTypeRef base_type, AstRef ast); TypeVectorRef get_parameter_types(AstRef ast); LLVMTypeRef get_function_type(AstFunctionDefinitionRef function_definition); AstTokenRef get_name(AstRef ast); diff --git a/src/code_generator/type.c b/src/code_generator/type.c index 03dd58c3..9e352a0a 100644 --- a/src/code_generator/type.c +++ b/src/code_generator/type.c @@ -1,5 +1,6 @@ #include "code_generator.h" #include "stdstring.h" +#include "ast/declarations_impl.h" #include "ast/is_method.h" #include "ast/get_method.h" #include "ast/ast_impl.h" @@ -17,3 +18,43 @@ LLVMTypeRef get_type(AstRef ast) { return NULL; } } + +LLVMTypeRef get_type_with_type_declarator( + LLVMTypeRef base_type, AstDeclaratorRef declarator) { + LLVMTypeRef direct_type = get_type_with_type(base_type, declarator->direct_declarator); + return get_type_with_type(direct_type, declarator->pointer); +} + +LLVMTypeRef get_type_with_type_direct_declarator( + LLVMTypeRef base_type, AstDirectDeclaratorRef direct_declarator) { + return get_type_with_type(base_type, direct_declarator->direct_declarator); +} + +LLVMTypeRef get_type_with_type_pointer( + LLVMTypeRef base_type, AstPointerRef pointer) { + if (pointer->pointer == NULL) return base_type; + else + return get_type_with_type(LLVMPointerType(base_type, 0), pointer->pointer); +} + +LLVMTypeRef get_type_with_type_identifier( + LLVMTypeRef base_type, AstIdentifierRef identifier) { + UNUSED(identifier); + return base_type; +} + +LLVMTypeRef get_type_with_type(LLVMTypeRef base_type, AstRef ast) { + switch (ast->tag) { + case AST_DECLARATOR: + return get_type_with_type_declarator(base_type, ast_get_declarator(ast)); + case AST_DIRECT_DECLARATOR: + return get_type_with_type_direct_declarator( + base_type, ast_get_direct_declarator(ast)); + case AST_POINTER: + return get_type_with_type_pointer( base_type, ast_get_pointer(ast)); + case AST_IDENTIFIER: + return get_type_with_type_identifier(base_type, ast_get_identifier(ast)); + default: + return NULL; + } +}