[llvm-diff] Also diff alloca's allocated type and alignment

[YanWQ-monad]

Currently, the function

llvm-project/llvm/tools/llvm-diff/lib/DifferenceEngine.cpp

Lines 364 to 369 in 8c33044

	// If AllowAssumptions is enabled, whenever we encounter a pair of values
	// that we cannot prove to be equivalent, we assume equivalence and store that
	// assumption to be checked later in BlockDiffCandidates.
	bool diff(const Instruction *L, const Instruction *R, bool Complain,
	bool TryUnify, bool AllowAssumptions) {
	// FIXME: metadata (if Complain is set)

doesn't handle the non-operand data of AllocaInst. For example,

alloca i64, align 1
alloca i32, align 1

would be considered the same instruction.

---

Under some special circumstances, that would make llvm-diff crash:

define ptr @func() {
  %1 = alloca i64, align 1
  %2 = alloca i32, align 1
  %3 = alloca i8, align 1
  ret ptr %2
}

define ptr @func() {
  %1 = alloca i64, align 1
  %2 = alloca i32, align 1
  ret ptr %2
}

$ ./build/bin/llvm-diff lhs.ll rhs.ll
in function func:
  in block %0 / %0:
    in instruction   ret ptr %2 /   ret ptr %2:
      operands %2 and %2 differ
llvm-diff: path/llvm/tools/llvm-diff/lib/DifferenceEngine.cpp:268: void (anonymous namespace)::FunctionDifferenceEngine::unify(const Instruction *, const Instruction *): Assertion `!Result && "structural differences second time around?"' failed.
fish: Job 1, './build/bin/llvm-diff lhs.ll r…' terminated by signal SIGABRT (Abort)

[github-actions]

Thank you for submitting a Pull Request (PR) to the LLVM Project!

This PR will be automatically labeled and the relevant teams will be
notified.

If you wish to, you can add reviewers by using the "Reviewers" section on this page.

If this is not working for you, it is probably because you do not have write
permissions for the repository. In which case you can instead tag reviewers by
name in a comment by using @ followed by their GitHub username.

If you have received no comments on your PR for a week, you can request a review
by "ping"ing the PR by adding a comment “Ping”. The common courtesy "ping" rate
is once a week. Please remember that you are asking for valuable time from other developers.

If you have further questions, they may be answered by the LLVM GitHub User Guide.

You can also ask questions in a comment on this PR, on the LLVM Discord or on the forums.

[nikic]

This looks correct, but I think it only scratches the surface of the problem? The same problem exists for load types, GEP types, and basically everything else that is checked by hasSameSpecialState(). Can we use that instead?

[YanWQ-monad]

Adding test case

[YanWQ-monad]

When I was adding the test cases, I found another weird thing: same struct in different .lls seems to be considered different types, although in the same LLVMContext. This can also be seen from the failed tests.

I'm gonna investigate this issue tomorrow, because I have to go sleep now - I have lessons tomorrow.

[YanWQ-monad]

After investigation, I found that two struct declarations always have different Type pointers, despite they have the same element.

The related code might be

llvm-project/llvm/lib/IR/Type.cpp

Lines 513 to 529 in ffe4181

	StructType *StructType::create(LLVMContext &Context, StringRef Name) {
	StructType *ST = new (Context.pImpl->Alloc) StructType(Context);
	if (!Name.empty())
	ST->setName(Name);
	return ST;
	}
	StructType *StructType::get(LLVMContext &Context, bool isPacked) {
	return get(Context, std::nullopt, isPacked);
	}
	StructType *StructType::create(LLVMContext &Context, ArrayRef<Type*> Elements,
	StringRef Name, bool isPacked) {
	StructType *ST = create(Context, Name);
	ST->setBody(Elements, isPacked);
	return ST;
	}

We can infer that different calls to StructType::create will always create different Type*s, which cause llvm-diff (of the current PR) to consider same struct as different types.

So, should we modify the code in Type.cpp to make it generate same pointer for structure with same element, or handle this situation in llvm-diff in a special way so that it won't report the differences?

---

Reproduction (llvm-diff of the current PR):

%struct = type { i8 }

define void @gep(ptr %addr) {
  %1 = getelementptr %struct, ptr %addr, i32 0
  ret void
}

Command: llvm-diff a.ll a.ll, results in

in function gep:
  in block %0 / %0:
    >   %1 = getelementptr %struct.0, ptr %addr, i32 0
    <   %1 = getelementptr %struct, ptr %addr, i32 0

[YanWQ-monad]

TL;DR: added a function isSameType(Type *TL, Type *TR) to check whether TL on the left side and TR on the right side are structural equivalence. It recursively compares the inner elements of StructType, VectorType, and ArrayType, and caches the result in IsSameTypes.

In diff(Instruction *L, Instruction *R, .....) function, for type-related instructions (load, gep, alloca), check their type equivalence using isSameType; and for other instructions, it calls hasSameSpecialState to compare other non-operand data.

[YanWQ-monad]

ping?

[YanWQ-monad]

ping @nikic