C API: functions to get mask of a ShuffleVector

[cdisselkoen]

Summary

This commit fixes a regression (from LLVM 10 to LLVM 11 RC3) in the LLVM C API.

Previously, commit 1ee6ec2bf removed the mask operand from the
ShuffleVector instruction, storing the mask data separately in the instruction
instead; this reduced the number of operands of ShuffleVector from 3 to 2.
AFAICT, this change unintentionally caused a regression in the LLVM C API.
Specifically, it is no longer possible to get the mask of a ShuffleVector
instruction through the C API. This patch introduces new functions which
together allow a C API user to get the mask of a ShuffleVector instruction,
restoring the functionality which was previously available through
LLVMGetOperand().

This patch also adds tests for this change to the llvm-c-test executable, which
involved adding support for InsertElement, ExtractElement, and ShuffleVector
itself (as well as constant vectors) to echo.cpp. Previously, vector
operations weren't tested at all in echo.ll.

I also fixed some typos in comments and help-text nearby these changes, which I
happened to spot while developing this patch. Since the typo fixes are technically
unrelated other than being in the same files, I'm happy to take them out if
you'd rather they not be included in the patch.

I'm not sure who the appropriate reviewer / code owner is for this diff,
so I'm taking a guess and adding @arsenm since they reviewed D67132 which
also touched the C API. If this is wrong, feel free to let me know.

[cdisselkoen]

some clang-tidy suggestions

[cdisselkoen]

whoops that isn't how arcanist works

[efriedma]

These changes all make sense, I think.

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

812

Any particular reason you aren't using a SmallVector here?

[cdisselkoen]

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

812

I guess it was just because conceptually in my mind this is C code and not C++ code (it consumes the C API). Happy to use SmallVector if you prefer

[cdisselkoen]

Use SmallVector rather than array

[cdisselkoen]

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

812

Updated to use SmallVector

[efriedma]

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

812

Did you mean to use push_back?

[cdisselkoen]

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

812

Uh, yes I did, whoops. Weird, I thought I ran tests locally but I must have not done that

[cdisselkoen]

fix: use push_back

[efriedma]

LGTM. Thanks for taking the time to improve llvm-c-test along with this patch.

I'll commit the patch for you; how do you want to be credited in the "author" line?

[cdisselkoen]

This is my first contribution to LLVM, I'm not sure what the typical practice is, but if it's a normal Git commit, then Craig Disselkoen <[e-mail]> is fine. Thanks for the review!

Also, again I'm new here, but since this fixes a regression, if there's any possibility of landing this on the 11.x branch in addition to master, I'd appreciate it. I know it's probably too late for 11.0.0.

[hans]

In D88190#2294181, @cdisselkoen wrote:

This is my first contribution to LLVM, I'm not sure what the typical practice is, but if it's a normal Git commit, then Craig Disselkoen <[e-mail]> is fine. Thanks for the review!

Also, again I'm new here, but since this fixes a regression, if there's any possibility of landing this on the 11.x branch in addition to master, I'd appreciate it. I know it's probably too late for 11.0.0.

We try not to change the C API in .1 releases, so it either needs to wait for 12, or go into 11.0.0. Since we'll need to do another release candidate for 11, I'd be okay with merging this since it seems pretty safe (assuming Eli agrees).

[efriedma]

@hans I think this is okay to land in 11.0.

[CodaFi]

llvm/lib/IR/Core.cpp

3966

Can we add a getter for this instead? We should avoid magic numbers in the C API - it doesn’t tend to stay in sync with the C++ otherwise

[cdisselkoen]

llvm/lib/IR/Core.cpp

3966

Actually, as I was looking into this, I realized that we can just write const int LLVMUndefMaskElem = UndefMaskElem; here and it works. UndefMaskElem is just a constant available in the Instructions.h header.

Since this has already landed on master, should I open a new diff with this change? Or still modify this diff?

[CodaFi]

llvm/lib/IR/Core.cpp

3966

To both questions

1. Please don’t mix C and C++ headers. It may happen to work for you locally now, but there’s no guarantee Instructions.h won’t break everybody in the future. Please make an explicit getter.

2. You should submit another revision for review here.

[cdisselkoen]

llvm/lib/IR/Core.cpp

3966

Please don't mix C and C++ headers ... there's no guarantee Instructions.h won't break everybody in the future

Apologies for my lack of knowledge (C++ is not my primary language), but could you explain what the concern is here? Instructions.h (and other C++ headers) are already included in Core.cpp, so the line above works without including any new headers. And we wouldn't have to change Core.h which is the actual C header -- in that header the current diff just has a declaration extern const int LLVMUndefMaskElem;, and we could keep that declaration the same.

[CodaFi]

llvm/lib/IR/Core.cpp

3966

The C bindings are meant to present a pure C view of a C++ API. It is only natural then that we *implement* these bindings in C++, but we express the interface to those bindings in C. But despite their names these languages are strictly incompatible. If I were to build a C-only translation unit with a C-only compiler that imported Instructions.h, I would not succeed. There are clients like the OCaml bindings, go bindings, and my own set of Swift bindings that would also break upon trying to import a C++ header in a C context.

[CodaFi]

llvm/lib/IR/Core.cpp

3966

The C API also has additional stability commitments that the C++ API roundly does not make. In order to carry out those guarantees, we make heavy use of abstraction. Notice that every API here that takes LLVM objects takes them in memory through bare typedefs of opaque pointers. Here, we have an implementation detail of the C++ API leaking to clients through this constant. If tomorrow somebody were to add support for a host that used some other value for this constant, we would be hosed by the lack of abstraction here.

[cdisselkoen]

llvm/lib/IR/Core.cpp

3966

The C bindings are meant to present a pure C view of a C++ API ... If I were to build a C-only translation unit with a C-only compiler that imported Instructions.h, I would not succeed. ... OCaml bindings, go bindings, and my own set of Swift bindings would also break

Sure, totally understood on this. (I also maintain these Rust bindings for LLVM which depend on the C API.) What I don't understand is what about this change would require C consumers to import Instructions.h. Is that somehow implied by the use of extern const int in the C header? The code seems to compile for me (and pass tests) without importing Instructions.h in the C header - we're only referencing Instructions.h in the C++ implementation of the bindings.

If tomorrow somebody were to add support for a host that used some other value for this constant

Is Core.cpp target-specific? I don't understand how different hosts could have different values for this constant. Again, I'm not the most familiar with C++ so this is probably me misunderstanding something.

[cdisselkoen]

Reopened per comments from @CodaFi

[cdisselkoen]

Use UndefMaskElem instead of magic-number constant

llvm/lib/IR/Core.cpp

3966

In case it makes the discussion more clear, I've updated the diff with my proposed change

[CodaFi]

llvm/lib/IR/Core.cpp

3966

You do *not* need additional includes in Core.h to write a getter.

unsigned LLVMGetUndefMaskElem(void);

[CodaFi]

llvm/lib/IR/Core.cpp

3966

Apologies, that should be a signed integer.

Regardless, this version of affairs will break existing clients. The constant initializer here is a constexpr declaration, which is not a construct in C. The existing LLVM tests use C++ translation units which can mask the failure here. That’s why I’m pushing for a getter.

[CodaFi]

llvm/lib/IR/Core.cpp

3966

I'm going to submit a revision that corrects this and tag you as a reviewer. I find it easier to read code than talk about it.

[CodaFi]

This has already been committed, it should remain closed.

[cdisselkoen]

llvm/lib/IR/Core.cpp

3966

You do *not* need additional includes in Core.h to write a getter.

Absolutely agreed. But you don't need additional includes in Core.h to have an extern const int declaration, either?

The constant initializer here is a constexpr declaration, which is not a construct in C

Again, I'm sure you're right, but just for my own edification - I'm confused why a constexpr declaration in the _C++ implementation_ is different than, say, a getter implemented in C++? Neither of those are valid C; we can't compile Core.cpp in pure C either way. There wouldn't be any constexpr in Core.h -- just an extern const declaration -- so wouldn't the linker do the right thing? And wouldn't any code including Core.h remain valid C, since there is no constexpr there?

I'm not arguing that a getter is bad, and I'm happy to make it a getter. I'm just trying to understand the problem better here. Apologies as I know my lack of C++ knowledge is showing.

[hans]

For those following along, the follow-up patch was https://reviews.llvm.org/D88367

In D88190#2296199, @efriedma wrote:

@hans I think this is okay to land in 11.0.

Thanks. I've pushed this and the follow-up to 11.x as 9e367bd69b0d2523237e204b43301e59a5badb29 and 293924973057e33fcc63521f582bb9fd41e60cc4, respectively.

llvm/include/llvm-c/Core.h

void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
                  LLVMBasicBlockRef Dest);
 
 /* Add a destination to the indirectbr instruction */
 void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest);
 
 /* Get the number of clauses on the landingpad instruction */
 unsigned LLVMGetNumClauses(LLVMValueRef LandingPad);
 
-/* Get the value of the clause at idnex Idx on the landingpad instruction */
+/* Get the value of the clause at index Idx on the landingpad instruction */
 LLVMValueRef LLVMGetClause(LLVMValueRef LandingPad, unsigned Idx);
 
 /* Add a catch or filter clause to the landingpad instruction */
 void LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal);
 
 /* Get the 'cleanup' flag in the landingpad instruction */
 LLVMBool LLVMIsCleanup(LLVMValueRef LandingPad);
 
LLVMValueRef LLVMBuildAtomicRMW(LLVMBuilderRef B, LLVMAtomicRMWBinOp op,
                                 LLVMAtomicOrdering ordering,
                                 LLVMBool singleThread);
 LLVMValueRef LLVMBuildAtomicCmpXchg(LLVMBuilderRef B, LLVMValueRef Ptr,
                                     LLVMValueRef Cmp, LLVMValueRef New,
                                     LLVMAtomicOrdering SuccessOrdering,
                                     LLVMAtomicOrdering FailureOrdering,
                                     LLVMBool SingleThread);
 
+/**
+ * Get the number of elements in the mask of a ShuffleVector instruction.
+ */
+unsigned LLVMGetNumMaskElements(LLVMValueRef ShuffleVectorInst);
+
+/**
+ * Get the mask value at position Elt in the mask of a ShuffleVector
+ * instruction. Return LLVMUndefMaskElem if the mask value is undef at that
+ * position.
+ */
+int LLVMGetMaskValue(LLVMValueRef ShuffleVectorInst, unsigned Elt);
+extern const int LLVMUndefMaskElem;
+
 LLVMBool LLVMIsAtomicSingleThread(LLVMValueRef AtomicInst);
 void LLVMSetAtomicSingleThread(LLVMValueRef AtomicInst, LLVMBool SingleThread);
 
 LLVMAtomicOrdering LLVMGetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst);
 void LLVMSetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst,
                                    LLVMAtomicOrdering Ordering);
 LLVMAtomicOrdering LLVMGetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst);
 void LLVMSetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst,

llvm/lib/IR/Core.cpp

LLVMValueRef LLVMBuildAtomicCmpXchg(LLVMBuilderRef B, LLVMValueRef Ptr,
                                     LLVMBool singleThread) {
 
   return wrap(unwrap(B)->CreateAtomicCmpXchg(unwrap(Ptr), unwrap(Cmp),
                 unwrap(New), mapFromLLVMOrdering(SuccessOrdering),
                 mapFromLLVMOrdering(FailureOrdering),
                 singleThread ? SyncScope::SingleThread : SyncScope::System));
 }
 
+unsigned LLVMGetNumMaskElements(LLVMValueRef SVInst) {
+  Value *P = unwrap<Value>(SVInst);
+  ShuffleVectorInst *I = cast<ShuffleVectorInst>(P);
+  return I->getShuffleMask().size();
+}
+
+int LLVMGetMaskValue(LLVMValueRef SVInst, unsigned Elt) {
+  Value *P = unwrap<Value>(SVInst);
+  ShuffleVectorInst *I = cast<ShuffleVectorInst>(P);
+  return I->getMaskValue(Elt);
+}
+const int LLVMUndefMaskElem =
+    -1; // not actually accessible as ShuffleVectorInst::UndefMaskElem, so we
+        // hardcode it here
 
 LLVMBool LLVMIsAtomicSingleThread(LLVMValueRef AtomicInst) {
   Value *P = unwrap<Value>(AtomicInst);
 
   if (AtomicRMWInst *I = dyn_cast<AtomicRMWInst>(P))
     return I->getSyncScopeID() == SyncScope::SingleThread;
   return cast<AtomicCmpXchgInst>(P)->getSyncScopeID() ==
              SyncScope::SingleThread;

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

define void @memops(i8* %ptr) {
   %e = atomicrmw add i8* %ptr, i8 0 monotonic
   %f = atomicrmw volatile xchg i8* %ptr, i8 0 acq_rel
   %g = cmpxchg i8* %ptr, i8 1, i8 2 seq_cst acquire
   %h = cmpxchg weak i8* %ptr, i8 1, i8 2 seq_cst acquire
   %i = cmpxchg volatile i8* %ptr, i8 1, i8 2 monotonic monotonic
   ret void
 }
 
+define i32 @vectorops(i32, i32) {
+  %a = insertelement <4 x i32> undef, i32 %0, i32 0
+  %b = insertelement <4 x i32> %a, i32 %1, i32 2
+  %c = shufflevector <4 x i32> %b, <4 x i32> undef, <4 x i32> zeroinitializer
+  %d = shufflevector <4 x i32> %c, <4 x i32> %b, <4 x i32> <i32 1, i32 2, i32 3, i32 0>
+  %e = add <4 x i32> %d, %a
+  %f = mul <4 x i32> %e, %b
+  %g = xor <4 x i32> %f, %d
+  %h = or <4 x i32> %f, %e
+  %i = lshr <4 x i32> %h, <i32 2, i32 2, i32 2, i32 2>
+  %j = shl <4 x i32> %i, <i32 2, i32 3, i32 4, i32 5>
+  %k = shufflevector <4 x i32> %j, <4 x i32> %i, <4 x i32> <i32 2, i32 3, i32 undef, i32 undef>
+  %m = shufflevector <4 x i32> %k, <4 x i32> undef, <1 x i32> <i32 1>
+  %n = shufflevector <4 x i32> %j, <4 x i32> undef, <8 x i32> <i32 0, i32 0, i32 1, i32 2, i32 undef, i32 3, i32 undef, i32 undef>
+  %p = extractelement <8 x i32> %n, i32 5
+  ret i32 %p
+}
+
 declare void @personalityFn()
 
 define void @exn() personality void ()* @personalityFn {
 entry:
   invoke void @decl()
           to label %via.cleanup unwind label %exn.dispatch
 via.cleanup:
   invoke void @decl()

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

 
 using namespace llvm;
 
 // Provide DenseMapInfo for C API opaque types.
 template<typename T>
 struct CAPIDenseMap {};
 
 // The default DenseMapInfo require to know about pointer alignment.
-// Because the C API uses opaques pointer types, their alignment is unknown.
+// Because the C API uses opaque pointer types, their alignment is unknown.
 // As a result, we need to roll out our own implementation.
 template<typename T>
 struct CAPIDenseMap<T*> {
   struct CAPIDenseMapInfo {
     static inline T* getEmptyKey() {
       uintptr_t Val = static_cast<uintptr_t>(-1);
       return reinterpret_cast<T*>(Val);
     }
if (LLVMIsAConstantArray(Cst)) {
     LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
     unsigned EltCount = LLVMGetArrayLength(Ty);
     SmallVector<LLVMValueRef, 8> Elts;
     for (unsigned i = 0; i < EltCount; i++)
       Elts.push_back(clone_constant(LLVMGetOperand(Cst, i), M));
     return LLVMConstArray(LLVMGetElementType(Ty), Elts.data(), EltCount);
   }
 
-  // Try contant data array
+  // Try constant data array
   if (LLVMIsAConstantDataArray(Cst)) {
     check_value_kind(Cst, LLVMConstantDataArrayValueKind);
     LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
     unsigned EltCount = LLVMGetArrayLength(Ty);
     SmallVector<LLVMValueRef, 8> Elts;
     for (unsigned i = 0; i < EltCount; i++)
       Elts.push_back(clone_constant(LLVMGetElementAsConstant(Cst, i), M));
     return LLVMConstArray(LLVMGetElementType(Ty), Elts.data(), EltCount);
static LLVMValueRef clone_constant_impl(LLVMValueRef Cst, LLVMModuleRef M) {
   }
 
   // Try float literal
   if (LLVMIsAConstantFP(Cst)) {
     check_value_kind(Cst, LLVMConstantFPValueKind);
     report_fatal_error("ConstantFP is not supported");
   }
 
-  // This kind of constant is not supported
+  // Try ConstantVector
+  if (LLVMIsAConstantVector(Cst)) {
+    check_value_kind(Cst, LLVMConstantVectorValueKind);
+    LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
+    unsigned EltCount = LLVMGetVectorSize(Ty);
+    SmallVector<LLVMValueRef, 8> Elts;
+    for (unsigned i = 0; i < EltCount; i++)
+      Elts.push_back(clone_constant(LLVMGetOperand(Cst, i), M));
+    return LLVMConstVector(Elts.data(), EltCount);
+  }
+
+  // Try ConstantDataVector
+  if (LLVMIsAConstantDataVector(Cst)) {
+    check_value_kind(Cst, LLVMConstantDataVectorValueKind);
+    LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
+    unsigned EltCount = LLVMGetVectorSize(Ty);
+    SmallVector<LLVMValueRef, 8> Elts;
+    for (unsigned i = 0; i < EltCount; i++)
+      Elts.push_back(clone_constant(LLVMGetElementAsConstant(Cst, i), M));
+    return LLVMConstVector(Elts.data(), EltCount);
+  }
+
+  // At this point, if it's not a constant expression, it's a kind of constant
+  // which is not supported
   if (!LLVMIsAConstantExpr(Cst))
-    report_fatal_error("Expected a constant expression");
+    report_fatal_error("Unsupported constant kind");
 
   // At this point, it must be a constant expression
   check_value_kind(Cst, LLVMConstantExprValueKind);
 
   LLVMOpcode Op = LLVMGetConstOpcode(Cst);
   switch(Op) {
     case LLVMBitCast:
       return LLVMConstBitCast(clone_constant(LLVMGetOperand(Cst, 0), M),
                               TypeCloner(M).Clone(Cst));
     default:
-      fprintf(stderr, "%d is not a supported opcode\n", Op);
+      fprintf(stderr, "%d is not a supported opcode for constant expressions\n",
+              Op);
       exit(-1);
   }
 }
 
 struct FunCloner {
   LLVMValueRef Fun;
   LLVMModuleRef M;
 
LLVMValueRef CloneInstruction(LLVMValueRef Src, LLVMBuilderRef Builder) {
     size_t NameLen;
     const char *Name = LLVMGetValueName2(Src, &NameLen);
 
     // Check if this is something we already computed.
     {
       auto i = VMap.find(Src);
       if (i != VMap.end()) {
         // If we have a hit, it means we already generated the instruction
-        // as a dependancy to somethign else. We need to make sure
+        // as a dependency to something else. We need to make sure
         // it is ordered properly.
         auto I = i->second;
         LLVMInstructionRemoveFromParent(I);
         LLVMInsertIntoBuilderWithName(Builder, I, Name);
         return I;
       }
     }
 
switch(Op) {
           for (unsigned i = 0; i < NumHandlers; i++)
             LLVMAddHandler(Dst, DeclareBB(Handlers[i]));
           free(Handlers);
         }
         break;
       }
       case LLVMExtractValue: {
         LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
-        if (LLVMGetNumIndices(Src) != 1)
-          report_fatal_error("Expected only one indice");
+        if (LLVMGetNumIndices(Src) > 1)
+          report_fatal_error("ExtractValue: Expected only one index");
+        else if (LLVMGetNumIndices(Src) < 1)
+          report_fatal_error("ExtractValue: Expected an index");
         auto I = LLVMGetIndices(Src)[0];
         Dst = LLVMBuildExtractValue(Builder, Agg, I, Name);
         break;
       }
       case LLVMInsertValue: {
         LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
         LLVMValueRef V = CloneValue(LLVMGetOperand(Src, 1));
-        if (LLVMGetNumIndices(Src) != 1)
-          report_fatal_error("Expected only one indice");
+        if (LLVMGetNumIndices(Src) > 1)
+          report_fatal_error("InsertValue: Expected only one index");
+        else if (LLVMGetNumIndices(Src) < 1)
+          report_fatal_error("InsertValue: Expected an index");
         auto I = LLVMGetIndices(Src)[0];
         Dst = LLVMBuildInsertValue(Builder, Agg, V, I, Name);
         break;
       }
+      case LLVMExtractElement: {
+        LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
+        LLVMValueRef Index = CloneValue(LLVMGetOperand(Src, 1));
+        Dst = LLVMBuildExtractElement(Builder, Agg, Index, Name);
+        break;
+      }
+      case LLVMInsertElement: {
+        LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
+        LLVMValueRef V = CloneValue(LLVMGetOperand(Src, 1));
+        LLVMValueRef Index = CloneValue(LLVMGetOperand(Src, 2));
+        Dst = LLVMBuildInsertElement(Builder, Agg, V, Index, Name);
+        break;
+      }
+      case LLVMShuffleVector: {
+        LLVMValueRef Agg0 = CloneValue(LLVMGetOperand(Src, 0));
+        LLVMValueRef Agg1 = CloneValue(LLVMGetOperand(Src, 1));
+        SmallVector<LLVMValueRef, 8> MaskElts;
+        unsigned NumMaskElts = LLVMGetNumMaskElements(Src);
+        for (unsigned i = 0; i < NumMaskElts; i++) {
+          int Val = LLVMGetMaskValue(Src, i);
+          if (Val == LLVMUndefMaskElem) {
+            MaskElts.push_back(LLVMGetUndef(LLVMInt64Type()));
+          } else {
+            MaskElts.push_back(LLVMConstInt(LLVMInt64Type(), Val, true));
+          }
+        }
+        LLVMValueRef Mask = LLVMConstVector(MaskElts.data(), NumMaskElts);
+        Dst = LLVMBuildShuffleVector(Builder, Agg0, Agg1, Mask, Name);
+        break;
+      }
       case LLVMFreeze: {
         LLVMValueRef Arg = CloneValue(LLVMGetOperand(Src, 0));
         Dst = LLVMBuildFreeze(Builder, Arg, Name);
         break;
       }
       default:
         break;
     }
while (true) {
     size_t NumMetadataEntries;
     auto *AllMetadata = LLVMGlobalCopyAllMetadata(Cur, &NumMetadataEntries);
     for (unsigned i = 0; i < NumMetadataEntries; ++i) {
       unsigned Kind = LLVMValueMetadataEntriesGetKind(AllMetadata, i);
       LLVMMetadataRef MD = LLVMValueMetadataEntriesGetMetadata(AllMetadata, i);
       LLVMGlobalSetMetadata(G, Kind, MD);
     }
     LLVMDisposeValueMetadataEntries(AllMetadata);
-    
     LLVMSetGlobalConstant(G, LLVMIsGlobalConstant(Cur));
     LLVMSetThreadLocal(G, LLVMIsThreadLocal(Cur));
     LLVMSetExternallyInitialized(G, LLVMIsExternallyInitialized(Cur));
     LLVMSetLinkage(G, LLVMGetLinkage(Cur));
     LLVMSetSection(G, LLVMGetSection(Cur));
     LLVMSetVisibility(G, LLVMGetVisibility(Cur));
     LLVMSetUnnamedAddress(G, LLVMGetUnnamedAddress(Cur));
     LLVMSetAlignment(G, LLVMGetAlignment(Cur));

llvm/tools/llvm-c-test/main.c

static void print_usage(void) {
   fprintf(stderr, "  * --module-list-functions\n");
   fprintf(stderr,
           "    Read bitcode from stdin - list summary of functions\n\n");
   fprintf(stderr, "  * --module-list-globals\n");
   fprintf(stderr, "    Read bitcode from stdin - list summary of globals\n\n");
   fprintf(stderr, "  * --targets-list\n");
   fprintf(stderr, "    List available targets\n\n");
   fprintf(stderr, "  * --object-list-sections\n");
-  fprintf(stderr, "    Read object file form stdin - list sections\n\n");
+  fprintf(stderr, "    Read object file from stdin - list sections\n\n");
   fprintf(stderr, "  * --object-list-symbols\n");
   fprintf(stderr,
-          "    Read object file form stdin - list symbols (like nm)\n\n");
+          "    Read object file from stdin - list symbols (like nm)\n\n");
   fprintf(stderr, "  * --disassemble\n");
   fprintf(stderr, "    Read lines of triple, hex ascii machine code from stdin "
                   "- print disassembly\n\n");
   fprintf(stderr, "  * --calc\n");
   fprintf(
       stderr,
       "    Read lines of name, rpn from stdin - print generated module\n\n");
   fprintf(stderr, "  * --echo\n");
-  fprintf(stderr,
-          "    Read bitcode file form stdin - print it back out\n\n");
+  fprintf(stderr, "    Read bitcode file from stdin - print it back out\n\n");
   fprintf(stderr, "  * --test-diagnostic-handler\n");
   fprintf(stderr,
-          "    Read bitcode file form stdin with a diagnostic handler set\n\n");
+          "    Read bitcode file from stdin with a diagnostic handler set\n\n");
   fprintf(stderr, "  * --test-dibuilder\n");
   fprintf(stderr,
           "    Run tests for the DIBuilder C API - print generated module\n\n");
 }
 
 int main(int argc, char **argv) {
   LLVMPassRegistryRef pr = LLVMGetGlobalPassRegistry();