Looks great, thanks Chandler!

To be clear, I'm not necessarily saying that this patch is the wrong thing to do, I would just like more diligence and experimentation with alternate approaches. Thanks :-)

As I mentioned on llvmdev, I'm strongly opposed to this patch without a significant amount of analysis and diligence applied to it. I'm concerned about both memory and compile time impact. We don't just add random caches to the core IR to speed up particular clients. We care a lot about sizeof(Instruction) and its subclasses, and this adds bloat to all of them. Similarly, you don't seem interested in evaluating "tricks" to make this efficient in practice (sparse numbering), nor have you evaluated other implementation choices that will probably also work with less impact. Let's continue discussing this on llvm-dev.

Just a drive by, but I'm hugely +1 on this change, thank you for tackling it!

Patch LGTM, I'd suggest including an example like `auto updateResult = [&](){...`

nice!

How about changing it to "LLVM Compiler Infrastructure". Accepted with that tweak, thanks!

These changes look great, but I'd suggest explicitly mentioning that SNaN behavior somewhere, the relation of the instructions to the intrinsics etc. Perhaps a section before Fast Math Flags?

Here's a different way to interpret the current situation: instead of seeing the current behavior as "inconsistent", you could see it as "duplication only making sense in some cases". Realistically though, I agree that the code base is probably inconsistent as it is written by lots of people with different practices.

Personally, I don't see the harm in duplicating the comments, and they are useful when you're not using doxygen or some other tool. You're talking about the overriden method situation, but another common one is when you define a class in an anonymous namespace and then implement it later in the same file. The implementation should certainly have a doc comment on it, and if it helps to understand the overview of what the struct is doing, then it makes sense to document it in the class definition as well.

This change LGTM.

LGTM! Thanks @asb

FWIW, I agree with @majnemer's comments here: use of auto in those places doesn't aid in understanding/maintainability of the code, and it is important to mention that the manual loop with an explicitly evaluated end can make sense if the sequence is being mutated in the loop (but also we should recommend a comment to make that explicit!)

I agree we should remove it from the main page. DragonEgg should also be removed.

In D32737#760310, @sanjoy wrote:

I've only lightly read the spec, but it looks like the vector length can be controlled by writing to the ZCR_ELn registers (so, e.g. user code could make a syscall to change the vector length)? If that's accurate, I think a constant vscale is not sufficient.

In D32737#760373, @rengolin wrote:

In D32737#760289, @lattner wrote:

This is not a research project, it's a spec that is being made into hardware by a large number of large corporations and it's in development by a long number of years.

In D32737#760276, @chandlerc wrote:

In D32737#759325, @rengolin wrote:

@echristo @chandlerc @lattner @majnemer Ping.

This is a trivial change, discussed in the past, and I'm inclined to approve.

Uh, where was it discussed? It's entirely possible I missed it, but I can't find any consensus on any of the threads that we actually want to support runtime vector width in LLVM's IR.

...

For the record, I remain unconvinced that LLVM's IR should support non-constant vector widths

Thanks for improving this to allow programatic complexity! This looks overall great to me, but again, I'm not the best technical reviewer for X86 backend anymore.

I think there are two things going on here. I think that eli is right: LLVM IR global variables should always be assumable that they don't alias. This is guaranteed by C and other source languages and is important for LLVM to be able to represent. Separately though, I think it makes sense for LLVM globals to have !range metadata to specify that (though disjoint) they live in a specific address range that can fit into immediates.

This seems like a huge improvement over the status quo. Unfortunately, it's been a couple of years since I've worked on this area though, so I'd like you to get someone working on the X86 backend to look at it.

This doesn't seem like the right approach. It would be better to introduce a new top level IR concept to represent this, instead of violating the model of GlobalValue.

Ah, I didn't see it. I'll respond there.

As I mentioned on llvmdev, this approach doesn't make sense to me.

Looks reasonable, please add the standard LLVM file header blob per the coding standards.

I can't provide a technical review for this, but thank you for working on it!

This revision LGTM, making the "const char*" ctor explicit can & should be done as a second step, thanks!

You should be able to make string literals work if you use a template that takes an array of char with the size as a template parameter.

The 0 is for the length, not the actual pointer.

LGTM, might as well use nullptr instead of 0 though.

LGTM

LGTM!

Thanks Renato!

I think this approach (adding "Commenting out large blocks of code is discouraged, ...") is great!

Overall, looks great. I added some specific detailed comments above. Once you addressed those, I think this is good to merge, thank you for driving this forward Renato!

I'm +1 for this change. While this is a good suggestion for local development of code when you're working on it, we don't want large blocks of code to be checked into the source tree. This document doesn't need legislate how you do your local development :-)

I think it absolutely makes sense to encode the policy for this into the developer policy document, but think we should converge on the mailing list before discussing specific wording for it.

Please send this to llvm-dev for discussion when it converges, thanks!

LGTM!