[C API]: Add getters for inline assembly template string, constraints, and flags

[Benjins]

Summary

This change adds support for accessing information about inline assembly calls through the C API, enough to be able to round-trip the information. This partially addresses https://github.com/llvm/llvm-project/issues/42037 which points out gaps in the C API

Getters for each of the parameters to LLVMGetInlineAsm/InlineAsm::get have been added, such that the C API now has enough surface to clone inline assembly calls

NB: LLVMGetInlineAsm has been changed to accept a const char* for its assembly and constraint strings. This isn't strictly needed, but does make using the API a bit easier to use since the results of LLVMGetInlineAsmAsmString/LLVMGetInlineAsmConstraintString can be passed to LLVMGetInlineAsm without having to make an explicit mutable copy. As far as I understand, changing this from char* to const char* shouldn't break existing users, but if it's something we want to avoid I can leave it

This API currently only returns the raw constraint string via LLVMGetInlineAsmConstraintString: it may be prudent to also expose the parsed constraints via InlineAsm::ParseConstraints, but I wasn't sure how that should look like. This at least exposes the information for clients

This is my first patch sent to LLVM, so if there's anything I've missed please let me know

[Benjins]

Apologies for bumping this: not sure who I should assign it to for review, since I couldn't find many recent C API diffs. Just want to make sure it doesn't get lost

[bogner]

In D153185#4441069, @Benjins wrote:

Apologies for bumping this: not sure who I should assign it to for review, since I couldn't find many recent C API diffs. Just want to make sure it doesn't get lost

No need to apologize for bumping the thread - it's perfectly reasonable to ping a review every couple of weeks if nobody's responding. Sorry that I didn't get to this sooner!

I'm not necessarily the best reviewer for the C API, but this all looks fairly obviously correct. Do you need me to commit it for you?

[Benjins]

@bogner Yes, if you could commit it for me that'd be great. And thank you for reviewing this! 🙏
And I guess as a side-note: it was a bit unclear to me who would be best for reviewing C-API changes, looking at previous reviews in that area and CODE_OWNERS. I don't have any follow-up changes planned, but if there's a good person to mention on C-API changes that'd be good to know

[bogner]

In D153185#4590530, @Benjins wrote:

it was a bit unclear to me who would be best for reviewing C-API changes, looking at previous reviews in that area and CODE_OWNERS. I don't have any follow-up changes planned, but if there's a good person to mention on C-API changes that'd be good to know

Unfortunately the C API doesn't currently seem to have a particular owner, per se. It's an area that's very much driven by need at this point.

llvm/include/llvm-c/Core.h

  */
 void LLVMAppendModuleInlineAsm(LLVMModuleRef M, const char *Asm, size_t Len);
 
 /**
  * Create the specified uniqued inline asm string.
  *
  * @see InlineAsm::get()
  */
-LLVMValueRef LLVMGetInlineAsm(LLVMTypeRef Ty, char *AsmString,
-                              size_t AsmStringSize, char *Constraints,
+LLVMValueRef LLVMGetInlineAsm(LLVMTypeRef Ty, const char *AsmString,
+                              size_t AsmStringSize, const char *Constraints,
                               size_t ConstraintsSize, LLVMBool HasSideEffects,
                               LLVMBool IsAlignStack,
                               LLVMInlineAsmDialect Dialect, LLVMBool CanThrow);
 
 /**
+ * Get the template string used for an inline assembly snippet
+ *
+ */
+const char *LLVMGetInlineAsmAsmString(LLVMValueRef InlineAsmVal, size_t *Len);
+
+/**
+ * Get the raw constraint string for an inline assembly snippet
+ *
+ */
+const char *LLVMGetInlineAsmConstraintString(LLVMValueRef InlineAsmVal,
+                                             size_t *Len);
+
+/**
+ * Get the dialect used by the inline asm snippet
+ *
+ */
+LLVMInlineAsmDialect LLVMGetInlineAsmDialect(LLVMValueRef InlineAsmVal);
+
+/**
+ * Get the function type of the inline assembly snippet. The same type that
+ * was passed into LLVMGetInlineAsm originally
+ *
+ * @see LLVMGetInlineAsm
+ *
+ */
+LLVMTypeRef LLVMGetInlineAsmFunctionType(LLVMValueRef InlineAsmVal);
+
+/**
+ * Get if the inline asm snippet has side effects
+ *
+ */
+LLVMBool LLVMGetInlineAsmHasSideEffects(LLVMValueRef InlineAsmVal);
+
+/**
+ * Get if the inline asm snippet needs an aligned stack
+ *
+ */
+LLVMBool LLVMGetInlineAsmNeedsAlignedStack(LLVMValueRef InlineAsmVal);
+
+/**
+ * Get if the inline asm snippet may unwind the stack
+ *
+ */
+LLVMBool LLVMGetInlineAsmCanUnwind(LLVMValueRef InlineAsmVal);
+
+/**
  * Obtain the context to which this module is associated.
  *
  * @see Module::getContext()
  */
 LLVMContextRef LLVMGetModuleContext(LLVMModuleRef M);
 
 /** Deprecated: Use LLVMGetTypeByName2 instead. */
 LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name);

llvm/lib/IR/Core.cpp

 }
 
 const char *LLVMGetModuleInlineAsm(LLVMModuleRef M, size_t *Len) {
   auto &Str = unwrap(M)->getModuleInlineAsm();
   *Len = Str.length();
   return Str.c_str();
 }
 
-LLVMValueRef LLVMGetInlineAsm(LLVMTypeRef Ty, char *AsmString,
-                              size_t AsmStringSize, char *Constraints,
+LLVMValueRef LLVMGetInlineAsm(LLVMTypeRef Ty, const char *AsmString,
+                              size_t AsmStringSize, const char *Constraints,
                               size_t ConstraintsSize, LLVMBool HasSideEffects,
                               LLVMBool IsAlignStack,
                               LLVMInlineAsmDialect Dialect, LLVMBool CanThrow) {
   InlineAsm::AsmDialect AD;
   switch (Dialect) {
   case LLVMInlineAsmDialectATT:
     AD = InlineAsm::AD_ATT;
     break;
   case LLVMInlineAsmDialectIntel:
     AD = InlineAsm::AD_Intel;
     break;
   }
   return wrap(InlineAsm::get(unwrap<FunctionType>(Ty),
                              StringRef(AsmString, AsmStringSize),
                              StringRef(Constraints, ConstraintsSize),
                              HasSideEffects, IsAlignStack, AD, CanThrow));
 }
 
+const char *LLVMGetInlineAsmAsmString(LLVMValueRef InlineAsmVal, size_t *Len) {
+
+  Value *Val = unwrap<Value>(InlineAsmVal);
+  const std::string &AsmString = cast<InlineAsm>(Val)->getAsmString();
+
+  *Len = AsmString.length();
+  return AsmString.c_str();
+}
+
+const char *LLVMGetInlineAsmConstraintString(LLVMValueRef InlineAsmVal,
+                                             size_t *Len) {
+  Value *Val = unwrap<Value>(InlineAsmVal);
+  const std::string &ConstraintString =
+      cast<InlineAsm>(Val)->getConstraintString();
+
+  *Len = ConstraintString.length();
+  return ConstraintString.c_str();
+}
+
+LLVMInlineAsmDialect LLVMGetInlineAsmDialect(LLVMValueRef InlineAsmVal) {
+
+  Value *Val = unwrap<Value>(InlineAsmVal);
+  InlineAsm::AsmDialect Dialect = cast<InlineAsm>(Val)->getDialect();
+
+  switch (Dialect) {
+  case InlineAsm::AD_ATT:
+    return LLVMInlineAsmDialectATT;
+  case InlineAsm::AD_Intel:
+    return LLVMInlineAsmDialectIntel;
+  }
+
+  llvm_unreachable("Unrecognized inline assembly dialect");
+  return LLVMInlineAsmDialectATT;
+}
+
+LLVMTypeRef LLVMGetInlineAsmFunctionType(LLVMValueRef InlineAsmVal) {
+  Value *Val = unwrap<Value>(InlineAsmVal);
+  return (LLVMTypeRef)cast<InlineAsm>(Val)->getFunctionType();
+}
+
+LLVMBool LLVMGetInlineAsmHasSideEffects(LLVMValueRef InlineAsmVal) {
+  Value *Val = unwrap<Value>(InlineAsmVal);
+  return cast<InlineAsm>(Val)->hasSideEffects();
+}
+
+LLVMBool LLVMGetInlineAsmNeedsAlignedStack(LLVMValueRef InlineAsmVal) {
+  Value *Val = unwrap<Value>(InlineAsmVal);
+  return cast<InlineAsm>(Val)->isAlignStack();
+}
+
+LLVMBool LLVMGetInlineAsmCanUnwind(LLVMValueRef InlineAsmVal) {
+  Value *Val = unwrap<Value>(InlineAsmVal);
+  return cast<InlineAsm>(Val)->canThrow();
+}
+
 /*--.. Operations on module contexts ......................................--*/
 LLVMContextRef LLVMGetModuleContext(LLVMModuleRef M) {
   return wrap(&unwrap(M)->getContext());
 }
 
 
 /*===-- Operations on types -----------------------------------------------===*/
 

llvm/test/Bindings/llvm-c/echo.ll

define i32 @musttailcall() {
   ret i32 %1
 }
 
 define i32 @notailcall() {
   %1 = notail call i32 @call()
   ret i32 %1
 }
 
+define i32 @call_inline_asm(i32 %0) {
+  ; Test Intel syntax
+  %2 = tail call i32 asm sideeffect inteldialect "mov $0, $1", "=r,r,~{dirflag},~{fpsr},~{flags}"(i32 %0)
+  %3 = tail call i32 asm sideeffect inteldialect "lea $0, [$1+$2]", "=r,r,r,~{dirflag},~{fpsr},~{flags}"(i32 %0, i32 %2)
+  %4 = tail call i32 asm inteldialect "mov $0, $1", "=r,r,~{dirflag},~{fpsr},~{flags}"(i32 %3)
+  %5 = tail call i32 asm inteldialect unwind "mov $0, $1", "=r,r,~{dirflag},~{fpsr},~{flags}"(i32 %4)
+  %6 = tail call i32 asm alignstack inteldialect "mov $0, $1", "=r,r,~{dirflag},~{fpsr},~{flags}"(i32 %5)
+
+  ; Test AT&T syntax
+  %7 = tail call i32 asm "mov $1, $0", "=r,r,~{dirflag},~{fpsr},~{flags}"(i32 %6)
+  %8 = tail call i32 asm sideeffect "mov $1, $0", "=r,r,~{dirflag},~{fpsr},~{flags}"(i32 %7)
+  %9 = tail call i32 asm alignstack "mov $1, $0", "=r,r,~{dirflag},~{fpsr},~{flags}"(i32 %8)
+  %10 = tail call i32 asm alignstack unwind "mov $1, $0", "=r,r,~{dirflag},~{fpsr},~{flags}"(i32 %9)
+  ret i32 %10
+}
+
 define i32 @cond(i32 %a, i32 %b) {
   br label %br
 unreachable:
   unreachable
 br:
   %1 = icmp eq i32 %a, %b
   br i1 %1, label %next0, label %unreachable
 next0:

llvm/tools/llvm-c-test/echo.cpp

switch(Op) {
     }
     default:
       fprintf(stderr, "%d is not a supported opcode for constant expressions\n",
               Op);
       exit(-1);
   }
 }
 
+static LLVMValueRef clone_inline_asm(LLVMValueRef Asm, LLVMModuleRef M) {
+
+  if (!LLVMIsAInlineAsm(Asm))
+      report_fatal_error("Expected inline assembly");
+
+  size_t AsmStringSize = 0;
+  const char *AsmString = LLVMGetInlineAsmAsmString(Asm, &AsmStringSize);
+
+  size_t ConstraintStringSize = 0;
+  const char *ConstraintString =
+      LLVMGetInlineAsmConstraintString(Asm, &ConstraintStringSize);
+
+  LLVMInlineAsmDialect AsmDialect = LLVMGetInlineAsmDialect(Asm);
+
+  LLVMTypeRef AsmFunctionType = LLVMGetInlineAsmFunctionType(Asm);
+
+  LLVMBool HasSideEffects = LLVMGetInlineAsmHasSideEffects(Asm);
+  LLVMBool NeedsAlignStack = LLVMGetInlineAsmNeedsAlignedStack(Asm);
+  LLVMBool CanUnwind = LLVMGetInlineAsmCanUnwind(Asm);
+
+  return LLVMGetInlineAsm(AsmFunctionType, AsmString, AsmStringSize,
+                          ConstraintString, ConstraintStringSize,
+                          HasSideEffects, NeedsAlignStack, AsmDialect,
+                          CanUnwind);
+}
+
 struct FunCloner {
   LLVMValueRef Fun;
   LLVMModuleRef M;
 
   ValueMap VMap;
   BasicBlockMap BBMap;
 
   FunCloner(LLVMValueRef Src, LLVMValueRef Dst): Fun(Dst),
LLVMValueRef CloneValue(LLVMValueRef Src) {
     if (LLVMIsAConstant(Src))
       return clone_constant(Src, M);
 
     // Function argument should always be in the map already.
     auto i = VMap.find(Src);
     if (i != VMap.end())
       return i->second;
 
+    // Inline assembly is a Value, but not an Instruction
+    if (LLVMIsAInlineAsm(Src))
+      return clone_inline_asm(Src, M);
+
     if (!LLVMIsAInstruction(Src))
       report_fatal_error("Expected an instruction");
 
     auto Ctx = LLVMGetModuleContext(M);
     auto Builder = LLVMCreateBuilderInContext(Ctx);
     auto BB = DeclareBB(LLVMGetInstructionParent(Src));
     LLVMPositionBuilderAtEnd(Builder, BB);
     auto Dst = CloneInstruction(Src, Builder);