<andrewrk>
one of the major differences between zig as a C compiler and clang is that zig does not depend on any system-installed things unless you explicitly ask it to
<andrewrk>
and that's why the -target option works better with zig - because zig provides all the necessary things for whatever target you choose
<nairou>
Ah okay, makes sense
<nairou>
I was trying to ease my transition by getting the existing makefile working with zig, looks like I need to dig a little deeper :-)
<andrewrk>
you can still do that, but use zig build-obj
<andrewrk>
and you may need to modify some of the flags. see `zig --help`
<scientes>
oh woah, llvm's select works with vectors
<scientes>
but I think my user-space version is just fine
<scientes>
I actually know it is for ppc because i filed the bug
ntgg has quit [Ping timeout: 268 seconds]
<nairou>
Is there documentation for the Builder API? Website documentation shows examples but doesn't explain parameters, like for addObject and addExecutable and the like.
ltriant has quit [Ping timeout: 245 seconds]
<daurnimator>
nairou: no there isn't
<nairou>
Okay. Well, for example, Builder.addObject(). Second parameter is the source file name, but the first parameter... I assume it isn't just an arbitrary string, but I don't know what it's for.
<nairou>
Digging through zig source for them, I guess I'll experiment :-)
ltriant has joined #zig
<daurnimator>
nairou: the name is... the name of the object :P as in, e.g. what should the file name be derived from
ltriant has quit [Ping timeout: 248 seconds]
<nairou>
Derived from? Is it for the sake of debugging and showing object names?
<nairou>
Even addExecutable has a name parameter. I guess I don't understand what that would be used for. If you've giving a bunch of files to be built, why label each one with a separate name?
<daurnimator>
nairou: builder.addObject is asking the builder to create an object file. i.e. output `<name>.o`
kristoff_it has joined #zig
<daurnimator>
nairou: likewise .addExecutable is telling the builder: create the file "name" (or e.g. "name.exe" for windows)
<nairou>
Aha! Okay, that makes sense now. Thank you :-)
<daurnimator>
gonz_: thinking back to the values conversation, I had a realisation today: "only one way to do things" means that "keep old APIs around for compat" isn't allowed. which really means you have to pick between "break things" or "stagnate"
kristoff_it has joined #zig
<andrewrk>
scientes, I added a src() method to AstNode for debugging purposes
<andrewrk>
(gdb) p instruction.base.source_node->src()
<bnbn>
Hello I'm having some issues running tests that depend on libc and some other c libraries. Is their a standard way to setup tests so they pull in all the dependencies that my regular build.zig pulls in?
<andrewrk>
bnbn, you can set up your build.zig to run your tests
<andrewrk>
b.addTest
<bnbn>
and they will be run on compile or run?
<andrewrk>
combine that with b.addStep and you can give a nice API to the zig build user. look at the zig repo's build.zig for example
<bnbn>
ok thank you!
<andrewrk>
you'll probably want to set up a separate testing step and start doing `zig build test` when you want to test
<andrewrk>
ah ok this is for a better solution to the file system than a dedicated thread
<daurnimator>
andrewrk: also sockets (soon)
<andrewrk>
yeah so the idea is that the low level function, e.g. read() or whatever, it does the syscall, but if it gets EAGAIN, then it does this: suspend { give_the_kernel_my_pointer(@frame()); }
<andrewrk>
and the other code does resume on that. and that's it. now async/await works everywhere
<daurnimator>
andrewrk: with uring you don't try the read first -> you go directly to the give_the_kernel_my_pointer
<daurnimator>
but yes, that is how epoll would work
<andrewrk>
I thought the whole point of uring is that you can do some I/O without syscalls
<daurnimator>
andrewrk: yes that's correct -> you have a circular buffer of operations to do, you append and the kernel reads.
<daurnimator>
but unless you use a rare (requires extra permissions) mode; you still have to do one syscall to 'step' the loop
<daurnimator>
so you can e.g. queue up 100 operations: some reads, some writes, whatever, and then submit with one syscall
<daurnimator>
andrewrk: my intention is that you would write different "backends" for loops. we'd have a uring one, an epoll one, a select() one. -> for most programs, you'd try and do the uring syscall, and if not available fall back to epoll, if not available fall back to select().
<daurnimator>
(this picking a fall-back procedure would happen once on program start up)
<andrewrk>
epoll was added in linux 2.5.44 which is well below the minimum supported linux version which is 3.16
<daurnimator>
yeah but IIRC e.g. linux-on-windows doesn't support epoll?
<daurnimator>
select() is also just a really old API, so it's a good fallback across lots of operating systems.
kristoff_it has joined #zig
<andrewrk>
if linux-on-windows isn't identical to actual linux in terms of ABI then it should be a distinct target
<andrewrk>
with the windows version additionally being part of the target
<daurnimator>
andrewrk: except the whole point of it from the windows side is binary-compatibility
<andrewrk>
if that's the case then it's not a valid argument to say that epoll isn't available. it can't be both ways
<gonz_>
WSL2 will have a whole linux kernel shipped with Windows
<daurnimator>
that argument is "above my paygrade" the pragmatic solution is to fall back to select()/poll().
<gonz_>
Including all syscalls, as far as I understand
<daurnimator>
gonz_: tis.
squeek502 has quit [Ping timeout: 268 seconds]
<andrewrk>
good night
kristoff_it has quit [Remote host closed the connection]
<daurnimator>
also, in gdb, how do you call an function that can error?
nairou_ has joined #zig
<andrewrk>
daurnimator, those are global variables that are only accessible from within that function. that's all the S= struct thing is
<andrewrk>
it should be able to be called the same way
<nrdmn>
daurnimator: I replaced some integer bit fields with structs as you suggested. Feel free to test it ;) I don't have much time in the next few days unfortunately
<daurnimator>
andrewrk: `p self.seekToFn(self, pos)` failed with: `Invalid data type for function to be called.`
batok has quit [Remote host closed the connection]
<andrewrk>
interesting
nairou has quit [Ping timeout: 246 seconds]
<andrewrk>
maybe the debug info is whack
<daurnimator>
`p self.seekToFn` gave me `$3 = (enum anyerror (**)(struct builtin.StackTrace *, struct std.io.seekable_stream.SeekableStream(anyerror,anyerror) *, u64)) 0xaaaaaaaaaaaaaaaa`
<daurnimator>
which I eventually saw was undefined
<daurnimator>
but I was curious why gdb failed with "Invalid data type for function to be called."
<daurnimator>
I also haven't figured out *why* its undefined yet :P
<andrewrk>
ohh yeah you didn't give the correct number of args because of the stack trace
<andrewrk>
that's interesting, it might be worth coming up with a way to do that for debugging purposes
<daurnimator>
andrewrk: sent my WIP for this issue as #3014
<daurnimator>
andrewrk: no. its just a part of #2300 that I realised wouldn't be too hard to do as I worked on #2458
<andrewrk>
ah nice
<andrewrk>
good night
<daurnimator>
btw, CI on #3005 just passed :)
<andrewrk>
nice work
<daurnimator>
There's still a few memory leaks in there.... and an fd leak. But I think they mostly should wait for a refactor of SeekableStream.... that interface is so weird.
nairou_ has quit [Read error: Connection reset by peer]
nairou has joined #zig
<daurnimator>
(no leaks that I've added: ones that have been there all along)
<gamester>
The root file of a package contains the package's public interface. The standard library uses its public interface internally as well by importing std. For non-public things are relative imports used? Is a root file used for executables, or rare elative imports used?
wootehfoot has joined #zig
kristoff_it has quit [Ping timeout: 268 seconds]
<andrewrk>
gamester, file paths in @import are relative to the current file
<gamester>
andrewrk: Yes but how should a program (not library) be designed? Just import the file that's needed like in C/C++?
<andrewrk>
yeah that's what I would do
<andrewrk>
my app would probably be split into packages anyway
ntgg has quit [Ping timeout: 244 seconds]
Tetralux has quit [Ping timeout: 258 seconds]
kristoff_it has joined #zig
tines9 has quit [Ping timeout: 245 seconds]
tines9 has joined #zig
Tetralux has joined #zig
kristoff_it has quit [Remote host closed the connection]
<scientes>
I'm really tired of gdb and lldb not understanding variables that are in registers
<scientes>
and clang and zig working around that
<andrewrk>
scientes, dwarf has a way to specify variables that are in registers and I'm fairly certain gdb supports them
<andrewrk>
there may be more to this story than you're seeing
<scientes>
yes, good point
kristoff_it has quit [Ping timeout: 248 seconds]
<nairou>
I was actually wondering something similar to gamester's question. When looking at existing projects containing multiple sources files, and how they are organized, I see some cases where multiple files are added to the build.zig, and some cases where only the main source file containing the entry point is specified in build.zig, with the other files being used only via import. Is there much of a difference between the two? In theory, the entry point is the only
<nairou>
part of a project that isn't used by some other part of the project, so would that mean you almost never need to add more than the main file to build.zig? Or am I missing something?
<andrewrk>
nairou, start with only one file in build.zig, and only make it more complex if there's a reason to. if you point me to the specific examples I can probably explain them
<nairou>
So different from what I'm used to with C/C++, but so much nicer. I'll find that example that specified multiple files.
<euantor>
andrewrk: Quick question about os.getrandom() (again ;)), on Windows it uses RtlGenRandom which is defined as taking a `ULONG` in Windows, which is 32 bit unsigned, but we pass in a `usize` - am I right in thinking that `usize` would be 64 bit on a 64 bit platform? If so, that will need handled and I'll open another issue
kristoff_it has joined #zig
<andrewrk>
euantor, that's right - looks like I made a mistake when declaring the extern function, in std/os/windows/advapi32.zig it has the type usize but it should be ULONG
<euantor>
no problem, will open an issue and look at fixing that
<andrewrk>
I wonder if there is an NtDll api for getting random bytes
<andrewrk>
oh! I learned how to find this out
dimenus has joined #zig
<dimenus>
andrewrk: wow, you've been making a lot of progress on coroutines
<andrewrk>
dimenus, yeah! It's been going really well. I'm pleased with how the semantics are turning out
kristoff_it has quit [Ping timeout: 244 seconds]
<euantor>
There seem to be a lot of slightly different ways of getting random bytes on Windows
<euantor>
RtlGenRandom seems to be the most commonly used when looking at projects like lib sodium and the Rust rand crate
laaron has quit [Remote host closed the connection]
laaron has joined #zig
<andrewrk>
procmon shows nothing for RtlGenRandom
<andrewrk>
maybe it's actually in NtDll, not advapi32, because that's usually what the Rtl prefix means
<dimenus>
RtlGenRandom is not really named RtlGenRandom
<dimenus>
This function has no associated import library. This function is available as a resource named SystemFunction036 in Advapi32.dll.
<euantor>
Ah, I was looking for that table a couple of days back but couldn't find it. Should have thought to check the website rather than just the repository
kristoff_it has quit [Ping timeout: 268 seconds]
<fengb>
Maybe it's just the JS in me, but I've always associated "coroutine" with the actual data structure backing and "async" with syntax sugar
<andrewrk>
many people hear "coroutines" and think "user-level threads with their own stacks" (e.g. goroutines)
<andrewrk>
I believe "async functions" will be the best way to communicate how it actually works
<dimenus>
sigh, my zig build on windows is complaining about atomicRmw being an invalid builtin
<andrewrk>
dimenus, we had CryptGenRandom but improved it to RtlGenRandom
<dimenus>
even though it's clearly in the source
<dimenus>
and the std lib
<dimenus>
andrewrk: MS doesn't guarantee the availablity of RtlGenRandom
<andrewrk>
their hands are tied though, they'd break so many applications
<andrewrk>
they're never going to take it away
<andrewrk>
it's like J-walking when there are already 20 ppl in the street
<fengb>
Ah okay, I've only worked with stackless coroutines in the past. And JS variant isn't even real coroutines but maybe that shouldn't be the biggest driver
<euantor>
yeah, OpenSSL uses it, and libsodium uses it. Both of those are used quite heavily and would just break
<andrewrk>
dimenus, also the docs for CryptGenRandom says Important This API is deprecated. New and existing software should start using Cryptography Next Generation APIs. Microsoft may remove this API in future releases.
<dimenus>
yeah, which is why i mentioned the next gen one first
<andrewrk>
IMO RtlGenRandom is fine
<dimenus>
and it is simpler
<dimenus>
(RtlGenRandom I mean)
<nairou>
Noob question: Why go to the OS for a random number when you could use something like PCG and know it's crypto regardless of platform.
<fengb>
We should have zigroutines
<andrewrk>
nairou, for the seed
<andrewrk>
it's a good question, with a strong answer
<andrewrk>
fengb, *groan*
<dimenus>
do we not have CI for the msvc toolchain?
kristoff_it has joined #zig
<andrewrk>
dimenus, you can click the x or check in the commits and see all the ci jobs
<dimenus>
oh i was just confused because it's invoking bash
<scientes>
oh RLY, so MSFT gave up on their hate for GPL?
<dimenus>
and the builtin exists in both codegen.cpp and ir.cpp
<gonz_>
Disliking GPL isn't really unique to Microsoft. It wouldn't be a stretch to say that most companies don't want to deal with it.
<gonz_>
A lot of companies are pretty confused when it comes to licensing as well. When I was working at Creative Assembly we were told that GPL'd libraries aren't going to be approved for use and anything with a weak copyleft license is basically going to go straight through if it provides value.
<gonz_>
That, as far as I know, came straight from SEGA lawyers.
porky11 has joined #zig
<fengb>
Apple was fine with GPL2 and refuses to touch GPL3 with a 10 foot pole
<scientes>
a 5280 foot pole
<scientes>
hell, we wouldn't have llvm (and zig) is that wasn't the case
<dimenus>
but it builds fine on mingw64 o.0
<dimenus>
this is so strange
nairou_ has joined #zig
andersfr has joined #zig
andersfr has quit [Client Quit]
nairou has quit [Ping timeout: 268 seconds]
porky11 has quit [Ping timeout: 264 seconds]
porky11 has joined #zig
marijnfs has joined #zig
kristoff_it has joined #zig
kristoff_it has quit [Ping timeout: 258 seconds]
wootehfoot has quit [Read error: Connection reset by peer]
marijnfs has quit [Ping timeout: 252 seconds]
marijnfs has joined #zig
kristoff_it has joined #zig
nairou_ has quit [Read error: Connection reset by peer]
nairou has joined #zig
kristoff_it has quit [Ping timeout: 272 seconds]
Tetralux has joined #zig
kristoff_it has joined #zig
marijnfs has quit [Quit: WeeChat 2.4]
halosghost has quit [Quit: WeeChat 2.5]
kristoff_it has quit [Ping timeout: 248 seconds]
dimenus has quit [Quit: Leaving]
ltriant has joined #zig
nairou has quit [Quit: Quit]
nairou has joined #zig
kristoff_it has joined #zig
batok has joined #zig
kristoff_it has quit [Ping timeout: 248 seconds]
porky11 has quit [Ping timeout: 264 seconds]
<AlexMax>
What the heck does "use" do?
<AlexMax>
I think I saw some code that did use @cImport({ // etc...
<nairou>
Doesn't it dump the import contents into the global namespace?
<AlexMax>
Use is such a common word that searching it in the docs is fraught with peril
kristoff_it has joined #zig
<scientes>
AlexMax, yeah it imports all the symbols into the current namespace
kristoff_it has quit [Ping timeout: 248 seconds]
<fengb>
It’s been renamed to usingnamespace
<hryx>
AlexMax: `use` has been replaced with `usingnamespace` on master
<hryx>
oh jinx
<fengb>
Currently both work but use will be removed by 1.0
nairou has quit [Remote host closed the connection]
nairou has joined #zig
<scientes>
yeah we need to ask for the most recent glibc symbol
<scientes>
the compat functions suck
<scientes>
Unable to hash /home/shawn/git/zig-simd/build/lib/zig/libc/musl/src/signal/sigaddset.c: file system error