shishantbiswas/c3c
1
1
Fork 0
mirror of https://github.com/c3lang/c3c.git synced 2026-02-27 12:01:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

Updated vector comparison behaviour and semantics.

Browse Source
This commit is contained in:
Christoffer Lerno
2022-12-14 18:20:42 +01:00
committed by Christoffer Lerno
parent abf0f64ac0
commit b5afa98507
14 changed files with 273 additions and 2652 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/compiler/enums.h
View File

@@ -889,6 +889,12 @@ typedef enum
BUILTIN_TRAP,
BUILTIN_TRUNC,
BUILTIN_UNREACHABLE,
BUILTIN_VECCOMPLT,
BUILTIN_VECCOMPLE,
BUILTIN_VECCOMPGT,
BUILTIN_VECCOMPGE,
BUILTIN_VECCOMPEQ,
BUILTIN_VECCOMPNE,
BUILTIN_VOLATILE_LOAD,
BUILTIN_VOLATILE_STORE,

85
src/compiler/llvm_codegen_builtins.c
View File

@@ -437,6 +437,83 @@ static void llvm_emit_wrap_builtin(GenContext *c, BEValue *result_value, Expr *e
llvm_value_set(result_value, res, expr->type);
}
static void llvm_emit_veccomp(GenContext *c, BEValue *value, Expr *expr, BuiltinFunction fn)
{
Expr **args = expr->call_expr.arguments;
unsigned count = vec_size(args);
assert(count == 2);
LLVMValueRef mask;
llvm_emit_expr(c, value, args[0]);
llvm_value_rvalue(c, value);
LLVMValueRef lhs_value = value->value;
llvm_emit_expr(c, value, args[1]);
llvm_value_rvalue(c, value);
LLVMValueRef rhs_value = value->value;
LLVMValueRef res;
if (type_flat_is_floatlike(args[0]->type))
{
switch (fn)
{
case BUILTIN_VECCOMPEQ:
// Unordered?
res = LLVMBuildFCmp(c->builder, LLVMRealOEQ, lhs_value, rhs_value, "eq");
break;
case BUILTIN_VECCOMPNE:
// Unordered?
res = LLVMBuildFCmp(c->builder, LLVMRealONE, lhs_value, rhs_value, "neq");
break;
case BUILTIN_VECCOMPGE:
res = LLVMBuildFCmp(c->builder, LLVMRealOGE, lhs_value, rhs_value, "ge");
break;
case BUILTIN_VECCOMPGT:
res = LLVMBuildFCmp(c->builder, LLVMRealOGT, lhs_value, rhs_value, "gt");
break;
case BUILTIN_VECCOMPLE:
res = LLVMBuildFCmp(c->builder, LLVMRealOLE, lhs_value, rhs_value, "le");
break;
case BUILTIN_VECCOMPLT:
res = LLVMBuildFCmp(c->builder, LLVMRealOLT, lhs_value, rhs_value, "lt");
break;
default:
UNREACHABLE
}
}
else
{
bool is_signed = type_is_signed(value->type);
switch (fn)
{
case BUILTIN_VECCOMPEQ:
// Unordered?
res = LLVMBuildICmp(c->builder, LLVMIntEQ, lhs_value, rhs_value, "eq");
break;
case BUILTIN_VECCOMPNE:
// Unordered?
res = LLVMBuildICmp(c->builder, LLVMIntNE, lhs_value, rhs_value, "neq");
break;
case BUILTIN_VECCOMPGE:
res = LLVMBuildICmp(c->builder, is_signed ? LLVMIntSGE : LLVMIntUGE, lhs_value, rhs_value, "ge");
break;
case BUILTIN_VECCOMPGT:
res = LLVMBuildICmp(c->builder, is_signed ? LLVMIntSGT : LLVMIntUGT, lhs_value, rhs_value, "gt");
break;
case BUILTIN_VECCOMPLE:
res = LLVMBuildICmp(c->builder, is_signed ? LLVMIntSLE : LLVMIntULE, lhs_value, rhs_value, "le");
break;
case BUILTIN_VECCOMPLT:
res = LLVMBuildICmp(c->builder, is_signed ? LLVMIntSLT : LLVMIntULT, lhs_value, rhs_value, "lt");
break;
default:
UNREACHABLE
}
}
Type *result_type = type_get_vector_bool(value->type);
res = LLVMBuildSExt(c->builder, res, llvm_get_type(c, result_type), "");
llvm_value_set(value, res, result_type);
return;
}
void llvm_emit_builtin_call(GenContext *c, BEValue *result_value, Expr *expr)
{
BuiltinFunction func = exprptr(expr->call_expr.function)->builtin_expr.builtin;
@@ -458,6 +535,14 @@ void llvm_emit_builtin_call(GenContext *c, BEValue *result_value, Expr *expr)
llvm_value_set(result_value, value, expr->type);
return;
}
case BUILTIN_VECCOMPLT:
case BUILTIN_VECCOMPLE:
case BUILTIN_VECCOMPNE:
case BUILTIN_VECCOMPEQ:
case BUILTIN_VECCOMPGT:
case BUILTIN_VECCOMPGE:
llvm_emit_veccomp(c, result_value, expr, func);
return;
case BUILTIN_REVERSE:
llvm_emit_reverse(c, result_value, expr);
return;

30
src/compiler/llvm_codegen_expr.c
View File

@@ -38,7 +38,8 @@ static inline void llvm_emit_vararg_parameter(GenContext *c, BEValue *value, Typ
static inline void llvm_emit_variant(GenContext *c, BEValue *value, Expr *expr);
static inline void llvm_emit_vector_initializer_list(GenContext *c, BEValue *value, Expr *expr);
static inline void llvm_extract_bitvalue_from_array(GenContext *c, BEValue *be_value, Decl *member, Decl *parent_decl);
static void llvm_convert_vector_comparison(GenContext *c, BEValue *be_value, LLVMValueRef val, Type *vector_type);
static void llvm_convert_vector_comparison(GenContext *c, BEValue *be_value, LLVMValueRef val, Type *vector_type,
bool is_equals);
static void llvm_emit_any_pointer(GenContext *c, BEValue *any, BEValue *pointer);
static void llvm_emit_binary(GenContext *c, BEValue *be_value, Expr *expr, BEValue *lhs_loaded, BinaryOp binary_op);
static void llvm_emit_call_expr(GenContext *c, BEValue *result_value, Expr *expr, BEValue *target);
@@ -178,15 +179,17 @@ BEValue llvm_emit_assign_expr(GenContext *c, BEValue *ref, Expr *expr, LLVMValue
return value;
}
static void llvm_convert_vector_comparison(GenContext *c, BEValue *be_value, LLVMValueRef val, Type *vector_type)
static void llvm_convert_vector_comparison(GenContext *c, BEValue *be_value, LLVMValueRef val, Type *vector_type,
bool is_equals)
{
Type *result_type = type_get_vector_bool(vector_type);
val = LLVMBuildSExt(c->builder, val, llvm_get_type(c, result_type), "");
llvm_value_set(be_value, val, result_type);
unsigned bits = vector_type->array.len;
LLVMTypeRef llvm_type = LLVMTypeOf(val);
if (bits <= 64)
{
}
unsigned intrinsic = is_equals ? intrinsic_id.vector_reduce_and : intrinsic_id.vector_reduce_or;
LLVMValueRef result = llvm_emit_call_intrinsic(c, intrinsic, &llvm_type, 1, &val, 1);
llvm_value_set_bool(be_value, result);
}
static LLVMValueRef llvm_emit_coerce_alignment(GenContext *c, BEValue *be_value, LLVMTypeRef coerce_type, AlignSize target_alignment, AlignSize *resulting_alignment)
@@ -3042,7 +3045,7 @@ void llvm_emit_int_comp_raw(GenContext *c, BEValue *result, Type *lhs_type, Type
}
if (vector_type)
{
llvm_convert_vector_comparison(c, result, value, lhs_type);
llvm_convert_vector_comparison(c, result, value, lhs_type, binary_op == BINARYOP_EQ);
return;
}
llvm_value_set_bool(result, value);
@@ -3083,7 +3086,7 @@ void llvm_emit_int_comp_raw(GenContext *c, BEValue *result, Type *lhs_type, Type
{
if (vector_type)
{
llvm_convert_vector_comparison(c, result, comp_value, lhs_type);
llvm_convert_vector_comparison(c, result, comp_value, lhs_type, binary_op == BINARYOP_EQ);
return;
}
llvm_value_set_bool(result, comp_value);
@@ -3129,7 +3132,7 @@ void llvm_emit_int_comp_raw(GenContext *c, BEValue *result, Type *lhs_type, Type
}
if (vector_type)
{
llvm_convert_vector_comparison(c, result, comp_value, lhs_type);
llvm_convert_vector_comparison(c, result, comp_value, lhs_type, BINARYOP_EQ == binary_op);
return;
}
llvm_value_set_bool(result, comp_value);
@@ -3271,6 +3274,7 @@ static void llvm_emit_subarray_comp(GenContext *c, BEValue *be_value, BEValue *l
}
static void llvm_emit_float_comp(GenContext *c, BEValue *be_value, BEValue *lhs, BEValue *rhs, BinaryOp binary_op, Type *vector_type)
{
llvm_value_rvalue(c, lhs);
@@ -3305,7 +3309,7 @@ static void llvm_emit_float_comp(GenContext *c, BEValue *be_value, BEValue *lhs,
}
if (vector_type)
{
llvm_convert_vector_comparison(c, be_value, val, vector_type);
llvm_convert_vector_comparison(c, be_value, val, vector_type, BINARYOP_EQ == binary_op);
return;
}
llvm_value_set_bool(be_value, val);

18
src/compiler/sema_builtins.c
View File

@@ -316,6 +316,18 @@ bool sema_expr_analyse_builtin_call(SemaContext *context, Expr *expr)
return false;
}
break;
case BUILTIN_VECCOMPGE:
case BUILTIN_VECCOMPEQ:
case BUILTIN_VECCOMPLE:
case BUILTIN_VECCOMPGT:
case BUILTIN_VECCOMPLT:
case BUILTIN_VECCOMPNE:
if (!sema_check_builtin_args(args,
(BuiltinArg[]) { BA_VEC, BA_VEC },
arg_count)) return false;
if (!sema_check_builtin_args_match(args, 2)) return false;
rtype = type_get_vector_bool(args[0]->type);
break;
case BUILTIN_OVERFLOW_ADD:
case BUILTIN_OVERFLOW_MUL:
case BUILTIN_OVERFLOW_SUB:
@@ -612,6 +624,12 @@ static inline unsigned builtin_expected_args(BuiltinFunction func)
case BUILTIN_SAT_SHL:
case BUILTIN_SAT_SUB:
case BUILTIN_VOLATILE_STORE:
case BUILTIN_VECCOMPNE:
case BUILTIN_VECCOMPLT:
case BUILTIN_VECCOMPLE:
case BUILTIN_VECCOMPGE:
case BUILTIN_VECCOMPGT:
case BUILTIN_VECCOMPEQ:
return 2;
case BUILTIN_FMA:
case BUILTIN_FSHL:

8
src/compiler/sema_expr.c
View File

@@ -4949,6 +4949,11 @@ static bool sema_expr_analyse_comp(SemaContext *context, Expr *expr, Expr *left,
if (left_type->type_kind == TYPE_VECTOR && right_type->type_kind == TYPE_VECTOR)
{
if (!is_equality_type_op)
{
SEMA_ERROR(expr, "Vector types can only be tested for equality, for other comparison, use vector comparison functions.");
return false;
}
if (left_type->array.len == right_type->array.len)
{
Type *left_vec = type_vector_type(left_type);
@@ -5019,8 +5024,7 @@ DONE:
// 8. Set the type to bool
Type *return_type = left_type->type_kind == TYPE_VECTOR ? type_get_vector_bool(left_type) : type_bool;
expr->type = type_add_optional(return_type, IS_OPTIONAL(left) || IS_OPTIONAL(right));
expr->type = type_add_optional(type_bool, IS_OPTIONAL(left) || IS_OPTIONAL(right));
return true;
}

6
src/compiler/symtab.c
View File

@@ -248,6 +248,12 @@ void symtab_init(uint32_t capacity)
builtin_list[BUILTIN_SYSCLOCK] = KW_DEF("sysclock");
builtin_list[BUILTIN_TRAP] = KW_DEF("trap");
builtin_list[BUILTIN_TRUNC] = KW_DEF("trunc");
builtin_list[BUILTIN_VECCOMPLT] = KW_DEF("veccomplt");
builtin_list[BUILTIN_VECCOMPLE] = KW_DEF("veccomple");
builtin_list[BUILTIN_VECCOMPGT] = KW_DEF("veccompgt");
builtin_list[BUILTIN_VECCOMPGE] = KW_DEF("veccompge");
builtin_list[BUILTIN_VECCOMPEQ] = KW_DEF("veccompeq");
builtin_list[BUILTIN_VECCOMPNE] = KW_DEF("veccompne");
builtin_list[BUILTIN_UNREACHABLE] = KW_DEF("unreachable");
builtin_list[BUILTIN_VOLATILE_LOAD] = KW_DEF("volatile_load");
builtin_list[BUILTIN_VOLATILE_STORE] = KW_DEF("volatile_store");

1
src/compiler/types.c
View File

@@ -439,7 +439,6 @@ bool type_is_ordered(Type *type)
case TYPE_POINTER:
case TYPE_BOOL:
case TYPE_ENUM:
case TYPE_VECTOR:
return true;
case TYPE_TYPEDEF:
type = type->canonical;

2
src/version.h
View File

@@ -1 +1 @@
#define COMPILER_VERSION "0.3.118"
#define COMPILER_VERSION "0.3.120"