Initial pass at #315

If this approach looks good I can apply it to the other []const u8 fields in Type.zig.

One slightly annoying thing is juggling the string_interner in the test runner, to make sure it doesn't get de-inited. I could make the string interner not be owned by the Compilation, but I'm not sure that feels right either.

Here is my first cut at record layout ported from this Rust code https://github.com/mahkoh/repr-c.

I'm looking for feedback and/or a punch list before merging.

It's a bit delicate. If you look at it sideways one of the tests will likely break. I'm skipping a good % of the test cases for various reasons (#300, #301), as well as others I haven't dug into yet. There are also some tests that clang-13 fails on, so there is some discrepancy in Rust tests and clang. I need to look into those.

The tests are auto-generated from the Rust code. Because of that test/test_records.zig is doing the filtering for which tests to skip (or parts of tests to skip).

I shoved a bunch of stuff into Type.Record and Type.Record.Field. I think I can get rid of some of that in the future, but I'd like to leave it now as it makes debugging easier.

I haven't done any work towards getting other targets to work. I'm currently just trying to mimic clang on x86 linux.

There are some asserts as well as panics, and I haven't done any errors or warnings. yet.

I'm happy for any feedback, even nitpicky "that's not very zig-like" feedback. It's a new-ish language to me. Or major "this is all wrong" is fine as well.

Based on doing this, I think we should probably do #40 first to make token locations better and make it easier to get the values we'll be working with.

Currently both just default to 1.

Note: the size calculation should happen after the attributes after the type are parsed since they may contain a packed attribute.

Add two new type specifiers: typeof_type and typeof_expr, which are the types returned by typeof (depending on whether it's called with a type or an expression)

This allows us to track the underlying type or expression that was used.

❯ arocc test.c -o test
thread 12150 panic: integer cast truncated bits
/home/varlad/arocc/src/Parser.zig:226:19: 0x2b86bc in Parser.addList (arocc)
    const start = @intCast(u32, p.data.items.len);
                  ^
/home/varlad/arocc/src/Parser.zig:3275:71: 0x2a317c in Parser.condExpr (arocc)
        .data = .{ .if3 = .{ .cond = cond.node, .body = (try p.addList(&.{ then_expr.node, else_expr.node })).start } },
                                                                      ^
/home/varlad/arocc/src/Parser.zig:2491:27: 0x28a5c0 in Parser.macroExpr (arocc)
    const res = p.condExpr() catch |e| switch (e) {
                          ^
/home/varlad/arocc/src/Preprocessor.zig:415:28: 0x26ef1f in Preprocessor.expr (arocc)
    return parser.macroExpr();
                           ^
/home/varlad/arocc/src/Preprocessor.zig:121:40: 0x267f80 in Preprocessor.preprocess (arocc)
                        if (try pp.expr(&tokenizer)) {
                                       ^
/home/varlad/arocc/src/Preprocessor.zig:1098:22: 0x26fecb in Preprocessor.include (arocc)
    try pp.preprocess(new_source);
                     ^
/home/varlad/arocc/src/Preprocessor.zig:205:55: 0x268a8a in Preprocessor.preprocess (arocc)
                    .keyword_include => try pp.include(&tokenizer),
                                                      ^
/home/varlad/arocc/src/Preprocessor.zig:1098:22: 0x26fecb in Preprocessor.include (arocc)
    try pp.preprocess(new_source);
                     ^
/home/varlad/arocc/src/Preprocessor.zig:205:55: 0x268a8a in Preprocessor.preprocess (arocc)
                    .keyword_include => try pp.include(&tokenizer),
                                                      ^
/home/varlad/arocc/src/Preprocessor.zig:1098:22: 0x26fecb in Preprocessor.include (arocc)
    try pp.preprocess(new_source);
                     ^
/home/varlad/arocc/src/Preprocessor.zig:205:55: 0x268a8a in Preprocessor.preprocess (arocc)
                    .keyword_include => try pp.include(&tokenizer),
                                                      ^
/home/varlad/arocc/src/main.zig:209:22: 0x25f5ac in processSource (arocc)
    try pp.preprocess(source);
                     ^
/home/varlad/arocc/src/main.zig:196:22: 0x25884e in handleArgs (arocc)
        processSource(comp, source, builtin, user_macros) catch |e| switch (e) {
                     ^
/home/varlad/arocc/src/main.zig:33:15: 0x24f8c2 in main (arocc)
    handleArgs(&comp, args) catch |err| switch (err) {
              ^
/home/varlad/zig-master/lib/std/start.zig:507:29: 0x2481cc in std.start.callMain (arocc)
            return root.main();
                            ^
/home/varlad/zig-master/lib/std/start.zig:452:12: 0x22c1ce in std.start.callMainWithArgs (arocc)
    return @call(.{ .modifier = .always_inline }, callMain, .{});
           ^
/home/varlad/zig-master/lib/std/start.zig:366:17: 0x22b1f6 in std.start.posixCallMainAndExit (arocc)
    std.os.exit(@call(.{ .modifier = .always_inline }, callMainWithArgs, .{ argc, argv, envp }));
                ^
/home/varlad/zig-master/lib/std/start.zig:279:5: 0x22b002 in std.start._start (arocc)
    @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
    ^
fish: Job 1, 'arocc test.c -o test' terminated by signal SIGABRT (Abort)

where test.c reads

#include "stdio.h"

int main()
{
	printf("Well, heck");
	return 0;
}

Built with Zig v0.9.0-dev.861+311797f68 via zig build

Compute sizeof/alignof records.

This isn't a perfect solution - I'm unsure if it works identically to other compilers in all cases & it definitely doesn't factor in packed attributes. But it's good enough - I wanted to load netinet/in.h, which fails with the following error otherwise:

Compiler error:
/usr/include/netinet/in.h:244:53: warning: overflow in expression; result is '18446744073709551615' [-Winteger-overflow]
    unsigned char sin_zero[sizeof (struct sockaddr) -
                                                    ^
/usr/include/netinet/in.h:244:27: error: array is too large
    unsigned char sin_zero[sizeof (struct sockaddr) -


// Because of this expression:
unsigned char sin_zero[sizeof (struct sockaddr) -
                        __SOCKADDR_COMMON_SIZE -
                        sizeof (in_port_t) -
                        sizeof (struct in_addr)];

Two questions:

1. How can i report a compiler error? see line 1711. I poked around Compilation.zig but nothing jumped out.
2. The test is obviously flawed, I just matched whatever GCC produced on my system. I can either remove the test, or maybe there's a way to skip it on non-x64-linux systems?

Briefly discussed here: https://github.com/Vexu/arocc/pull/232#issuecomment-1030530859

If you like this approach I can fill out the fromExplicitCast function.

Putting this up as a draft to see what you think; right now it just consumes attributes (in some but not all places where they are allowed) but doesn't do anything with them.

Remaining work includes but is not limited to:

• [x] Implement __has_attribute preprocessor function
• [ ] merge consecutive attribute specifiers?
• [ ] Verify arg count and types for each attribute
• [ ] Strategy for attributed statements, var decls, function decls, types, etc
• [ ] Actually do something with the attributes

This addresses the GCC/clang side of #367. It's also a pretty ugly hack so feel free to close it if you'd prefer to handle it some other way. Short of reworking the entire Type system, another way I think it could be handled would be adding a ?u29 alignment field to Type.Attributed to store typedef alignments

The fundamental problem is that after parse time there's no way to distinguish "struct with attributes" from "typedef which adds attributes to a struct" . It's relevant because attributes directly on a struct have a different effect on alignment than attributes on a typedef.

struct A {
    int x;
};
struct __attribute__((aligned(2))) B {
    int x;
};
typedef __attribute__((aligned(2))) struct A Aligned_A;

_Static_assert(_Alignof(struct A) == 4, "");
_Static_assert(_Alignof(struct B) == 4, "");
_Static_assert(_Alignof(Aligned_A) == 2, "");

Both struct B and Aligned_A are represented as "attributed record", where the record has a single int field, but they have different alignment because the alignment on a typedef is allowed to be lower than the natural alignment.

Adds a test suite for record layout.

• Runs permutations of targets and tests
• Has expected failures for some tests due to various zig/arocc issues, including parser failures.
• will error if a test passes when it currently expects to fail
• Can run a specific platform/test for local debugging
• readme for more info

MSVC seems to walk down the type stack.

__declspec(align(8)) typedef int I1;
__declspec(align(1)) typedef I1 I2;

_Static_assert(sizeof(I1) == 4, "");
_Static_assert(_Alignof(I1) == 8, "");
_Static_assert(sizeof(I2) == 4, "");
_Static_assert(_Alignof(I2) == 8, "");

where GCC/Clang don't

typedef int I1 __attribute__((aligned(8)));
typedef I1 I2 __attribute__((aligned(1)));

_Static_assert(sizeof(I1) == 4, "");
_Static_assert(_Alignof(I1) == 8, "");
_Static_assert(sizeof(I2) == 4, "");
_Static_assert(_Alignof(I2) == 1, "");

Based on https://en.cppreference.com/w/c/23

• [x] _Static_asert with no message
• [x] [[nodiscard]]
• [x] [[maybe_unused]]
• [x] [[deprecated]]
• [x] Attributes
• [ ] IEEE 754 decimal floating-point types
• [x] [[fallthrough]]
• [ ] u8 character constants
• [ ] Removal of function definitions without prototype
• [x] [[nodiscard]] with message
• [x] Unnamed parameters in function definitions
• [ ] Labels before declarations and end of blocks
• [x] Binary integer constants
• [ ] __has_c_attribute in preprocessor conditionals
• [x] Allow duplicate attributes
• [ ] IEEE 754 interchange and extended types
• [x] Digit separators
• [ ] #elifdef and #elifndef
• [ ] Type change of u8 string literals
• [ ] [[maybe_unused]] for labels
• [x] #warning
• [x] Bit-precise integer types (_BitInt)
• [x] [[noreturn]]
• [ ] Suffixes for bit-precise integer constants
• [x] __has_include in preprocessor conditionals
• [ ] Removal of function declarations without prototype
• [x] Empty initializers
• [x] typeof ...
• [ ] ... and typeof_unqual
• [x] New spelling of keywords
• [x] Predefined true and false
• [ ] [[unsequenced]]
• [ ] [[reproducible]]
• [ ] Relax requirements for variadic parameter list
• [ ] Type inference in object definitions (auto)
• [x] constexpr objects
• [ ] nullptr
• [ ] #embed

int foo(void) {
    const int a;
    a = 1;
    return a;
}

Arocc output:

./a.c:40:7: error: expression is not assignable
    a = 1;
      ^
1 error generated.

Clang output:

a.c:40:7: error: cannot assign to variable 'a' with const-qualified type 'const int'
    a = 1;
    ~ ^
a.c:39:15: note: variable 'a' declared const here
    const int a;
    ~~~~~~~~~~^
1 error generated.

Starting with C23, implicit-int type specifiers are no longer allowed:

// test.c
static x = 5;

➜  ~/local/llvm15-release/bin/clang -std=c2x test.c
test.c:1:8: error: a type specifier is required for all declarations
static x = 5;
~~~~~~ ^
1 error generated.

This will need a new error diagnostic in Diagnostics.zig and an update to Type.zig where we issue .missing_type_specifier