<awygle>
so i know that c++ abis/calling conventions are pretty squishyand so it's not, like, a good idea to try to mix e.g. clang-compiled code and g++-compiled code, but how easy is it to run into that problem in practice?
<awygle>
do I have to be doing Complicated Things with -mabi or will it just happen?
<qu1j0t3>
might be a try-it-and-see kind of situation
<awygle>
yeah, im just concerned that ill try it on a toy example, itll work fine, and then in six months it breaks on mac os11 because i used an exception inside a virtual method or something
wpwrak has quit [Read error: Connection reset by peer]
wpwrak has joined ##openfpga
<qu1j0t3>
:-)))))))))))))
<qu1j0t3>
not sure you can ever prevent that completely. I hit this kind of BS porting perfectly ordinary single-compiler libraries.
<qu1j0t3>
sorry, not "porting". "building". but these days the latter ends up being the former, very often
<unixb0y>
I haven't been able to get into things lately, as I had exams @ uni
<whitequark>
awygle: it's perfectly fine to mix clang-compiled and g++-compiled code
<whitequark>
consider that clang has to interoperate with system libstdc++
<awygle>
whitequark: yeah i'm digging into it a bit more, looks like they both use the itanium c++ abi?
<whitequark>
it's more complex than that
<awygle>
but if you pass -stdlib=libc++ the name mangling seems different (although of course you also have other problems at that point)
<whitequark>
but yes, clang uses the platform ABI on every platform
<whitequark>
so it uses the same ABI as gcc on *nix and the same ABI as MSVC on Windows, unless you tell it to use the GNU ABI explicitly
wpwrak has quit [Read error: Connection reset by peer]
<whitequark>
it even can generate MSVC-compatible pdb files
wpwrak has joined ##openfpga
<awygle>
that's cool
<mithro>
The Chromium devs have been trying to move from MSVC++ to clang for like ages
<mithro>
I think they finally succeeded a month or two ago
<awygle>
yeah i saw that on reddit i think
<whitequark>
that's somewhat different though
pie__ has joined ##openfpga
<awygle>
flipping the experiment somewhat, i'm now trying to force linking .o files with incompatible ABIs but compatible name mangling and i can't make it happen. which is a good thing
digshadow has quit [Ping timeout: 260 seconds]
<awygle>
compilers are cool
<qu1j0t3>
yes i agree but perhaps for different reasons
* qu1j0t3
giggles
user10032 has quit [Ping timeout: 260 seconds]
* awygle
is creeped out
<qu1j0t3>
LOL
<qu1j0t3>
no, not like that
<qu1j0t3>
god. i don't have a "My fursona is g++" T-shirt.
<qu1j0t3>
maybe whitequark does
<azonenberg>
lol
* qu1j0t3
prepares to be b&
<azonenberg>
no whitequark would totally be clang or rustc
* qu1j0t3
really should be working
* awygle
is working and desperately craves distraction from buggy ICs
<qu1j0t3>
ha
* azonenberg
is working on bringing up GTYs on this vcu118
<azonenberg>
the xilinx 64/66b is a pain b/c its not a full line coding block
<awygle>
can a crab be a fursona? i don't see why not but it becomes kind of a misnomer
<qu1j0t3>
I am a REALLY GOOD procrastinator, but this looks bad on a CV, I suppose
<azonenberg>
it just does gearboxing
<awygle>
oh maybe i can't figure this out because i haven't eaten yet today.
<awygle>
whoops.
<pie__>
<qu1j0t3> god. i don't have a "My fursona is g++" T-shirt.
<pie__>
maybe we should make that a thing
<pie__>
but as a joke, obviously
<awygle>
ugh i should eat real food and not just Cereal Again
<pie__>
awygle, i know that feeling
wpwrak has quit [Read error: Connection reset by peer]
<pie__>
plan b is go out to eat at a place that has proper food but isnt too expensive
<awygle>
cooking is much harder when you can't walk
<pie__>
oh you can cook
wpwrak has joined ##openfpga
<whitequark>
pie__: why make it as a joke
<whitequark>
there's nothing wrong with having a fursona
<awygle>
i'm actually quite a good cook, normally, and there are ~15 great restaurants in walking distance, but both of those options are quite challenging atm
<whitequark>
also, i don't know about g++, but wyverns are cool
<pie__>
"IT JUST A JOKE GUYS"
<awygle>
that's a wyvern?
<awygle>
i thought it was a dragon
<awygle>
"a kind of dragon" FUCK YOU FIGHT ME
<qu1j0t3>
well this has been educational
<pie__>
i was trying to find a way to say this: <awygle> "a kind of dragon" FUCK YOU FIGHT ME
<qu1j0t3>
maybe if the g++ logo were a wyvern
<qu1j0t3>
but it's C++, so jabberwock seems appropriate
<awygle>
i literally laughed out loud at the dragonegg logo
<qu1j0t3>
dragonegg should really have the gcc logo on fire
<pie__>
whitequark, lol thats funny
<pie__>
also somewhat strange
<awygle>
for some reason i thought that was an adorable baby dragon wearing its shell.... i wonder what that's the logo for
<pie__>
awygle, go get breakfast son
<awygle>
pie__: it's 3pm
<awygle>
where i am
<awygle>
or is this a "universal greeting time" thing? is it always breakfast time on the internet?
<awygle>
i could get behind that tbh
specing has joined ##openfpga
<pie__>
well "i havent eaten today"
<pie__>
breakfast is the first meal
<pie__>
morning is when you wake up
<pie__>
& etc
<awygle>
fair enough, i am breaking my fast (assuming that coffee doesn't count)
<pie__>
*tomorrow is when you wake up
<pie__>
average lifespan is 27000 days. dont sleep => live forever
<pie__>
DOUBLE YOUR LIFESPAN WITH THIS ONE SIMPLE TRICK!
<azonenberg>
awygle: when i was in grad school and $wife was working night shift at walmart
<whitequark>
spiders georg is an outlier and shouldn't have been counted
<azonenberg>
we never referred to "breakfast", "lunch", or "dinner"
<azonenberg>
we just said "meal"
<azonenberg>
because there was no good term for eating (say) pancakes at 0345 right before going to sleep
<azonenberg>
or pasta at 1600 after waking up
<azonenberg>
or something equally absurd
<whitequark>
thats the normal schedule
<pie__>
i guess the problem is with matching $wife local time and $azonenberg local time
<pie__>
should have come up with a new word matric
<pie__>
matrix
<awygle>
as with many things, a problem of translation
<awygle>
when i was in college and doing these things didn't affect me i did similar things
<pie__>
im desperately trying to make a time travel tenses -> tensers (tensors) pun but its not happening
<awygle>
the difference between young me and older me is doing terrible things to my health with the full knowledge that the things are terrible
<azonenberg>
pie__: well i was in grad school working crazy hours too
<awygle>
right, a nonlinear transformation is required
<azonenberg>
awygle: i actually felt great when i was working on a week of six 28-hour days
<azonenberg>
i'm a lot less rested now forcing myself onto a 24-hour day
<pie__>
im in bsc school and i work crazy hours
<azonenberg>
if i work until i'm tired and sleep until i wake up naturally it's >24 hours
<pie__>
azonenberg, i have classes, it doesnt work out well
<awygle>
azonenberg: yeah same tbh, but when i was in school i worked a week of *math* 18 and 2/3 9-hour days
<azonenberg>
So what ends up happening is either i work until i'm tired then crash for a few hours then wake up long before i'
<azonenberg>
before i've slept well
<awygle>
with some regularity
<azonenberg>
or i go to bed early then roll around and dont fall asleep for several hours
<azonenberg>
i cant force myself to sleep when i'm not tired
<awygle>
then had a week or so of horrible nightmares while my psyche reintegrated or whatever tf was happening
<awygle>
i was productive as hell though let me tell you
<azonenberg>
my natural schedule is to work for about 18 hours then sleep for 9
<pie__>
YOU WILL BE ASSIMILATED
<pie__>
honestly idk if im a normal person with bad habits or a special person with bad habits
<pie__>
special meaning special needs wrt sleep times
<awygle>
the key to great productivity, i've found, is to abuse your life until it takes on a kind of samey grey-ness and you forget what it was like to not be working
<azonenberg>
my actual (forced) schedule these days is about 18 hours awake and 6 hours of sleep
<whitequark>
awygle: that only works for five years or so
<whitequark>
then you stop caring
<whitequark>
ask me how i know™
<pie__>
i....completely fucked up last weeks sleep. it was not good. the problem is "its only a little more...just a little more and this will work..." that usually keeps me up >_>
<awygle>
whitequark: yeah the above was extremely tongue in cheek, i have also been down the other side of that mountain
<whitequark>
i had a 500+ day github streak at one point
<pie__>
either tat or trying to supress existential dread
<pie__>
whitequark, wat.
<pie__>
oh i reda that as 500 commits in a dat
<pie__>
*read, *day
<awygle>
this thread of chat has gone from wryly amusing to legitimately depressing very quickly. i should go back to work.
<qu1j0t3>
whitequark: amazing.
<whitequark>
qu1j0t3: no i was just very depressed
<qu1j0t3>
whitequark: i see. hope that changed.
<pie__>
awygle, something something the first step to fixing something is acknowledgig it
<awygle>
pie__: if you figure out the second step, let me know
<pie__>
not sure if that actually helps with getting to step two xD
<pie__>
ahh there we go xD
<awygle>
i actually think that aphorism does more harm than good, i think for a certain kind of person it leads to beating yourself up with your failures under the banner of "acknowledging the problem"
<awygle>
s/failures/imperfections/ and i'm proving my own point lol
<whitequark>
qu1j0t3: yes. now i'm depressed just less enough to realize how deep the hole is but not enough to actually do anything about it
* qu1j0t3
frowns helplessly
<qu1j0t3>
look at me, still procrastinating
<pie__>
i promised my friend after coming home that ill wont use the comp, which means ill get some studying done and go to sleep
<pie__>
its kind of working
* pie__
goes to ask ##math some questions
digshadow has joined ##openfpga
<pie__>
qu1j0t3, it doesnt really help but what i started doing is if im procrastinating i at elast do *something* useful, even if its not what im supposed to be doing, vs just staring out of my face (at random internet crap)
<pie__>
dunno how you are with that
<awygle>
I forgot about llvm-cat, what a gift
<pie__>
meow
<rqou>
wait, so does the clang/llvm on windows stuff match msvcpNNN abi or does it still use libc++?
<whitequark>
rqou: it can do both depending on the triple
<rqou>
i thought matching msvcpNNN abi is close to impossible because every NNN version was different?
<rqou>
oh, and there's also the evil libstdc++-on-windows (via mingw) abi too
<awygle>
My cat has figured out the glowing rectangle is probably why I'm not petting him, so he politely grabs my phone and sets it down next to me
<rqou>
lol
<whitequark>
it matches several versions of the msvc abi
<whitequark>
and it can do libstdc++-on-windows too
<rqou>
i guess _somebody_ finally realized that abi disasters is one big reason against using C++
<rqou>
hmm, one thing that keeps annoying me about clang/llvm is that there seems to be no good up-to-date list of what is actually theoretically possible
<rqou>
and the compiler driver is pretty idiotic and makes things appear to be impossible when they're actually possible
<awygle>
Open Source Software Project Lacks Comprehensive Documentation - News At Eleven
<whitequark>
theoretically possible in what sense?
<rqou>
e.g. if i bypass the compiler driver and give it a giant pile of flags, this will work
<whitequark>
hm?
<whitequark>
cc1 is an implementation detail
<rqou>
what i usually find when i try to use clang as anything other than a native compiler is that it'll complain "ha ha, i can't find headers or libs"
<rqou>
whereas a gcc built as a cross compiler is hardcoded to find headers/libs in the directory "next to" the binary
<rqou>
clang somehow tries to "guess" where to find headers and basically never works
<whitequark>
clang -isysroot
<awygle>
Compiling c++ is enough to make me hate the file system
<whitequark>
will give you the same result
<rqou>
iirc something about sysroot didn't work right
<awygle>
Or at least cwd
<rqou>
hmm, i think it was because i was using gcc's multilib hack
<rqou>
yeah, i was building gcc with a patch to gcc/config/arm/t-arm-elf to change its built-in hardcoded multilib settings
<awygle>
I have a small rant about multilib as it relates to msp430 multipliers and newlib
<rqou>
of course, that's not the way clang works
<whitequark>
clang devs *hate* multilib
<rqou>
but why?
<whitequark>
because it's a shitty pile of hacks that's a huge pain in the ass to support
<rqou>
lol agree
<whitequark>
they still do
<whitequark>
but they hate it
<rqou>
unless you apply weird patches to gcc's config i guess
<whitequark>
i mean after becoming bug-compatible with MSVC's serialization of expressions in templates
<qu1j0t3>
pie__: right, good idea
<whitequark>
you can implement anything
<qu1j0t3>
pie__: in fact i've kind of stopped procrastinating which is why i'm typing on irc rightnow .... oh
<pie__>
qu1j0t3, which is why i basically went through half of overthewire this week
<pie__>
alternativelt i did overthewire instead of stuying
<pie__>
so i dunno
<rqou>
hmm on a slightly different topic: whitequark do you know why gcc people always say that you need to build a foobar-none-elf targeting gcc and can't just use foobar-linux-elf gcc with -nostdlib?
<rqou>
somehow none vs linux causes the compiler to change a lot of important things? but nobody seems to be able to explain what things
<whitequark>
things like e.g. emulation of atomics on armv5t
<pie__>
sounds like a fun time...
<whitequark>
rqou: if you put it the *other* way, that'd make more sense tbh
<whitequark>
e.g. x-none-elf binutils refuse to link a shared library
<whitequark>
which is idiotic
<rqou>
they do?
<whitequark>
they do
<rqou>
i totally thought i've done that before by accident?
<whitequark>
it's a compile-time check that literally just makes sure that your platform isn't none when you're building a .so
<rqou>
what about when devkitARM made their giant dynamically-linked flashcart access hack?
<awygle>
What's the rationale? No os to explain how to load shared libs?
<rqou>
i assume they must have told gcc that was an executable?
<whitequark>
rqou: dunno, you could load relocatables directly, or you could patch gcc
<whitequark>
erm, binutils
<whitequark>
awygle: no idea
<rqou>
the magic term you want to search for is "DLDI" btw
<rqou>
oh, they manually applied relocations
<whitequark>
manually?
<whitequark>
so they load relocatables?
<whitequark>
in ARTIQ i need shared objects because i use C++ EH
<whitequark>
and that means i need .eh_frame_hdr, which is generated by the linker
<rqou>
this worked by setting the default base address such that the address would decode as a permanently undefined opcode under both ARM and THUMB
<whitequark>
wtf
<rqou>
and then they would search for 32-bit words in this address range and assume they are all addresses that need relocating
<whitequark>
...
<pie__>
til compilers are just huge piles of hacks
<rqou>
you were restricted to 32K total size
<whitequark>
what moron came up with that
<whitequark>
pie__: well devkitARM's stuff is not in upstream compilers
<rqou>
presumably chishm came up with it
<pie__>
so uh...no inline data?
<rqou>
amazingly they had enough influence that they actually got all the chinese flashcart engineers to actually code libraries for accessing their flashcarts
<pie__>
(i think thats usually just a theoretical concern anyway? most compilers dont have data in the text section (sually)?)
<rqou>
yeah, i think if you had a constant that was not intended to be an address but also fell in that range it would get mangled
<jn__>
pie__: constant pools in .text are very common on ARM
<awygle>
Depends. Msp430 asm has in line constants.
<pie__>
but for a fixed instruction length arch that shouldnt be a problem on first thought?
<pie__>
(i guess that would be second hought actually
<rqou>
whitequark: do you also know why gcc's configure has a --with-newlib option? why does gcc need special knowledge of newlib, and what does it change inside the compiler?
<pie__>
well depends on if you mean something like mov reg, const or something
<whitequark>
rqou: include and library paths i think
<rqou>
hrm, so more hardcoding inside the compiler driver
<whitequark>
yes
<whitequark>
well, it's not quite hardcoded
<whitequark>
there's the "specs file"
<azonenberg>
yeah i am dealing with some of this absurdity in Splash
<azonenberg>
trying to create a platform where you can build on any distro, any ODS
<azonenberg>
OS*
<azonenberg>
and get the same binary
<azonenberg>
more specifically, i want to be able to create a totally heterogeneous build cluster composed of "whatever laptops and workstations are in the office today"
<azonenberg>
and get reproducible builds on that
<azonenberg>
including mixed fpga, native builds, cross-compiles, etc
* pie__
quietly pushes nixos
<rqou>
do you know what might be different between x86_64-linux-gnu-gcc and x86_64-linux-musl-gcc?
<pie__>
(key kid, want some lambdas?)
<awygle>
my msp430 toolchain makefile dumps the .spec file and rewrites it with sed before feeding it back into the compiler
<whitequark>
on codegen level? likely nothing
<awygle>
i can't even remember what what bug i'm working around by doing that
<awygle>
something about ignoring my linker script maybe
<azonenberg>
awygle: my problem is trying to make sure that it doesn't matter what lib, compiler, header, etc versions are installed, or not installed, on a given build node
<whitequark>
aaargh
<azonenberg>
So i designate one machine as the authoritative "golden image"
<azonenberg>
and all nodes build with its headers/libs instead of the locally installed ones
<rqou>
azonenberg: you do realize you're basically building your own distro, right?
<rqou>
why don't you just use musl?
<azonenberg>
and i verify hash-identical compiler versions etc
* pie__
oushes nix at azonenberg
<azonenberg>
rqou: the whole point is that it will run on whatever is already there
<rqou>
yeah? musl works on basically any kernel 3.0.0+ system
<awygle>
nix does seem pretty cool but it is _ugly as sin_ for (afaict) no good reason
<azonenberg>
the intended use case of splash is to create a build farm ad-hoc out of whoever is in the office that day
<whitequark>
which part is ugly?
<azonenberg>
if somebody goes home, jobs running on / scheduled for their workstation are rescheduled for another node
<awygle>
the nix package language or whatever it's called
<azonenberg>
if somebody updates their OS and gets new headers etc, it doesnt matter
<azonenberg>
you still build on the golden image
<rqou>
azonenberg: it's going to be so much easier with musl
<pie__>
awygle, i dont think its bad but its definitely atypical
<pie__>
alternatively, ugly vs other packaging langs? :P
<azonenberg>
If they update their compiler, and you dont have jobs for that compiler version
<azonenberg>
then they just dont get any work units
<azonenberg>
rqou: libc is the least of the problems
<azonenberg>
dependency scanning and such is tricky
<azonenberg>
also, forcing gcc to build in isolation is hard
<rqou>
i'm telling you, afaict that tarball works
<azonenberg>
i.e. telling it "do not use any libraries whatsoever from your local machine, only use stuff in the cache directory i give you that i've hashed"
<rqou>
because it's set up as a cross compiler
<pie__>
(please look at nix, its basically what you want)
<rqou>
also, it has the best filename!
<azonenberg>
pie__: i looked at it
<azonenberg>
it doesnt go far enough
<azonenberg>
this is closer to google blaze + nix
<pie__>
whats it missing?
<pie__>
(im not a guru)
<azonenberg>
i do parallel/distributed builds across potentially hundreds or thousands of cores
<azonenberg>
with guaranteed traceability to a hash of each object
<azonenberg>
caching everywhere
<azonenberg>
There are bugs and missing features, it's far from complete
<azonenberg>
for example i never empty old objects from the cache right now :p
<rqou>
i'm just going to keep repeating "just use musl and build all your own libs"
<pie__>
look at hydra maybhsve you looked at hydra (nix)
<azonenberg>
rqou: i'm not going to rebuild every lib on the os
<pie__>
*have you looked at hydra
<rqou>
it's totally manageable for openfpga
<rqou>
i've done it already
<azonenberg>
pie__: i think so
<pie__>
(i havent)
<azonenberg>
a little bit
<azonenberg>
the other thing is, cross-language cross-architecture builds
<azonenberg>
every other build system i've looked at has implcit dependencies on the host os
<azonenberg>
in splash, every build is a cross build
<azonenberg>
the host os is irrelevant
<rqou>
azonenberg: that tarball doesn't depend on the host os either
<azonenberg>
I can handle crazy dependency chains like a windows firmware update binary
<pie__>
i cant remember how nix is doing on cross builds, i know its a thing, but not sure of how much of a thing yet
<azonenberg>
that contains an fpga bitstream
<awygle>
azonenberg: the goals "no dependencies on the host os" and "use the host os" seem in conflict
<rqou>
it's a statically linked gcc targeting musl, linked with musl
<azonenberg>
which contains a risc-v c binary
<pie__>
i know a dude that builds firmware images with nix
<azonenberg>
and build all that on x86 linux
<pie__>
for routers, or something
<azonenberg>
pie__: yeah but do you have dependency scanning that many levels deep?
<pie__>
probably
<rqou>
azonenberg: just start with my "gcc-x86_64-rott.tar.xz" and use it to compile all your cross compilers?
<azonenberg>
because e.g. cmake fails horribly
<pie__>
well, ping clever on #nixos , maybe you should talk to him
<azonenberg>
when you try to build for >1 ISA at once in one build tree
<azonenberg>
awygle: I use one node's host OS to find libs etc
<azonenberg>
those are hashed and put into the central cache
<azonenberg>
every other node checks out libs and headers from the cache
<azonenberg>
rather than using its local copy
<rqou>
why do you hate musl?
<azonenberg>
So you set up that one node to be the way you want, then every other node can be running anything from plan 9 to windows
<awygle>
ah
<azonenberg>
rqou: i dont see how changing the libc solves my problem
<rqou>
use musl, build all your own libs, statically link everything, get reproducible builds that work on any distro
<azonenberg>
statically linking everything is not an option
<rqou>
why not?
<azonenberg>
i need to be able to make shlibs and static libs
<awygle>
i have been thinking about my Ideal Build System and the problem i have is that i want to be able to attest "running this command will produce n outputs with these n hashes" without having to write infinity wrapper scripts
<azonenberg>
Because i dont want multiple MB of bloat padding every single binary
<rqou>
also, musl _can_ make shlibs
<azonenberg>
awygle: that is the goal for splash
<azonenberg>
however, i do not verify hash identical OUTPUTS
<azonenberg>
i verify hash identical INPUTS, so reproducibility is modulo tool variability
<azonenberg>
e.g. if you have a randomized par seed, i cant guarantee outputs will be identical
<azonenberg>
or if your compiler adds a timestamp to the elf header
<azonenberg>
those are the kinds of things that Blaze has to patch compilers to work around
<rqou>
fortunately afaik elf doesn't have that
<rqou>
PE does though, so have fun :P
<azonenberg>
rqou: gnu build id?
<rqou>
hmm, not aware of that
<whitequark>
build id is not quite that afaik
<azonenberg>
its different if you compile the same binary twice, right?
<rqou>
PE literally has a "timestamp" field
<azonenberg>
yeah
<whitequark>
I don't think it's different
<azonenberg>
in my case, what i do is create a sha256 hash that identifies the *semantics* of a binary
<azonenberg>
not the content
<azonenberg>
so for a source file its literally the sha256 of the content
<pie__>
i saw something on llvm reproducibility modulo build ids the other day
<azonenberg>
For an object file it's the hash of the source file node, every header file node it includes
<azonenberg>
the compiler flags
<azonenberg>
the compiler itself
<azonenberg>
for an executable it's the hash of the object nodes, the lib nodes, and the linker
<balrog>
[19:15:33] <azonenberg>So i designate one machine as the authoritative "golden image"
<balrog>
[19:15:41] <azonenberg>and all nodes build with its headers/libs instead of the locally installed ones
<whitequark>
the default build id is an md5 over all elf sections and elf header
<whitequark>
you can tell the linker to use an uuid instead
<balrog>
that reminds me of the mechanism some HPC systems use where the compute nodes netboot off a controller
<whitequark>
the main issue for reproducible builds right now is debuginfo
<rqou>
azonenberg: how do you feel about the polar opposite of reproducible builds - IDA's link order watermarking?
<azonenberg>
rqou: $work trusts hexrays enough to not root our boxes with the binaries
<whitequark>
oh, someone figured out the protection mechanism in ida?
<azonenberg>
whitequark: they reorder functions in the binary each link
<azonenberg>
unique per customer
<rqou>
i thought it's always been known?
<whitequark>
that seems easy to defeat
<azonenberg>
So you can trace the source of a leak given a binary
<rqou>
there are probably others too
<pie__>
rqou, whats tahat
<pie__>
*that
<azonenberg>
balrog: i am considering pxe booting compute nodes down the road at some point, i actually was doing this on some of my servers for a while
<balrog>
whitequark: they don't care about protection as much as traceability
<azonenberg>
but the goal of splash is to NOT require a dedicated hpc cluster
<whitequark>
balrog: yes
<azonenberg>
you just run the worker daemon on everybody's laptop at the office
<whitequark>
traceability seems easy to defeat
<pie__>
oh i see
<azonenberg>
poof, build farm
<whitequark>
just relink the executable
<balrog>
but you don't know what other watermarks are in it
<whitequark>
yes, that's another story
<pie__>
watermark schwatermark
<azonenberg>
pie__: the idea is, if you ever leak ida
<azonenberg>
you're banned for life from ever buying it again
<pie__>
#YouOnlyLeakOnce
<azonenberg>
and you company may get blacklisted too
<rqou>
yeah, ida has a really unusual protection centered around watermarks and asshole sales guys rather than obfuscation/DRM
<azonenberg>
it basically makes you unemployable in infosec forever
<azonenberg>
one guy i remember leaked it on some public server
<pie__>
dam
<azonenberg>
and hexrays now has a policy that they will never sell ida to anyone employing him
<rqou>
although if the rumors are true hexrays will just not sell ida to any people they don't "trust" enough anyways
<pie__>
well, as opposed to drm, this seems to woek
<pie__>
work
<awygle>
azonenberg: can you, from an output, verify that it was built from some inputs?
<azonenberg>
awygle: no
<azonenberg>
The goal is not traceability
<azonenberg>
The goal is to allow caching
<azonenberg>
compiles take time
<azonenberg>
you should never repeat a compile if you've ever done it before
<awygle>
my goal wouldn't be traceability either, it would be "gratuitous caching"
<awygle>
or rather "all the world's a cache"
<azonenberg>
So as long as you can create a mapping from hash IDs to binaries, one way
<azonenberg>
you're good
<azonenberg>
basically every time it walks the dependency graph it generates objects lazily that it needs but doesnt have content for
<awygle>
i'd like to be able to use "apt-get install clang" if i knew that would result in getting the clang-hash i needed
<azonenberg>
so in splash what i do is specify compilers using a kind of filter expression
<awygle>
basically acknowledging that not everyone in the world will use splash
<azonenberg>
for each binary
<azonenberg>
c++/generic is the most unrestrictive
<azonenberg>
"compile on whatever the best compiler you find in the golden image is, then any other workers that have the same one"
<azonenberg>
you can also be more specific like c++/gnu/4.7.3-ubuntu1
<azonenberg>
or c++/clang/1.2
<rqou>
awygle: want to help me and work on the opposite? start with "gcc-x86_64-rott.tar.xz" and build the entire universe based on that
<rqou>
oh, and in case it wasn't obvious, "rott" = "reflections on trusting trust"
<awygle>
what i want is "i am gonna build firefox. get me this exact version of every library dependency, every compiler, every build system, every command-line tool called in a build script, ad infinitum"
<rqou>
isn't this just called a "distro?"
<azonenberg>
awygle: so, splash doesnt fetch things
<azonenberg>
it just compiles off what you have
<rqou>
oh yeah, that's good
<pie__>
ill stop spamming it but yall need nix
<rqou>
i don't get why people love to make shitty build systems that also try and fetch deps
<awygle>
"i don't care where you get it, i don't care if half of the codebase is built on clang and half on gcc, i don't care if you have to build a monkey-patched version of Forth implemented in Lua implemented in Brainfuck, but at the end of it i better get a binary that _works_, goddammit"
<azonenberg>
the main goal of splash is simply to reduce build times
<rqou>
awygle: what you want really sounds like a "distro"
<awygle>
rqou: except that distros are horrible broken things and also you ironically can't distribute them
<awygle>
rqou: what i want is "docker on demand"
<awygle>
or "unikernels but not stupid"
<rqou>
my "favorite" (/s) shitty build system that tries to auto-download deps has to be kicad's, which uses cmake to control the downloading
<azonenberg>
meanwhile, my vision for splash is a bit different
<azonenberg>
what i want is, i write some code
<pie__>
btw the problem with hashes all the way down is if you change anything thats a lot of rebuilds
<azonenberg>
i build it, auotmatically have all affected unit tests run in parallel on everyone's workstation in the lab
<rqou>
and the ex-maintainer thought of it so highly that he threw a huge hissyfit on the mailing list once because somebody copied one of his cmake scripts without proper attribution
<awygle>
i will eventually write a blog post about this, probably
<azonenberg>
pie__: that is the POINT
<azonenberg>
once you change something you have inconsistent state
<pie__>
though you could say thats actually not a problem and in fact what we want
<azonenberg>
rebuilding is the goal
<pie__>
^
<azonenberg>
if you update some header file you want to rebuild everything
<azonenberg>
anyway, so the idea is, i build it and it reruns all tests in parallel
<azonenberg>
i commit and push my changs
<pie__>
i just said that because you were like cahing and LESS BUILD TIMES
<azonenberg>
somebody else pulls the code and says "build"
<azonenberg>
they get an instant binary from the cache
<rqou>
thank goodness (i think?) that the kicad ex-maintainer got kicked out. i heard wayne is a lot saner
<awygle>
it would be great if we could rely on the interface and not the implementation but history shows otherwise
<azonenberg>
Then say my commit introduces a bug
<azonenberg>
so the dev checks out a few commits ago to see if it was introduced recently
<azonenberg>
Instant binary since the old one is still in the cache
<azonenberg>
This applies even if the "binary" is an fpga bitstream that takes hours to P&R
<awygle>
i find it interesting that in this model compile times are expensive but disk is free
<awygle>
not saying you're wrong but the tradeoff is interesting
<pie__>
yeah youll need a lot of disk
<pie__>
well, "a lot"
<awygle>
more likely to be an issue than disk is network bandwidth but i'm guessing you're picturing this as primarily LAN-based
<azonenberg>
awygle: I've billed clients as high as $150/hr
<azonenberg>
How much is a 4TB hdd?
<azonenberg>
one hour of build time saved pays for the drive
<azonenberg>
over the lifetime of th edisk
<azonenberg>
And yes, i'm picturing it LAN based
<pie__>
azonenberg, how do you bill 150$ an hour
<azonenberg>
gig-e is probably fine, 10g if available
<awygle>
i was gonna say "wow only 150$/hr?"
<pie__>
;_;
<awygle>
your skill set is niche enough i'm surprised
<pie__>
consider that network is probably faster than compiling in like...every case?
<rqou>
azonenberg is apparently one of those Highly Paid Consultants(TM)
<pie__>
^how do you do that
<awygle>
rqou: 150$/hr is not "highly paid consulting".
<azonenberg>
pie__: consider that taxes take maybe a third or more of that
<azonenberg>
and this type of work is normally paid hourly, here and there
<pie__>
azonenberg, if its less that still applies i think
<azonenberg>
its not 40 hours a week every werek
<rqou>
pie__: have a hugely inflated ego, sit around having meetings, etc. etc. :P :P :P
<pie__>
;D
<rqou>
oh wait, that's the _other_ type of Highly Paid Consultant :P :P :P
<pie__>
the cool kids get paid for actual work
<rqou>
eventually concludes by telling you that you need to buy Cisco/Oracle/Microsoft's <strike>product</strike>Enterprise Solution :P :P :P :P
<pie__>
ok but seriously though
<awygle>
pie__: you get testimonials from clients, build a network, and binary-search for the maximum acceptable pay
<awygle>
pie__: basically increase your rates until you're not turning work away anymore
<rqou>
or you sell an Enterprise Solution :P
<awygle>
rqou: same routine you just bill 20k/week instead of 400$/hr
<awygle>
networking is the most important and least fun part tbh
<rqou>
azonenberg: have you ever had to pentest an "Enterprise Solution?"
<pie__>
rqou, remember to ask questions that leave the nda unactivated
<azonenberg>
yes, they're a trainwreck :p
<rqou>
lol
<pie__>
wheeee
<pie__>
alternatively, s/wh/r/
<awygle>
why don't ICs ever just follow standards
<pie__>
the optimist in me says that its because they arent formal specs and can be misunderstood, also humans arent the most reliable of machines
<pie__>
the pseeimist in me says "ship it"
<pie__>
or vvendor lock in
<pie__>
im sorry that was a rhetorical question and that didnt register