[llvm-c][test] Remove typed pointer support from llvm-c-test echo

[nikic]

LGTM

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

 ; RUN: llvm-as < %s | llvm-dis > %t.orig
-; RUN: llvm-as < %s | llvm-c-test --echo --no-opaque-pointers > %t.echo
+; RUN: llvm-as < %s | llvm-c-test --echo > %t.echo
 ; RUN: diff -w %t.orig %t.echo
 ;
-; RUN: llvm-as -opaque-pointers < %s | llvm-dis > %t.orig_opaque
-; RUN: llvm-as -opaque-pointers < %s | llvm-c-test --echo > %t.echo_opaque
-; RUN: diff -w %t.orig_opaque %t.echo_opaque
-
 source_filename = "/test/Bindings/echo.ll"
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 module asm "classical GAS"
 
-%S = type { i64, %S* }
+%S = type { i64, ptr }
 
 @var = global i32 42
-@ext = external global i32*
-@cst = constant %S { i64 1, %S* @cst }
-@tl = thread_local global { i64, %S* } { i64 1, %S* @cst }
+@ext = external global ptr
+@cst = constant %S { i64 1, ptr @cst }
+@tl = thread_local global { i64, ptr } { i64 1, ptr @cst }
 @arr = linkonce_odr global [5 x i8] [ i8 2, i8 3, i8 5, i8 7, i8 11 ]
 @str = private unnamed_addr constant [13 x i8] c"hello world\0A\00"
 @locStr = private local_unnamed_addr constant [13 x i8] c"hello world\0A\00"
 @hidden = hidden global i32 7
 @protected = protected global i32 23
 @section = global i32 27, section ".custom"
 @align = global i32 31, align 4
-@nullptr = global i32* null
+@nullptr = global ptr null
 
-@const_gep = global i32* getelementptr (i32, i32* @var, i64 2)
-@const_inbounds_gep = global i32* getelementptr inbounds (i32, i32* @var, i64 1)
+@const_gep = global ptr getelementptr (i32, ptr @var, i64 2)
+@const_inbounds_gep = global ptr getelementptr inbounds (i32, ptr @var, i64 1)
 
-@aliased1 = alias i32, i32* @var
-@aliased2 = internal alias i32, i32* @var
-@aliased3 = external alias i32, i32* @var
-@aliased4 = weak alias i32, i32* @var
-@aliased5 = weak_odr alias i32, i32* @var
+@aliased1 = alias i32, ptr @var
+@aliased2 = internal alias i32, ptr @var
+@aliased3 = external alias i32, ptr @var
+@aliased4 = weak alias i32, ptr @var
+@aliased5 = weak_odr alias i32, ptr @var
 
-@ifunc = ifunc i32 (i32), i32 (i32)* ()* @ifunc_resolver
+@ifunc = ifunc i32 (i32), ptr @ifunc_resolver
 
-define i32 (i32)* @ifunc_resolver() {
+define ptr @ifunc_resolver() {
 entry:
-  ret i32 (i32)* null
+  ret ptr null
 }
 
-define { i64, %S* } @unpackrepack(%S %s) {
+define { i64, ptr } @unpackrepack(%S %s) {
   %1 = extractvalue %S %s, 0
   %2 = extractvalue %S %s, 1
-  %3 = insertvalue { i64, %S* } undef, %S* %2, 1
-  %4 = insertvalue { i64, %S* } %3, i64 %1, 0
-  ret { i64, %S* } %4
+  %3 = insertvalue { i64, ptr } undef, ptr %2, 1
+  %4 = insertvalue { i64, ptr } %3, i64 %1, 0
+  ret { i64, ptr } %4
 }
 
 declare void @decl()
 
 ; TODO: label and metadata types
 define void @types() {
   %1 = alloca half, align 2
   %2 = alloca float, align 4
   %3 = alloca double, align 8
   %4 = alloca x86_fp80, align 16
   %5 = alloca fp128, align 16
   %6 = alloca ppc_fp128, align 16
   %7 = alloca i7, align 1
-  %8 = alloca void (i1)*, align 8
+  %8 = alloca ptr, align 8
   %9 = alloca [3 x i22], align 4
-  %10 = alloca i328 addrspace(5)*, align 8
-  %11 = alloca <5 x i23*>, align 64
+  %10 = alloca ptr addrspace(5), align 8
+  %11 = alloca <5 x ptr>, align 64
   %12 = alloca x86_mmx, align 8
   ret void
 }
 
 define i32 @iops(i32 %a, i32 %b) {
   %1 = add i32 %a, %b
   %2 = mul i32 %a, %1
   %3 = sub i32 %2, %1
do:
   %2 = sub i32 %p, 23
   %j = sub i32 %i, 1
   %r = mul i32 %2, 3
   br label %cond
 done:
   ret i32 %p
 }
 
-define void @memops(i8* %ptr) {
-  %a = load i8, i8* %ptr
-  %b = load volatile i8, i8* %ptr
-  %c = load i8, i8* %ptr, align 8
-  %d = load atomic i8, i8* %ptr acquire, align 32
-  store i8 0, i8* %ptr
-  store volatile i8 0, i8* %ptr
-  store i8 0, i8* %ptr, align 8
-  store atomic i8 0, i8* %ptr release, align 32
-  %e = atomicrmw add i8* %ptr, i8 0 monotonic, align 1
-  %f = atomicrmw volatile xchg i8* %ptr, i8 0 acq_rel, align 8
-  %g = cmpxchg i8* %ptr, i8 1, i8 2 seq_cst acquire, align 1
-  %h = cmpxchg weak i8* %ptr, i8 1, i8 2 seq_cst acquire, align 8
-  %i = cmpxchg volatile i8* %ptr, i8 1, i8 2 monotonic monotonic, align 16
+define void @memops(ptr %ptr) {
+  %a = load i8, ptr %ptr
+  %b = load volatile i8, ptr %ptr
+  %c = load i8, ptr %ptr, align 8
+  %d = load atomic i8, ptr %ptr acquire, align 32
+  store i8 0, ptr %ptr
+  store volatile i8 0, ptr %ptr
+  store i8 0, ptr %ptr, align 8
+  store atomic i8 0, ptr %ptr release, align 32
+  %e = atomicrmw add ptr %ptr, i8 0 monotonic, align 1
+  %f = atomicrmw volatile xchg ptr %ptr, i8 0 acq_rel, align 8
+  %g = cmpxchg ptr %ptr, i8 1, i8 2 seq_cst acquire, align 1
+  %h = cmpxchg weak ptr %ptr, i8 1, i8 2 seq_cst acquire, align 8
+  %i = cmpxchg volatile ptr %ptr, i8 1, i8 2 monotonic monotonic, align 16
   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>
define i32 @scalablevectorops(i32, <vscale x 4 x i32>) {
   %h = or <vscale x 4 x i32> %g, %e
   %i = lshr <vscale x 4 x i32> %h, undef
   %j = extractelement <vscale x 4 x i32> %i, i32 3
   ret i32 %j
 }
 
 declare void @personalityFn()
 
-define void @exn() personality void ()* @personalityFn {
+define void @exn() personality ptr @personalityFn {
 entry:
   invoke void @decl()
           to label %via.cleanup unwind label %exn.dispatch
 via.cleanup:
   invoke void @decl()
           to label %via.catchswitch unwind label %cleanup.inner
 cleanup.inner:
   %cp.inner = cleanuppad within none []

 exit:
   ret void
 }
 
 define void @with_debuginfo() !dbg !4 {
   ret void, !dbg !7
 }
 
-declare i8* @llvm.stacksave()
-declare void @llvm.stackrestore(i8*)
-declare void @llvm.lifetime.start.p0i8(i64, i8*)
-declare void @llvm.lifetime.end.p0i8(i64, i8*)
+declare ptr @llvm.stacksave()
+declare void @llvm.stackrestore(ptr)
+declare void @llvm.lifetime.start.p0(i64, ptr)
+declare void @llvm.lifetime.end.p0(i64, ptr)
 
 define void @test_intrinsics() {
 entry:
-  %sp = call i8* @llvm.stacksave()
+  %sp = call ptr @llvm.stacksave()
   %0 = alloca i8, align 1
-  call void @llvm.lifetime.start.p0i8(i64 1, i8* %0)
-  call void @llvm.lifetime.end.p0i8(i64 1, i8* %0)
-  call void @llvm.stackrestore(i8* %sp)
+  call void @llvm.lifetime.start.p0(i64 1, ptr %0)
+  call void @llvm.lifetime.end.p0(i64 1, ptr %0)
+  call void @llvm.stackrestore(ptr %sp)
   ret void
 }
 
 !llvm.dbg.cu = !{!0, !2}
 !llvm.module.flags = !{!3}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C, file: !1, producer: "", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug)
 !1 = !DIFile(filename: "echo.ll", directory: "/llvm/test/Bindings/llvm-c/echo.ll")

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

while (true) {
     LLVMNamedMDNodeRef PrevMD = LLVMGetPreviousNamedMetadata(NextMD);
     if (PrevMD != CurMD)
       report_fatal_error("Next.Previous Named MD Node is not Current");
 
     CurMD = NextMD;
   }
 }
 
-int llvm_echo(bool OpaquePointers) {
+int llvm_echo(void) {
   LLVMEnablePrettyStackTrace();
 
   LLVMModuleRef Src = llvm_load_module(false, true);
   size_t SourceFileLen;
   const char *SourceFileName = LLVMGetSourceFileName(Src, &SourceFileLen);
   size_t ModuleIdentLen;
   const char *ModuleName = LLVMGetModuleIdentifier(Src, &ModuleIdentLen);
   LLVMContextRef Ctx = LLVMContextCreate();
-  if (!OpaquePointers)
-    LLVMContextSetOpaquePointers(Ctx, false);
   LLVMModuleRef M = LLVMModuleCreateWithNameInContext(ModuleName, Ctx);
 
   LLVMSetSourceFileName(M, SourceFileName, SourceFileLen);
   LLVMSetModuleIdentifier(M, ModuleName, ModuleIdentLen);
 
   LLVMSetTarget(M, LLVMGetTarget(Src));
   LLVMSetModuleDataLayout(M, LLVMGetModuleDataLayout(Src));
   if (strcmp(LLVMGetDataLayoutStr(M), LLVMGetDataLayoutStr(Src)))

llvm/tools/llvm-c-test/llvm-c-test.h

 // object.c
 int llvm_object_list_sections(void);
 int llvm_object_list_symbols(void);
 
 // targets.c
 int llvm_targets_list(void);
 
 // echo.c
-int llvm_echo(bool OpaquePointers);
+int llvm_echo(void);
 
 // diagnostic.c
 int llvm_test_diagnostic_handler(void);
 
 // attributes.c
 int llvm_test_function_attributes(void);
 int llvm_test_callsite_attributes(void);
 
 #ifdef __cplusplus
 }
 #endif /* !defined(__cplusplus) */
 
 #endif

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

int main(int argc, char **argv) {
   } else if (argc == 2 && !strcmp(argv[1], "--add-named-metadata-operand")) {
     return llvm_add_named_metadata_operand();
   } else if (argc == 2 && !strcmp(argv[1], "--set-metadata")) {
     return llvm_set_metadata();
   } else if (argc == 2 && !strcmp(argv[1], "--test-function-attributes")) {
     return llvm_test_function_attributes();
   } else if (argc == 2 && !strcmp(argv[1], "--test-callsite-attributes")) {
     return llvm_test_callsite_attributes();
-  } else if ((argc == 2 || argc == 3) && !strcmp(argv[1], "--echo")) {
-    return llvm_echo(argc == 3 ? strcmp(argv[2], "--no-opaque-pointers") != 0
-                               : 1);
+  } else if (argc == 2 && !strcmp(argv[1], "--echo")) {
+    return llvm_echo();
   } else if (argc == 2 && !strcmp(argv[1], "--test-diagnostic-handler")) {
     return llvm_test_diagnostic_handler();
   } else if (argc == 2 && !strcmp(argv[1], "--test-dibuilder")) {
     return llvm_test_dibuilder();
   } else {
     print_usage();
   }
 
   return 1;
 }