Delete ExpandInlineAsm

[jyknight]

LLVM generally treats the contents of inline-asm as a black box -- not optimizing based on what's in the asm-string, just the constraints.

There is an exception, however: a hack, "ExpandInlineAsm", dating back to 2011 to translate bswap assembly into a bswap intrinsic.

That entire mechanism should just be deleted now.

Not only is it crufty in general, it also causes a violation of Rust's documentation, per @programmerjake on https://discourse.llvm.org/t/rfc-constant-time-coding-support/87781/41?u=jyknight:

it has a important theoretical impact on Rust, since Rust specifies that all inline asm is a blackbox and the program is allowed to overwrite inline asm with arbitrary code at runtime and that isn’t UB as long as the modified code wouldn’t be UB inside that inline asm call. LLVM optimizing based on the contents of what that inline asm was at compile time introduces UB whenever the program overwrites it at runtime.

[lenary]

I presume these optimisations matched a specific library implementation back when they were first implemented - I don't know how true that still is?

Both Arm and x86 perform this optimisation:

• Arm:

  llvm-project/llvm/lib/Target/ARM/ARMISelLowering.cpp

  Lines 20195 to 20224 in 74275a1

  	bool ARMTargetLowering::ExpandInlineAsm(CallInst *CI) const {
  	// Looking for "rev" which is V6+.
  	if (!Subtarget->hasV6Ops())
  	return false;
  	InlineAsm *IA = cast<InlineAsm>(CI->getCalledOperand());
  	StringRef AsmStr = IA->getAsmString();
  	SmallVector<StringRef, 4> AsmPieces;
  	SplitString(AsmStr, AsmPieces, ";\n");
  	switch (AsmPieces.size()) {
  	default: return false;
  	case 1:
  	AsmStr = AsmPieces[0];
  	AsmPieces.clear();
  	SplitString(AsmStr, AsmPieces, " \t,");
  	// rev $0, $1
  	if (AsmPieces.size() == 3 && AsmPieces[0] == "rev" &&
  	AsmPieces[1] == "$0" && AsmPieces[2] == "$1" &&
  	IA->getConstraintString().starts_with("=l,l")) {
  	IntegerType *Ty = dyn_cast<IntegerType>(CI->getType());
  	if (Ty && Ty->getBitWidth() == 32)
  	return IntrinsicLowering::LowerToByteSwap(CI);
  	}
  	break;
  	}
  	return false;
  	}

• X86: (difficult to link to as github doesn't like the size of X86ISelLowering.cpp, but there's a bool X86TargetLowering::ExpandInlineAsm(CallInst *CI) const { implementation.

[efriedma-quic]

I presume these optimisations matched a specific library implementation back when they were first implemented - I don't know how true that still is?

I think it was originally pattern-matching the C library.

Android deleted their inline asm in 2014, glibc deleted their inline asm in 2018, OpenBSD deleted their inline asm in 2024, I assume Apple rewrote their headers at some point, musl never used inline asm for bswap, Microsoft doesn't support inline asm. There's probably someone somewhere with some inline asm that still matches the pattern, but probably nothing significant.

[RalfJung]

If this is removed, it'd be great if the LangRef could also state that inline asm is guaranteed to be treated as an opaque blob, using only the information given in the clobbers. Rust already relies on that, apparently we forgot to check that LLVM indeed provides this guarantee.

[llvmbot]

@llvm/issue-subscribers-backend-x86

Author: James Y Knight (jyknight)

LLVM generally treats the contents of inline-asm as a black box -- not optimizing based on what's in the asm-string, just the constraints.

There is an exception, however: a hack, "ExpandInlineAsm", dating back to 2011 to translate bswap assembly into a bswap intrinsic.

That entire mechanism should just be deleted now.

Not only is it crufty in general, it also causes a violation of Rust's documentation, per @programmerjake on https://discourse.llvm.org/t/rfc-constant-time-coding-support/87781/41?u=jyknight:
> it has a important theoretical impact on Rust, since Rust specifies that all inline asm is a blackbox and the program is allowed to overwrite inline asm with arbitrary code at runtime and that isn’t UB as long as the modified code wouldn’t be UB inside that inline asm call. LLVM optimizing based on the contents of what that inline asm was at compile time introduces UB whenever the program overwrites it at runtime.

[llvmbot]

@llvm/issue-subscribers-backend-arm

Author: James Y Knight (jyknight)

LLVM generally treats the contents of inline-asm as a black box -- not optimizing based on what's in the asm-string, just the constraints.

There is an exception, however: a hack, "ExpandInlineAsm", dating back to 2011 to translate bswap assembly into a bswap intrinsic.

That entire mechanism should just be deleted now.

Not only is it crufty in general, it also causes a violation of Rust's documentation, per @programmerjake on https://discourse.llvm.org/t/rfc-constant-time-coding-support/87781/41?u=jyknight:
> it has a important theoretical impact on Rust, since Rust specifies that all inline asm is a blackbox and the program is allowed to overwrite inline asm with arbitrary code at runtime and that isn’t UB as long as the modified code wouldn’t be UB inside that inline asm call. LLVM optimizing based on the contents of what that inline asm was at compile time introduces UB whenever the program overwrites it at runtime.