authorgravatar for git@vexu.euVeikka Tuominen <git@vexu.eu> 2020-10-30 21:14:22+02:00
committergravatar for git@vexu.euVeikka Tuominen <git@vexu.eu> 2020-10-31 09:30:13+02:00
log3ff381385aad13955360973d1604410335f2ddff
tree060e1ce37a6d79608b0e59b1e2d5db95fa1c8de4
parent80dd43213727b914418175e6e35c35de95204f7c
signaturelock-open Commit is signed but in an unrecognized format.

translate-c: correctly handle pointers to opaque demoted structs

2 files changed, 102 insertions(+), 35 deletions(-)

src/translate_c.zig+82-35
......@@ -19,8 +19,6 @@ pub const Error = error{OutOfMemory};
1919const TypeError = Error || error{UnsupportedType};
2020const TransError = TypeError || error{UnsupportedTranslation};
2121
22const DeclTable = std.AutoArrayHashMap(usize, []const u8);
23
2422const SymbolTable = std.StringArrayHashMap(*ast.Node);
2523const AliasList = std.ArrayList(struct {
2624 alias: []const u8,
......@@ -254,24 +252,25 @@ const Scope = struct {
254252pub const Context = struct {
255253 gpa: *mem.Allocator,
256254 arena: *mem.Allocator,
257 token_ids: std.ArrayListUnmanaged(Token.Id),
258 token_locs: std.ArrayListUnmanaged(Token.Loc),
259 errors: std.ArrayListUnmanaged(ast.Error),
255 token_ids: std.ArrayListUnmanaged(Token.Id) = .{},
256 token_locs: std.ArrayListUnmanaged(Token.Loc) = .{},
257 errors: std.ArrayListUnmanaged(ast.Error) = .{},
260258 source_buffer: *std.ArrayList(u8),
261259 err: Error,
262260 source_manager: *clang.SourceManager,
263 decl_table: DeclTable,
261 decl_table: std.AutoArrayHashMapUnmanaged(usize, []const u8) = .{},
264262 alias_list: AliasList,
265263 global_scope: *Scope.Root,
266264 clang_context: *clang.ASTContext,
267265 mangle_count: u32 = 0,
268 root_decls: std.ArrayListUnmanaged(*ast.Node),
266 root_decls: std.ArrayListUnmanaged(*ast.Node) = .{},
267 opaque_demotes: std.AutoHashMapUnmanaged(usize, void) = .{},
269268
270269 /// This one is different than the root scope's name table. This contains
271270 /// a list of names that we found by visiting all the top level decls without
272271 /// translating them. The other maps are updated as we translate; this one is updated
273272 /// up front in a pre-processing step.
274 global_names: std.StringArrayHashMap(void),
273 global_names: std.StringArrayHashMapUnmanaged(void) = .{},
275274
276275 fn getMangle(c: *Context) u32 {
277276 c.mangle_count += 1;
......@@ -362,24 +361,21 @@ pub fn translate(
362361 .source_buffer = &source_buffer,
363362 .source_manager = ast_unit.getSourceManager(),
364363 .err = undefined,
365 .decl_table = DeclTable.init(gpa),
366364 .alias_list = AliasList.init(gpa),
367365 .global_scope = try arena.allocator.create(Scope.Root),
368366 .clang_context = ast_unit.getASTContext(),
369 .global_names = std.StringArrayHashMap(void).init(gpa),
370 .token_ids = .{},
371 .token_locs = .{},
372 .errors = .{},
373 .root_decls = .{},
374367 };
375368 context.global_scope.* = Scope.Root.init(&context);
376 defer context.decl_table.deinit();
377 defer context.alias_list.deinit();
378 defer context.token_ids.deinit(gpa);
379 defer context.token_locs.deinit(gpa);
380 defer context.errors.deinit(gpa);
381 defer context.global_names.deinit();
382 defer context.root_decls.deinit(gpa);
369 defer {
370 context.decl_table.deinit(gpa);
371 context.alias_list.deinit();
372 context.token_ids.deinit(gpa);
373 context.token_locs.deinit(gpa);
374 context.errors.deinit(gpa);
375 context.global_names.deinit(gpa);
376 context.root_decls.deinit(gpa);
377 context.opaque_demotes.deinit(gpa);
378 }
383379
384380 try prepopulateGlobalNameTable(ast_unit, &context);
385381
......@@ -437,7 +433,7 @@ fn prepopulateGlobalNameTable(ast_unit: *clang.ASTUnit, c: *Context) !void {
437433 const macro = @ptrCast(*clang.MacroDefinitionRecord, entity);
438434 const raw_name = macro.getName_getNameStart();
439435 const name = try c.str(raw_name);
440 _ = try c.global_names.put(name, {});
436 _ = try c.global_names.put(c.gpa, name, {});
441437 },
442438 else => {},
443439 }
......@@ -465,7 +461,7 @@ fn declVisitorC(context: ?*c_void, decl: *const clang.Decl) callconv(.C) bool {
465461fn declVisitorNamesOnly(c: *Context, decl: *const clang.Decl) Error!void {
466462 if (decl.castToNamedDecl()) |named_decl| {
467463 const decl_name = try c.str(named_decl.getName_bytes_begin());
468 _ = try c.global_names.put(decl_name, {});
464 _ = try c.global_names.put(c.gpa, decl_name, {});
469465 }
470466}
471467
......@@ -804,7 +800,7 @@ fn visitVarDecl(c: *Context, var_decl: *const clang.VarDecl, mangled_name: ?[]co
804800}
805801
806802fn transTypeDefAsBuiltin(c: *Context, typedef_decl: *const clang.TypedefNameDecl, builtin_name: []const u8) !*ast.Node {
807 _ = try c.decl_table.put(@ptrToInt(typedef_decl.getCanonicalDecl()), builtin_name);
803 _ = try c.decl_table.put(c.gpa, @ptrToInt(typedef_decl.getCanonicalDecl()), builtin_name);
808804 return transCreateNodeIdentifier(c, builtin_name);
809805}
810806
......@@ -851,7 +847,7 @@ fn transTypeDef(c: *Context, typedef_decl: *const clang.TypedefNameDecl, top_lev
851847 return transCreateNodeIdentifier(c, checked_name);
852848 }
853849
854 _ = try c.decl_table.put(@ptrToInt(typedef_decl.getCanonicalDecl()), checked_name);
850 _ = try c.decl_table.put(c.gpa, @ptrToInt(typedef_decl.getCanonicalDecl()), checked_name);
855851 const node = (try transCreateNodeTypedef(rp, typedef_decl, true, checked_name)) orelse return null;
856852 try addTopLevelDecl(c, checked_name, node);
857853 return transCreateNodeIdentifier(c, checked_name);
......@@ -918,7 +914,7 @@ fn transRecordDecl(c: *Context, record_decl: *const clang.RecordDecl) Error!?*as
918914 }
919915
920916 const name = try std.fmt.allocPrint(c.arena, "{}_{}", .{ container_kind_name, bare_name });
921 _ = try c.decl_table.put(@ptrToInt(record_decl.getCanonicalDecl()), name);
917 _ = try c.decl_table.put(c.gpa, @ptrToInt(record_decl.getCanonicalDecl()), name);
922918
923919 const visib_tok = if (!is_unnamed) try appendToken(c, .Keyword_pub, "pub") else null;
924920 const mut_tok = try appendToken(c, .Keyword_const, "const");
......@@ -930,6 +926,7 @@ fn transRecordDecl(c: *Context, record_decl: *const clang.RecordDecl) Error!?*as
930926 const init_node = blk: {
931927 const rp = makeRestorePoint(c);
932928 const record_def = record_decl.getDefinition() orelse {
929 _ = try c.opaque_demotes.put(c.gpa, @ptrToInt(record_decl.getCanonicalDecl()), {});
933930 const opaque_type = try transCreateNodeOpaqueType(c);
934931 semicolon = try appendToken(c, .Semicolon, ";");
935932 break :blk opaque_type;
......@@ -954,6 +951,7 @@ fn transRecordDecl(c: *Context, record_decl: *const clang.RecordDecl) Error!?*as
954951 const field_qt = field_decl.getType();
955952
956953 if (field_decl.isBitField()) {
954 _ = try c.opaque_demotes.put(c.gpa, @ptrToInt(record_decl.getCanonicalDecl()), {});
957955 const opaque_type = try transCreateNodeOpaqueType(c);
958956 semicolon = try appendToken(c, .Semicolon, ";");
959957 try emitWarning(c, field_loc, "{} demoted to opaque type - has bitfield", .{container_kind_name});
......@@ -961,6 +959,7 @@ fn transRecordDecl(c: *Context, record_decl: *const clang.RecordDecl) Error!?*as
961959 }
962960
963961 if (qualTypeCanon(field_qt).isIncompleteOrZeroLengthArrayType(c.clang_context)) {
962 _ = try c.opaque_demotes.put(c.gpa, @ptrToInt(record_decl.getCanonicalDecl()), {});
964963 const opaque_type = try transCreateNodeOpaqueType(c);
965964 semicolon = try appendToken(c, .Semicolon, ";");
966965 try emitWarning(c, field_loc, "{} demoted to opaque type - has variable length array", .{container_kind_name});
......@@ -979,6 +978,7 @@ fn transRecordDecl(c: *Context, record_decl: *const clang.RecordDecl) Error!?*as
979978 _ = try appendToken(c, .Colon, ":");
980979 const field_type = transQualType(rp, field_qt, field_loc) catch |err| switch (err) {
981980 error.UnsupportedType => {
981 _ = try c.opaque_demotes.put(c.gpa, @ptrToInt(record_decl.getCanonicalDecl()), {});
982982 const opaque_type = try transCreateNodeOpaqueType(c);
983983 semicolon = try appendToken(c, .Semicolon, ";");
984984 try emitWarning(c, record_loc, "{} demoted to opaque type - unable to translate type of field {}", .{ container_kind_name, raw_name });
......@@ -988,13 +988,13 @@ fn transRecordDecl(c: *Context, record_decl: *const clang.RecordDecl) Error!?*as
988988 };
989989
990990 const align_expr = blk_2: {
991 const alignment = field_decl.getAlignedAttribute(rp.c.clang_context);
991 const alignment = field_decl.getAlignedAttribute(c.clang_context);
992992 if (alignment != 0) {
993 _ = try appendToken(rp.c, .Keyword_align, "align");
994 _ = try appendToken(rp.c, .LParen, "(");
993 _ = try appendToken(c, .Keyword_align, "align");
994 _ = try appendToken(c, .LParen, "(");
995995 // Clang reports the alignment in bits
996 const expr = try transCreateNodeInt(rp.c, alignment / 8);
997 _ = try appendToken(rp.c, .RParen, ")");
996 const expr = try transCreateNodeInt(c, alignment / 8);
997 _ = try appendToken(c, .RParen, ")");
998998
999999 break :blk_2 expr;
10001000 }
......@@ -1013,6 +1013,7 @@ fn transRecordDecl(c: *Context, record_decl: *const clang.RecordDecl) Error!?*as
10131013
10141014 if (is_anon) {
10151015 _ = try c.decl_table.put(
1016 c.gpa,
10161017 @ptrToInt(field_decl.getCanonicalDecl()),
10171018 raw_name,
10181019 );
......@@ -1065,7 +1066,7 @@ fn transEnumDecl(c: *Context, enum_decl: *const clang.EnumDecl) Error!?*ast.Node
10651066 }
10661067
10671068 const name = try std.fmt.allocPrint(c.arena, "enum_{}", .{bare_name});
1068 _ = try c.decl_table.put(@ptrToInt(enum_decl.getCanonicalDecl()), name);
1069 _ = try c.decl_table.put(c.gpa, @ptrToInt(enum_decl.getCanonicalDecl()), name);
10691070
10701071 const visib_tok = if (!is_unnamed) try appendToken(c, .Keyword_pub, "pub") else null;
10711072 const mut_tok = try appendToken(c, .Keyword_const, "const");
......@@ -1204,8 +1205,10 @@ fn transEnumDecl(c: *Context, enum_decl: *const clang.EnumDecl) Error!?*ast.Node
12041205 };
12051206 mem.copy(*ast.Node, container_node.fieldsAndDecls(), fields_and_decls.items);
12061207 break :blk &container_node.base;
1207 } else
1208 try transCreateNodeOpaqueType(c);
1208 } else blk: {
1209 _ = try c.opaque_demotes.put(c.gpa, @ptrToInt(enum_decl.getCanonicalDecl()), {});
1210 break :blk try transCreateNodeOpaqueType(c);
1211 };
12091212
12101213 const semicolon_token = try appendToken(c, .Semicolon, ";");
12111214 const node = try ast.Node.VarDecl.create(c.arena, .{
......@@ -4767,7 +4770,7 @@ fn transType(rp: RestorePoint, ty: *const clang.Type, source_loc: clang.SourceLo
47674770 optional_node.rhs = try transQualType(rp, child_qt, source_loc);
47684771 return &optional_node.base;
47694772 }
4770 if (typeIsOpaque(rp.c, child_qt.getTypePtr(), source_loc)) {
4773 if (typeIsOpaque(rp.c, child_qt.getTypePtr(), source_loc) or qualTypeWasDemotedToOpaque(rp.c, child_qt)) {
47714774 const optional_node = try transCreateNodeSimplePrefixOp(rp.c, .OptionalType, .QuestionMark, "?");
47724775 const pointer_node = try transCreateNodePtrType(
47734776 rp.c,
......@@ -4853,6 +4856,50 @@ fn transType(rp: RestorePoint, ty: *const clang.Type, source_loc: clang.SourceLo
48534856 }
48544857}
48554858
4859fn qualTypeWasDemotedToOpaque(c: *Context, qt: clang.QualType) bool {
4860 const ty = qt.getTypePtr();
4861 switch (qt.getTypeClass()) {
4862 .Typedef => {
4863 const typedef_ty = @ptrCast(*const clang.TypedefType, ty);
4864
4865 const typedef_decl = typedef_ty.getDecl();
4866 const underlying_type = typedef_decl.getUnderlyingType();
4867 return qualTypeWasDemotedToOpaque(c, underlying_type);
4868 },
4869 .Record => {
4870 const record_ty = @ptrCast(*const clang.RecordType, ty);
4871
4872 const record_decl = record_ty.getDecl();
4873 const canonical = @ptrToInt(record_decl.getCanonicalDecl());
4874 return c.opaque_demotes.contains(canonical);
4875 },
4876 .Enum => {
4877 const enum_ty = @ptrCast(*const clang.EnumType, ty);
4878
4879 const enum_decl = enum_ty.getDecl();
4880 const canonical = @ptrToInt(enum_decl.getCanonicalDecl());
4881 return c.opaque_demotes.contains(canonical);
4882 },
4883 .Elaborated => {
4884 const elaborated_ty = @ptrCast(*const clang.ElaboratedType, ty);
4885 return qualTypeWasDemotedToOpaque(c, elaborated_ty.getNamedType());
4886 },
4887 .Decayed => {
4888 const decayed_ty = @ptrCast(*const clang.DecayedType, ty);
4889 return qualTypeWasDemotedToOpaque(c, decayed_ty.getDecayedType());
4890 },
4891 .Attributed => {
4892 const attributed_ty = @ptrCast(*const clang.AttributedType, ty);
4893 return qualTypeWasDemotedToOpaque(c, attributed_ty.getEquivalentType());
4894 },
4895 .MacroQualified => {
4896 const macroqualified_ty = @ptrCast(*const clang.MacroQualifiedType, ty);
4897 return qualTypeWasDemotedToOpaque(c, macroqualified_ty.getModifiedType());
4898 },
4899 else => return false,
4900 }
4901}
4902
48564903fn isCVoid(qt: clang.QualType) bool {
48574904 const ty = qt.getTypePtr();
48584905 if (ty.getTypeClass() == .Builtin) {
test/translate_c.zig+20
......@@ -3,6 +3,26 @@ const std = @import("std");
33const CrossTarget = std.zig.CrossTarget;
44
55pub fn addCases(cases: *tests.TranslateCContext) void {
6 cases.add("pointer to opaque demoted struct",
7 \\typedef struct {
8 \\ _Atomic int foo;
9 \\} Foo;
10 \\
11 \\typedef struct {
12 \\ Foo *bar;
13 \\} Bar;
14 , &[_][]const u8{
15 \\const struct_unnamed_1 = //
16 ,
17 \\warning: unsupported type: 'Atomic'
18 \\ opaque {}; //
19 ,
20 \\pub const Foo = struct_unnamed_1;
21 \\const struct_unnamed_2 = extern struct {
22 \\ bar: ?*Foo,
23 \\};
24 });
25
626 cases.add("macro expressions respect C operator precedence",
727 \\#define FOO *((foo) + 2)
828 \\#define VALUE (1 + 2 * 3 + 4 * 5 + 6 << 7 | 8 == 9)