Fix layering between llvm-c and Support by factoring out some typedefs into Support

llvm-c depends on Support, but Support (TargetRegistry) uses some of
llvm-c's typedefs. Move those into a Support header to be used from both
llvm-c and Support.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@327940 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm-c/Disassembler.h b/include/llvm-c/Disassembler.h
index d6f92e5..9d2b380 100644 (file)
--- a/include/llvm-c/Disassembler.h
+++ b/include/llvm-c/Disassembler.h
@@ -16,6 +16,7 @@
 #define LLVM_C_DISASSEMBLER_H
 
 #include "llvm/Support/DataTypes.h"
+#include "llvm/Support/DisassemblerTypedefs.h"
 #ifdef __cplusplus
 #include <cstddef>
 #else
@@ -34,26 +35,6 @@
  */
 typedef void *LLVMDisasmContextRef;
 
-/**
- * The type for the operand information call back function.  This is called to
- * get the symbolic information for an operand of an instruction.  Typically
- * this is from the relocation information, symbol table, etc.  That block of
- * information is saved when the disassembler context is created and passed to
- * the call back in the DisInfo parameter.  The instruction containing operand
- * is at the PC parameter.  For some instruction sets, there can be more than
- * one operand with symbolic information.  To determine the symbolic operand
- * information for each operand, the bytes for the specific operand in the
- * instruction are specified by the Offset parameter and its byte widith is the
- * size parameter.  For instructions sets with fixed widths and one symbolic
- * operand per instruction, the Offset parameter will be zero and Size parameter
- * will be the instruction width.  The information is returned in TagBuf and is
- * Triple specific with its specific information defined by the value of
- * TagType for that Triple.  If symbolic information is returned the function
- * returns 1, otherwise it returns 0.
- */
-typedef int (*LLVMOpInfoCallback)(void *DisInfo, uint64_t PC,
-                                  uint64_t Offset, uint64_t Size,
-                                  int TagType, void *TagBuf);
 
 /**
  * The initial support in LLVM MC for the most general form of a relocatable
@@ -110,23 +91,6 @@ struct LLVMOpInfo1 {
 #define LLVMDisassembler_VariantKind_ARM64_TLVOFF     6 /* @tvlppageoff */
 
 /**
- * The type for the symbol lookup function.  This may be called by the
- * disassembler for things like adding a comment for a PC plus a constant
- * offset load instruction to use a symbol name instead of a load address value.
- * It is passed the block information is saved when the disassembler context is
- * created and the ReferenceValue to look up as a symbol.  If no symbol is found
- * for the ReferenceValue NULL is returned.  The ReferenceType of the
- * instruction is passed indirectly as is the PC of the instruction in
- * ReferencePC.  If the output reference can be determined its type is returned
- * indirectly in ReferenceType along with ReferenceName if any, or that is set
- * to NULL.
- */
-typedef const char *(*LLVMSymbolLookupCallback)(void *DisInfo,
-                                                uint64_t ReferenceValue,
-                                                uint64_t *ReferenceType,
-                                                uint64_t ReferencePC,
-                                                const char **ReferenceName);
-/**
  * The reference types on input and output.
  */
 /* No input reference type or no output reference type. */

diff --git a/include/llvm/Support/DisassemblerTypedefs.h b/include/llvm/Support/DisassemblerTypedefs.h
new file mode 100644 (file)
index 0000000..f275cb9
--- /dev/null
+++ b/include/llvm/Support/DisassemblerTypedefs.h
@@ -0,0 +1,60 @@
+//===- Support/DisassemblerTypedefs.h ---------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Typedefs used across the boundary between Support and the C API.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_DISASSEMBLERTYPEDEFS_H
+#define LLVM_SUPPORT_DISASSEMBLERTYPEDEFS_H
+#ifdef __cplusplus
+#include <cstddef>
+#else
+#include <stddef.h>
+#endif
+
+/**
+ * The type for the operand information call back function.  This is called to
+ * get the symbolic information for an operand of an instruction.  Typically
+ * this is from the relocation information, symbol table, etc.  That block of
+ * information is saved when the disassembler context is created and passed to
+ * the call back in the DisInfo parameter.  The instruction containing operand
+ * is at the PC parameter.  For some instruction sets, there can be more than
+ * one operand with symbolic information.  To determine the symbolic operand
+ * information for each operand, the bytes for the specific operand in the
+ * instruction are specified by the Offset parameter and its byte widith is the
+ * size parameter.  For instructions sets with fixed widths and one symbolic
+ * operand per instruction, the Offset parameter will be zero and Size parameter
+ * will be the instruction width.  The information is returned in TagBuf and is
+ * Triple specific with its specific information defined by the value of
+ * TagType for that Triple.  If symbolic information is returned the function
+ * returns 1, otherwise it returns 0.
+ */
+typedef int (*LLVMOpInfoCallback)(void *DisInfo, uint64_t PC,
+                                  uint64_t Offset, uint64_t Size,
+                                  int TagType, void *TagBuf);
+
+/**
+ * The type for the symbol lookup function.  This may be called by the
+ * disassembler for things like adding a comment for a PC plus a constant
+ * offset load instruction to use a symbol name instead of a load address value.
+ * It is passed the block information is saved when the disassembler context is
+ * created and the ReferenceValue to look up as a symbol.  If no symbol is found
+ * for the ReferenceValue NULL is returned.  The ReferenceType of the
+ * instruction is passed indirectly as is the PC of the instruction in
+ * ReferencePC.  If the output reference can be determined its type is returned
+ * indirectly in ReferenceType along with ReferenceName if any, or that is set
+ * to NULL.
+ */
+typedef const char *(*LLVMSymbolLookupCallback)(void *DisInfo,
+                                                uint64_t ReferenceValue,
+                                                uint64_t *ReferenceType,
+                                                uint64_t ReferencePC,
+                                                const char **ReferenceName);
+#endif

diff --git a/include/llvm/Support/TargetRegistry.h b/include/llvm/Support/TargetRegistry.h
index 8a429ab..0bcb8ba 100644 (file)
--- a/include/llvm/Support/TargetRegistry.h
+++ b/include/llvm/Support/TargetRegistry.h
@@ -19,12 +19,12 @@
 #ifndef LLVM_SUPPORT_TARGETREGISTRY_H
 #define LLVM_SUPPORT_TARGETREGISTRY_H
 
-#include "llvm-c/Disassembler.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/CodeGen.h"
+#include "llvm/Support/DisassemblerTypedefs.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FormattedStream.h"
 #include <algorithm>