2007-04-23 03:01:15 +02:00
|
|
|
//===- LLVMBitCodes.h - Enum values for the LLVM bitcode format -*- C++ -*-===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:59:42 +01:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2007-04-23 03:01:15 +02:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This header defines Bitcode enum values for LLVM IR bitcode files.
|
|
|
|
//
|
|
|
|
// The enum values defined in this file should be considered permanent. If
|
|
|
|
// new features are added, they should have values added at the end of the
|
|
|
|
// respective lists.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#ifndef LLVM_BITCODE_LLVMBITCODES_H
|
|
|
|
#define LLVM_BITCODE_LLVMBITCODES_H
|
|
|
|
|
|
|
|
#include "llvm/Bitcode/BitCodes.h"
|
|
|
|
|
|
|
|
namespace llvm {
|
|
|
|
namespace bitc {
|
|
|
|
// The only top-level block type defined is for a module.
|
|
|
|
enum BlockIDs {
|
|
|
|
// Blocks
|
2007-05-04 20:25:49 +02:00
|
|
|
MODULE_BLOCK_ID = FIRST_APPLICATION_BLOCKID,
|
2009-02-21 00:04:06 +01:00
|
|
|
|
2007-05-04 20:25:49 +02:00
|
|
|
// Module sub-block id's.
|
|
|
|
PARAMATTR_BLOCK_ID,
|
2013-02-11 00:09:32 +01:00
|
|
|
PARAMATTR_GROUP_BLOCK_ID,
|
2012-11-15 23:34:00 +01:00
|
|
|
|
2007-05-04 20:25:49 +02:00
|
|
|
CONSTANTS_BLOCK_ID,
|
|
|
|
FUNCTION_BLOCK_ID,
|
2012-11-15 23:34:00 +01:00
|
|
|
|
2013-02-11 00:09:32 +01:00
|
|
|
UNUSED_ID1,
|
2012-11-15 23:34:00 +01:00
|
|
|
|
2009-07-22 19:43:22 +02:00
|
|
|
VALUE_SYMTAB_BLOCK_ID,
|
2009-09-18 21:26:43 +02:00
|
|
|
METADATA_BLOCK_ID,
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-09 19:41:24 +02:00
|
|
|
METADATA_ATTACHMENT_ID,
|
2012-11-15 23:34:00 +01:00
|
|
|
|
2011-12-07 22:44:12 +01:00
|
|
|
TYPE_BLOCK_ID_NEW,
|
|
|
|
|
|
|
|
USELIST_BLOCK_ID
|
2007-04-23 03:01:15 +02:00
|
|
|
};
|
2009-02-21 00:04:06 +01:00
|
|
|
|
|
|
|
|
2007-04-23 03:01:15 +02:00
|
|
|
/// MODULE blocks have a number of optional fields and subblocks.
|
|
|
|
enum ModuleCodes {
|
|
|
|
MODULE_CODE_VERSION = 1, // VERSION: [version#]
|
2007-05-04 21:10:48 +02:00
|
|
|
MODULE_CODE_TRIPLE = 2, // TRIPLE: [strchr x N]
|
|
|
|
MODULE_CODE_DATALAYOUT = 3, // DATALAYOUT: [strchr x N]
|
|
|
|
MODULE_CODE_ASM = 4, // ASM: [strchr x N]
|
|
|
|
MODULE_CODE_SECTIONNAME = 5, // SECTIONNAME: [strchr x N]
|
2007-04-23 03:01:15 +02:00
|
|
|
|
2012-11-28 09:41:48 +01:00
|
|
|
// FIXME: Remove DEPLIB in 4.0.
|
|
|
|
MODULE_CODE_DEPLIB = 6, // DEPLIB: [strchr x N]
|
|
|
|
|
2009-02-21 00:04:06 +01:00
|
|
|
// GLOBALVAR: [pointer type, isconst, initid,
|
2007-04-23 03:01:15 +02:00
|
|
|
// linkage, alignment, section, visibility, threadlocal]
|
|
|
|
MODULE_CODE_GLOBALVAR = 7,
|
|
|
|
|
2007-05-08 07:38:32 +02:00
|
|
|
// FUNCTION: [type, callingconv, isproto, linkage, paramattrs, alignment,
|
2011-12-08 00:57:55 +01:00
|
|
|
// section, visibility, gc, unnamed_addr]
|
2007-04-26 04:46:23 +02:00
|
|
|
MODULE_CODE_FUNCTION = 8,
|
2009-02-21 00:04:06 +01:00
|
|
|
|
2011-12-08 01:11:31 +01:00
|
|
|
// ALIAS: [alias type, aliasee val#, linkage, visibility]
|
2007-04-26 05:26:26 +02:00
|
|
|
MODULE_CODE_ALIAS = 9,
|
2009-02-21 00:04:06 +01:00
|
|
|
|
2013-02-11 00:09:32 +01:00
|
|
|
// MODULE_CODE_PURGEVALS: [numvals]
|
2007-12-10 04:18:06 +01:00
|
|
|
MODULE_CODE_PURGEVALS = 10,
|
2009-02-21 00:04:06 +01:00
|
|
|
|
2014-06-27 20:19:56 +02:00
|
|
|
MODULE_CODE_GCNAME = 11, // GCNAME: [strchr x N]
|
|
|
|
MODULE_CODE_COMDAT = 12, // COMDAT: [selection_kind, name]
|
2007-04-23 03:01:15 +02:00
|
|
|
};
|
2009-02-21 00:04:06 +01:00
|
|
|
|
2007-05-04 05:00:00 +02:00
|
|
|
/// PARAMATTR blocks have code for defining a parameter attribute set.
|
2008-09-25 23:00:45 +02:00
|
|
|
enum AttributeCodes {
|
2013-02-05 00:32:23 +01:00
|
|
|
// FIXME: Remove `PARAMATTR_CODE_ENTRY_OLD' in 4.0
|
2013-02-11 00:09:32 +01:00
|
|
|
PARAMATTR_CODE_ENTRY_OLD = 1, // ENTRY: [paramidx0, attr0,
|
|
|
|
// paramidx1, attr1...]
|
|
|
|
PARAMATTR_CODE_ENTRY = 2, // ENTRY: [paramidx0, attrgrp0,
|
|
|
|
// paramidx1, attrgrp1, ...]
|
|
|
|
PARAMATTR_GRP_CODE_ENTRY = 3 // ENTRY: [id, attr0, att1, ...]
|
2007-05-04 05:00:00 +02:00
|
|
|
};
|
2009-02-21 00:04:06 +01:00
|
|
|
|
2007-04-23 03:01:15 +02:00
|
|
|
/// TYPE blocks have codes for each type primitive they use.
|
|
|
|
enum TypeCodes {
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-09 19:41:24 +02:00
|
|
|
TYPE_CODE_NUMENTRY = 1, // NUMENTRY: [numentries]
|
2009-02-21 00:04:06 +01:00
|
|
|
|
2007-04-23 03:01:15 +02:00
|
|
|
// Type Codes
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-09 19:41:24 +02:00
|
|
|
TYPE_CODE_VOID = 2, // VOID
|
|
|
|
TYPE_CODE_FLOAT = 3, // FLOAT
|
|
|
|
TYPE_CODE_DOUBLE = 4, // DOUBLE
|
|
|
|
TYPE_CODE_LABEL = 5, // LABEL
|
|
|
|
TYPE_CODE_OPAQUE = 6, // OPAQUE
|
|
|
|
TYPE_CODE_INTEGER = 7, // INTEGER: [width]
|
|
|
|
TYPE_CODE_POINTER = 8, // POINTER: [pointee type]
|
2012-05-23 17:19:39 +02:00
|
|
|
|
|
|
|
TYPE_CODE_FUNCTION_OLD = 9, // FUNCTION: [vararg, attrid, retty,
|
|
|
|
// paramty x N]
|
2012-11-15 23:34:00 +01:00
|
|
|
|
2011-12-17 01:04:22 +01:00
|
|
|
TYPE_CODE_HALF = 10, // HALF
|
2012-11-15 23:34:00 +01:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-09 19:41:24 +02:00
|
|
|
TYPE_CODE_ARRAY = 11, // ARRAY: [numelts, eltty]
|
|
|
|
TYPE_CODE_VECTOR = 12, // VECTOR: [numelts, eltty]
|
2007-08-03 03:03:46 +02:00
|
|
|
|
|
|
|
// These are not with the other floating point types because they're
|
|
|
|
// a late addition, and putting them in the right place breaks
|
|
|
|
// binary compatibility.
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-09 19:41:24 +02:00
|
|
|
TYPE_CODE_X86_FP80 = 13, // X86 LONG DOUBLE
|
|
|
|
TYPE_CODE_FP128 = 14, // LONG DOUBLE (112 bit mantissa)
|
|
|
|
TYPE_CODE_PPC_FP128= 15, // PPC LONG DOUBLE (2 doubles)
|
2009-05-30 07:06:04 +02:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-09 19:41:24 +02:00
|
|
|
TYPE_CODE_METADATA = 16, // METADATA
|
2010-09-10 22:55:01 +02:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-09 19:41:24 +02:00
|
|
|
TYPE_CODE_X86_MMX = 17, // X86 MMX
|
2012-11-15 23:34:00 +01:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
llvm-svn: 134829
2011-07-09 19:41:24 +02:00
|
|
|
TYPE_CODE_STRUCT_ANON = 18, // STRUCT_ANON: [ispacked, eltty x N]
|
|
|
|
TYPE_CODE_STRUCT_NAME = 19, // STRUCT_NAME: [strchr x N]
|
2011-11-03 01:14:01 +01:00
|
|
|
TYPE_CODE_STRUCT_NAMED = 20,// STRUCT_NAMED: [ispacked, eltty x N]
|
|
|
|
|
2015-08-14 07:09:07 +02:00
|
|
|
TYPE_CODE_FUNCTION = 21, // FUNCTION: [vararg, retty, paramty x N]
|
|
|
|
|
|
|
|
TYPE_CODE_TOKEN = 22 // TOKEN
|
2007-04-23 03:01:15 +02:00
|
|
|
};
|
2009-02-21 00:04:06 +01:00
|
|
|
|
2007-04-23 03:01:15 +02:00
|
|
|
// The type symbol table only has one code (TST_ENTRY_CODE).
|
|
|
|
enum TypeSymtabCodes {
|
2007-05-04 21:10:48 +02:00
|
|
|
TST_CODE_ENTRY = 1 // TST_ENTRY: [typeid, namechar x N]
|
2007-04-23 03:01:15 +02:00
|
|
|
};
|
2009-02-21 00:04:06 +01:00
|
|
|
|
2007-04-23 22:34:46 +02:00
|
|
|
// The value symbol table only has one code (VST_ENTRY_CODE).
|
|
|
|
enum ValueSymtabCodes {
|
2011-04-11 01:18:04 +02:00
|
|
|
VST_CODE_ENTRY = 1, // VST_ENTRY: [valid, namechar x N]
|
|
|
|
VST_CODE_BBENTRY = 2 // VST_BBENTRY: [bbid, namechar x N]
|
2007-04-24 01:29:59 +02:00
|
|
|
};
|
2009-02-21 00:04:06 +01:00
|
|
|
|
2009-07-22 19:43:22 +02:00
|
|
|
enum MetadataCodes {
|
2009-07-30 00:34:41 +02:00
|
|
|
METADATA_STRING = 1, // MDSTRING: [values]
|
2014-12-12 00:02:24 +01:00
|
|
|
METADATA_VALUE = 2, // VALUE: [type num, value num]
|
|
|
|
METADATA_NODE = 3, // NODE: [n x md num]
|
2010-01-10 08:14:18 +01:00
|
|
|
METADATA_NAME = 4, // STRING: [values]
|
2015-01-08 23:38:29 +01:00
|
|
|
METADATA_DISTINCT_NODE = 5, // DISTINCT_NODE: [n x md num]
|
2010-01-10 08:14:18 +01:00
|
|
|
METADATA_KIND = 6, // [n x [id, name]]
|
2015-01-13 22:10:44 +01:00
|
|
|
METADATA_LOCATION = 7, // [distinct, line, col, scope, inlined-at?]
|
2014-12-11 23:30:48 +01:00
|
|
|
METADATA_OLD_NODE = 8, // OLD_NODE: [n x (type num, value num)]
|
|
|
|
METADATA_OLD_FN_NODE = 9, // OLD_FN_NODE: [n x (type num, value num)]
|
2011-06-17 19:50:30 +02:00
|
|
|
METADATA_NAMED_NODE = 10, // NAMED_NODE: [n x mdnodes]
|
2015-02-03 22:54:14 +01:00
|
|
|
METADATA_ATTACHMENT = 11, // [m x [value, [n x [id, mdnode]]]
|
2015-02-13 02:10:38 +01:00
|
|
|
METADATA_GENERIC_DEBUG = 12, // [distinct, tag, vers, header, n x md num]
|
2015-02-13 02:14:11 +01:00
|
|
|
METADATA_SUBRANGE = 13, // [distinct, count, lo]
|
2015-02-13 03:43:38 +01:00
|
|
|
METADATA_ENUMERATOR = 14, // [distinct, value, name]
|
2015-02-13 02:19:14 +01:00
|
|
|
METADATA_BASIC_TYPE = 15, // [distinct, tag, name, size, align, enc]
|
2015-02-13 02:20:38 +01:00
|
|
|
METADATA_FILE = 16, // [distinct, filename, directory]
|
|
|
|
METADATA_DERIVED_TYPE = 17, // [distinct, ...]
|
2015-02-13 02:22:59 +01:00
|
|
|
METADATA_COMPOSITE_TYPE= 18, // [distinct, ...]
|
2015-02-13 02:25:10 +01:00
|
|
|
METADATA_SUBROUTINE_TYPE=19, // [distinct, flags, types]
|
2015-02-13 02:26:47 +01:00
|
|
|
METADATA_COMPILE_UNIT = 20, // [distinct, ...]
|
2015-02-13 02:29:28 +01:00
|
|
|
METADATA_SUBPROGRAM = 21, // [distinct, ...]
|
2015-02-13 02:30:42 +01:00
|
|
|
METADATA_LEXICAL_BLOCK = 22, // [distinct, scope, file, line, column]
|
2015-02-13 02:32:09 +01:00
|
|
|
METADATA_LEXICAL_BLOCK_FILE=23,//[distinct, scope, file, discriminator]
|
2015-02-13 02:34:32 +01:00
|
|
|
METADATA_NAMESPACE = 24, // [distinct, scope, file, name, line]
|
|
|
|
METADATA_TEMPLATE_TYPE = 25, // [distinct, scope, name, type, ...]
|
2015-02-13 02:35:40 +01:00
|
|
|
METADATA_TEMPLATE_VALUE= 26, // [distinct, scope, name, type, value, ...]
|
2015-02-13 02:39:44 +01:00
|
|
|
METADATA_GLOBAL_VAR = 27, // [distinct, ...]
|
2015-02-13 02:42:09 +01:00
|
|
|
METADATA_LOCAL_VAR = 28, // [distinct, ...]
|
2015-02-13 02:43:22 +01:00
|
|
|
METADATA_EXPRESSION = 29, // [distinct, n x element]
|
2015-02-13 02:46:02 +01:00
|
|
|
METADATA_OBJC_PROPERTY = 30, // [distinct, name, file, line, ...]
|
2015-02-13 03:41:36 +01:00
|
|
|
METADATA_IMPORTED_ENTITY=31, // [distinct, tag, scope, entity, line, name]
|
2015-06-30 01:03:47 +02:00
|
|
|
METADATA_MODULE=32, // [distinct, scope, name, ...]
|
2009-07-22 19:43:22 +02:00
|
|
|
};
|
2013-02-05 00:32:23 +01:00
|
|
|
|
2007-04-24 01:29:59 +02:00
|
|
|
// The constants block (CONSTANTS_BLOCK_ID) describes emission for each
|
|
|
|
// constant and maintains an implicit current type value.
|
2007-04-29 23:49:05 +02:00
|
|
|
enum ConstantsCodes {
|
2007-04-24 09:03:08 +02:00
|
|
|
CST_CODE_SETTYPE = 1, // SETTYPE: [typeid]
|
|
|
|
CST_CODE_NULL = 2, // NULL
|
|
|
|
CST_CODE_UNDEF = 3, // UNDEF
|
|
|
|
CST_CODE_INTEGER = 4, // INTEGER: [intval]
|
2007-05-04 21:10:48 +02:00
|
|
|
CST_CODE_WIDE_INTEGER = 5, // WIDE_INTEGER: [n x intval]
|
2007-04-24 09:03:08 +02:00
|
|
|
CST_CODE_FLOAT = 6, // FLOAT: [fpval]
|
2007-05-04 21:10:48 +02:00
|
|
|
CST_CODE_AGGREGATE = 7, // AGGREGATE: [n x value number]
|
2007-05-06 02:35:24 +02:00
|
|
|
CST_CODE_STRING = 8, // STRING: [values]
|
2007-05-06 02:53:07 +02:00
|
|
|
CST_CODE_CSTRING = 9, // CSTRING: [values]
|
|
|
|
CST_CODE_CE_BINOP = 10, // CE_BINOP: [opcode, opval, opval]
|
|
|
|
CST_CODE_CE_CAST = 11, // CE_CAST: [opcode, opty, opval]
|
|
|
|
CST_CODE_CE_GEP = 12, // CE_GEP: [n x operands]
|
|
|
|
CST_CODE_CE_SELECT = 13, // CE_SELECT: [opval, opval, opval]
|
|
|
|
CST_CODE_CE_EXTRACTELT = 14, // CE_EXTRACTELT: [opty, opval, opval]
|
|
|
|
CST_CODE_CE_INSERTELT = 15, // CE_INSERTELT: [opval, opval, opval]
|
|
|
|
CST_CODE_CE_SHUFFLEVEC = 16, // CE_SHUFFLEVEC: [opval, opval, opval]
|
2007-05-06 03:50:11 +02:00
|
|
|
CST_CODE_CE_CMP = 17, // CE_CMP: [opty, opval, opval, pred]
|
2012-09-05 02:56:20 +02:00
|
|
|
CST_CODE_INLINEASM_OLD = 18, // INLINEASM: [sideeffect|alignstack,
|
|
|
|
// asmstr,conststr]
|
2009-07-27 23:53:46 +02:00
|
|
|
CST_CODE_CE_SHUFVEC_EX = 19, // SHUFVEC_EX: [opty, opval, opval, opval]
|
2009-10-28 06:24:40 +01:00
|
|
|
CST_CODE_CE_INBOUNDS_GEP = 20,// INBOUNDS_GEP: [n x operands]
|
2012-01-30 01:51:16 +01:00
|
|
|
CST_CODE_BLOCKADDRESS = 21, // CST_CODE_BLOCKADDRESS [fnty, fnval, bb#]
|
2012-09-05 02:56:20 +02:00
|
|
|
CST_CODE_DATA = 22, // DATA: [n x elements]
|
|
|
|
CST_CODE_INLINEASM = 23 // INLINEASM: [sideeffect|alignstack|
|
2012-09-05 21:00:49 +02:00
|
|
|
// asmdialect,asmstr,conststr]
|
2007-04-24 09:03:08 +02:00
|
|
|
};
|
2009-02-21 00:04:06 +01:00
|
|
|
|
2007-04-24 17:54:42 +02:00
|
|
|
/// CastOpcodes - These are values used in the bitcode files to encode which
|
|
|
|
/// cast a CST_CODE_CE_CAST or a XXX refers to. The values of these enums
|
|
|
|
/// have no fixed relation to the LLVM IR enum values. Changing these will
|
|
|
|
/// break compatibility with old files.
|
2007-04-24 09:03:08 +02:00
|
|
|
enum CastOpcodes {
|
|
|
|
CAST_TRUNC = 0,
|
|
|
|
CAST_ZEXT = 1,
|
|
|
|
CAST_SEXT = 2,
|
|
|
|
CAST_FPTOUI = 3,
|
|
|
|
CAST_FPTOSI = 4,
|
|
|
|
CAST_UITOFP = 5,
|
|
|
|
CAST_SITOFP = 6,
|
|
|
|
CAST_FPTRUNC = 7,
|
|
|
|
CAST_FPEXT = 8,
|
|
|
|
CAST_PTRTOINT = 9,
|
|
|
|
CAST_INTTOPTR = 10,
|
2013-11-15 02:34:59 +01:00
|
|
|
CAST_BITCAST = 11,
|
|
|
|
CAST_ADDRSPACECAST = 12
|
2007-04-24 09:03:08 +02:00
|
|
|
};
|
2009-02-21 00:04:06 +01:00
|
|
|
|
2007-04-24 17:54:42 +02:00
|
|
|
/// BinaryOpcodes - These are values used in the bitcode files to encode which
|
|
|
|
/// binop a CST_CODE_CE_BINOP or a XXX refers to. The values of these enums
|
|
|
|
/// have no fixed relation to the LLVM IR enum values. Changing these will
|
|
|
|
/// break compatibility with old files.
|
2007-04-24 09:03:08 +02:00
|
|
|
enum BinaryOpcodes {
|
|
|
|
BINOP_ADD = 0,
|
|
|
|
BINOP_SUB = 1,
|
|
|
|
BINOP_MUL = 2,
|
|
|
|
BINOP_UDIV = 3,
|
|
|
|
BINOP_SDIV = 4, // overloaded for FP
|
|
|
|
BINOP_UREM = 5,
|
|
|
|
BINOP_SREM = 6, // overloaded for FP
|
|
|
|
BINOP_SHL = 7,
|
|
|
|
BINOP_LSHR = 8,
|
|
|
|
BINOP_ASHR = 9,
|
|
|
|
BINOP_AND = 10,
|
|
|
|
BINOP_OR = 11,
|
|
|
|
BINOP_XOR = 12
|
2007-04-23 22:34:46 +02:00
|
|
|
};
|
2009-02-21 00:04:06 +01:00
|
|
|
|
2011-07-28 23:48:00 +02:00
|
|
|
/// These are values used in the bitcode files to encode AtomicRMW operations.
|
|
|
|
/// The values of these enums have no fixed relation to the LLVM IR enum
|
|
|
|
/// values. Changing these will break compatibility with old files.
|
|
|
|
enum RMWOperations {
|
|
|
|
RMW_XCHG = 0,
|
|
|
|
RMW_ADD = 1,
|
|
|
|
RMW_SUB = 2,
|
|
|
|
RMW_AND = 3,
|
|
|
|
RMW_NAND = 4,
|
|
|
|
RMW_OR = 5,
|
|
|
|
RMW_XOR = 6,
|
|
|
|
RMW_MAX = 7,
|
|
|
|
RMW_MIN = 8,
|
|
|
|
RMW_UMAX = 9,
|
|
|
|
RMW_UMIN = 10
|
|
|
|
};
|
|
|
|
|
2009-07-20 23:19:07 +02:00
|
|
|
/// OverflowingBinaryOperatorOptionalFlags - Flags for serializing
|
|
|
|
/// OverflowingBinaryOperator's SubclassOptionalData contents.
|
|
|
|
enum OverflowingBinaryOperatorOptionalFlags {
|
2009-08-20 19:11:38 +02:00
|
|
|
OBO_NO_UNSIGNED_WRAP = 0,
|
|
|
|
OBO_NO_SIGNED_WRAP = 1
|
2009-07-20 23:19:07 +02:00
|
|
|
};
|
|
|
|
|
2012-11-15 23:34:00 +01:00
|
|
|
/// PossiblyExactOperatorOptionalFlags - Flags for serializing
|
2011-02-06 22:44:57 +01:00
|
|
|
/// PossiblyExactOperator's SubclassOptionalData contents.
|
|
|
|
enum PossiblyExactOperatorOptionalFlags {
|
|
|
|
PEO_EXACT = 0
|
2009-07-20 23:19:07 +02:00
|
|
|
};
|
2009-02-21 00:04:06 +01:00
|
|
|
|
2011-07-26 01:16:38 +02:00
|
|
|
/// Encoded AtomicOrdering values.
|
|
|
|
enum AtomicOrderingCodes {
|
|
|
|
ORDERING_NOTATOMIC = 0,
|
|
|
|
ORDERING_UNORDERED = 1,
|
|
|
|
ORDERING_MONOTONIC = 2,
|
|
|
|
ORDERING_ACQUIRE = 3,
|
|
|
|
ORDERING_RELEASE = 4,
|
|
|
|
ORDERING_ACQREL = 5,
|
|
|
|
ORDERING_SEQCST = 6
|
|
|
|
};
|
|
|
|
|
|
|
|
/// Encoded SynchronizationScope values.
|
|
|
|
enum AtomicSynchScopeCodes {
|
|
|
|
SYNCHSCOPE_SINGLETHREAD = 0,
|
|
|
|
SYNCHSCOPE_CROSSTHREAD = 1
|
|
|
|
};
|
|
|
|
|
2007-04-26 07:53:04 +02:00
|
|
|
// The function body block (FUNCTION_BLOCK_ID) describes function bodies. It
|
|
|
|
// can contain a constant block (CONSTANTS_BLOCK_ID).
|
|
|
|
enum FunctionCodes {
|
|
|
|
FUNC_CODE_DECLAREBLOCKS = 1, // DECLAREBLOCKS: [n]
|
2009-02-21 00:04:06 +01:00
|
|
|
|
2007-04-26 07:53:04 +02:00
|
|
|
FUNC_CODE_INST_BINOP = 2, // BINOP: [opcode, ty, opval, opval]
|
|
|
|
FUNC_CODE_INST_CAST = 3, // CAST: [opcode, ty, opty, opval]
|
2015-02-25 02:08:52 +01:00
|
|
|
FUNC_CODE_INST_GEP_OLD = 4, // GEP: [n x operands]
|
2007-04-26 07:53:04 +02:00
|
|
|
FUNC_CODE_INST_SELECT = 5, // SELECT: [ty, opval, opval, opval]
|
|
|
|
FUNC_CODE_INST_EXTRACTELT = 6, // EXTRACTELT: [opty, opval, opval]
|
|
|
|
FUNC_CODE_INST_INSERTELT = 7, // INSERTELT: [ty, opval, opval, opval]
|
|
|
|
FUNC_CODE_INST_SHUFFLEVEC = 8, // SHUFFLEVEC: [ty, opval, opval, opval]
|
|
|
|
FUNC_CODE_INST_CMP = 9, // CMP: [opty, opval, opval, pred]
|
2009-02-21 00:04:06 +01:00
|
|
|
|
2007-05-04 21:10:48 +02:00
|
|
|
FUNC_CODE_INST_RET = 10, // RET: [opty,opval<both optional>]
|
2007-05-02 07:47:22 +02:00
|
|
|
FUNC_CODE_INST_BR = 11, // BR: [bb#, bb#, cond] or [bb#]
|
2009-10-27 22:27:42 +01:00
|
|
|
FUNC_CODE_INST_SWITCH = 12, // SWITCH: [opty, op0, op1, ...]
|
2007-05-08 07:38:32 +02:00
|
|
|
FUNC_CODE_INST_INVOKE = 13, // INVOKE: [attr, fnty, op0,op1, ...]
|
2012-02-06 22:55:35 +01:00
|
|
|
// 14 is unused.
|
2007-04-26 07:53:04 +02:00
|
|
|
FUNC_CODE_INST_UNREACHABLE = 15, // UNREACHABLE
|
2009-02-21 00:04:06 +01:00
|
|
|
|
2007-05-04 21:10:48 +02:00
|
|
|
FUNC_CODE_INST_PHI = 16, // PHI: [ty, val0,bb0, ...]
|
Revert r136253, r136263, r136269, r136313, r136325, r136326, r136329, r136338,
r136339, r136341, r136369, r136387, r136392, r136396, r136429, r136430, r136444,
r136445, r136446, r136253 pending review.
llvm-svn: 136556
2011-07-30 07:42:50 +02:00
|
|
|
// 17 is unused.
|
2011-06-17 20:09:11 +02:00
|
|
|
// 18 is unused.
|
2014-07-16 03:34:27 +02:00
|
|
|
FUNC_CODE_INST_ALLOCA = 19, // ALLOCA: [instty, opty, op, align]
|
2007-05-01 04:12:05 +02:00
|
|
|
FUNC_CODE_INST_LOAD = 20, // LOAD: [opty, op, align, vol]
|
2011-06-17 20:09:11 +02:00
|
|
|
// 21 is unused.
|
|
|
|
// 22 is unused.
|
2007-12-11 09:59:05 +01:00
|
|
|
FUNC_CODE_INST_VAARG = 23, // VAARG: [valistty, valist, instty]
|
|
|
|
// This store code encodes the pointer type, rather than the value type
|
|
|
|
// this is so information only available in the pointer type (e.g. address
|
|
|
|
// spaces) is retained.
|
2015-04-22 06:14:42 +02:00
|
|
|
FUNC_CODE_INST_STORE_OLD = 24, // STORE: [ptrty,ptr,val, align, vol]
|
2011-06-17 20:09:11 +02:00
|
|
|
// 25 is unused.
|
2008-05-23 03:55:30 +02:00
|
|
|
FUNC_CODE_INST_EXTRACTVAL = 26, // EXTRACTVAL: [n x operands]
|
2008-09-09 03:02:47 +02:00
|
|
|
FUNC_CODE_INST_INSERTVAL = 27, // INSERTVAL: [n x operands]
|
2009-07-08 05:04:38 +02:00
|
|
|
// fcmp/icmp returning Int1TY or vector of Int1Ty. Same as CMP, exists to
|
|
|
|
// support legacy vicmp/vfcmp instructions.
|
2008-09-23 20:27:53 +02:00
|
|
|
FUNC_CODE_INST_CMP2 = 28, // CMP2: [opty, opval, opval, pred]
|
2008-09-16 03:01:33 +02:00
|
|
|
// new select on i1 or [N x i1]
|
2009-07-27 23:53:46 +02:00
|
|
|
FUNC_CODE_INST_VSELECT = 29, // VSELECT: [ty,opval,opval,predty,pred]
|
2015-02-25 02:08:52 +01:00
|
|
|
FUNC_CODE_INST_INBOUNDS_GEP_OLD = 30, // INBOUNDS_GEP: [n x operands]
|
2010-04-03 04:17:50 +02:00
|
|
|
FUNC_CODE_INST_INDIRECTBR = 31, // INDIRECTBR: [opty, op0, op1, ...]
|
2011-06-17 20:09:11 +02:00
|
|
|
// 32 is unused.
|
2010-09-10 01:12:39 +02:00
|
|
|
FUNC_CODE_DEBUG_LOC_AGAIN = 33, // DEBUG_LOC_AGAIN
|
|
|
|
|
2014-04-18 20:19:18 +02:00
|
|
|
FUNC_CODE_INST_CALL = 34, // CALL: [attr, cc, fnty, fnid, args...]
|
2010-09-10 01:12:39 +02:00
|
|
|
|
2015-01-09 18:53:27 +01:00
|
|
|
FUNC_CODE_DEBUG_LOC = 35, // DEBUG_LOC: [Line,Col,ScopeVal, IAVal]
|
2011-07-27 22:18:04 +02:00
|
|
|
FUNC_CODE_INST_FENCE = 36, // FENCE: [ordering, synchscope]
|
2015-04-28 06:30:29 +02:00
|
|
|
FUNC_CODE_INST_CMPXCHG_OLD = 37, // CMPXCHG: [ptrty,ptr,cmp,new, align, vol,
|
2011-07-28 23:48:00 +02:00
|
|
|
// ordering, synchscope]
|
2011-07-31 08:30:59 +02:00
|
|
|
FUNC_CODE_INST_ATOMICRMW = 38, // ATOMICRMW: [ptrty,ptr,val, operation,
|
2011-07-28 23:48:00 +02:00
|
|
|
// align, vol,
|
|
|
|
// ordering, synchscope]
|
2011-08-10 01:02:53 +02:00
|
|
|
FUNC_CODE_INST_RESUME = 39, // RESUME: [opval]
|
2015-06-17 22:52:32 +02:00
|
|
|
FUNC_CODE_INST_LANDINGPAD_OLD = 40, // LANDINGPAD: [ty,val,val,num,id0,val0...]
|
2011-08-12 22:24:12 +02:00
|
|
|
FUNC_CODE_INST_LOADATOMIC = 41, // LOAD: [opty, op, align, vol,
|
2011-08-10 01:02:53 +02:00
|
|
|
// ordering, synchscope]
|
2015-04-22 06:14:46 +02:00
|
|
|
FUNC_CODE_INST_STOREATOMIC_OLD = 42, // STORE: [ptrty,ptr,val, align, vol
|
2011-08-10 01:02:53 +02:00
|
|
|
// ordering, synchscope]
|
2015-02-25 02:08:52 +01:00
|
|
|
FUNC_CODE_INST_GEP = 43, // GEP: [inbounds, n x operands]
|
2015-04-22 06:14:42 +02:00
|
|
|
FUNC_CODE_INST_STORE = 44, // STORE: [ptrty,ptr,valty,val, align, vol]
|
2015-04-22 06:14:46 +02:00
|
|
|
FUNC_CODE_INST_STOREATOMIC = 45, // STORE: [ptrty,ptr,val, align, vol
|
2015-04-28 06:30:29 +02:00
|
|
|
FUNC_CODE_INST_CMPXCHG = 46, // CMPXCHG: [ptrty,ptr,valty,cmp,new, align,
|
|
|
|
// vol,ordering,synchscope]
|
2015-06-17 22:52:32 +02:00
|
|
|
FUNC_CODE_INST_LANDINGPAD = 47, // LANDINGPAD: [ty,val,num,id0,val0...]
|
2015-07-31 19:58:14 +02:00
|
|
|
FUNC_CODE_INST_CLEANUPRET = 48, // CLEANUPRET: [] or [val] or [bb#] or [val,bb#]
|
|
|
|
FUNC_CODE_INST_CATCHRET = 49, // CATCHRET: [bb#]
|
|
|
|
FUNC_CODE_INST_CATCHPAD = 50, // CATCHPAD: [ty,val,val,num,args...]
|
|
|
|
FUNC_CODE_INST_TERMINATEPAD = 51, // TERMINATEPAD: [bb#,num,args...]
|
|
|
|
FUNC_CODE_INST_CLEANUPPAD = 52, // CLEANUPPAD: [num,args...]
|
|
|
|
FUNC_CODE_INST_CATCHENDPAD = 53, // CATCHENDPAD: [] or [bb#]
|
2007-04-26 07:53:04 +02:00
|
|
|
};
|
2011-12-07 22:44:12 +01:00
|
|
|
|
|
|
|
enum UseListCodes {
|
2014-07-28 23:19:41 +02:00
|
|
|
USELIST_CODE_DEFAULT = 1, // DEFAULT: [index..., value-id]
|
|
|
|
USELIST_CODE_BB = 2 // BB: [index..., bb-id]
|
2011-12-07 22:44:12 +01:00
|
|
|
};
|
2013-07-26 06:16:55 +02:00
|
|
|
|
|
|
|
enum AttributeKindCodes {
|
|
|
|
// = 0 is unused
|
|
|
|
ATTR_KIND_ALIGNMENT = 1,
|
|
|
|
ATTR_KIND_ALWAYS_INLINE = 2,
|
|
|
|
ATTR_KIND_BY_VAL = 3,
|
|
|
|
ATTR_KIND_INLINE_HINT = 4,
|
|
|
|
ATTR_KIND_IN_REG = 5,
|
|
|
|
ATTR_KIND_MIN_SIZE = 6,
|
|
|
|
ATTR_KIND_NAKED = 7,
|
|
|
|
ATTR_KIND_NEST = 8,
|
|
|
|
ATTR_KIND_NO_ALIAS = 9,
|
|
|
|
ATTR_KIND_NO_BUILTIN = 10,
|
|
|
|
ATTR_KIND_NO_CAPTURE = 11,
|
|
|
|
ATTR_KIND_NO_DUPLICATE = 12,
|
|
|
|
ATTR_KIND_NO_IMPLICIT_FLOAT = 13,
|
|
|
|
ATTR_KIND_NO_INLINE = 14,
|
|
|
|
ATTR_KIND_NON_LAZY_BIND = 15,
|
|
|
|
ATTR_KIND_NO_RED_ZONE = 16,
|
|
|
|
ATTR_KIND_NO_RETURN = 17,
|
|
|
|
ATTR_KIND_NO_UNWIND = 18,
|
|
|
|
ATTR_KIND_OPTIMIZE_FOR_SIZE = 19,
|
|
|
|
ATTR_KIND_READ_NONE = 20,
|
|
|
|
ATTR_KIND_READ_ONLY = 21,
|
|
|
|
ATTR_KIND_RETURNED = 22,
|
|
|
|
ATTR_KIND_RETURNS_TWICE = 23,
|
|
|
|
ATTR_KIND_S_EXT = 24,
|
|
|
|
ATTR_KIND_STACK_ALIGNMENT = 25,
|
|
|
|
ATTR_KIND_STACK_PROTECT = 26,
|
|
|
|
ATTR_KIND_STACK_PROTECT_REQ = 27,
|
|
|
|
ATTR_KIND_STACK_PROTECT_STRONG = 28,
|
|
|
|
ATTR_KIND_STRUCT_RET = 29,
|
|
|
|
ATTR_KIND_SANITIZE_ADDRESS = 30,
|
|
|
|
ATTR_KIND_SANITIZE_THREAD = 31,
|
|
|
|
ATTR_KIND_SANITIZE_MEMORY = 32,
|
|
|
|
ATTR_KIND_UW_TABLE = 33,
|
|
|
|
ATTR_KIND_Z_EXT = 34,
|
|
|
|
ATTR_KIND_BUILTIN = 35,
|
2013-08-23 13:53:55 +02:00
|
|
|
ATTR_KIND_COLD = 36,
|
2013-12-19 03:14:12 +01:00
|
|
|
ATTR_KIND_OPTIMIZE_NONE = 37,
|
2014-05-20 03:23:40 +02:00
|
|
|
ATTR_KIND_IN_ALLOCA = 38,
|
2014-06-05 21:29:43 +02:00
|
|
|
ATTR_KIND_NON_NULL = 39,
|
2014-07-18 17:51:28 +02:00
|
|
|
ATTR_KIND_JUMP_TABLE = 40,
|
2015-04-16 22:29:50 +02:00
|
|
|
ATTR_KIND_DEREFERENCEABLE = 41,
|
2015-05-27 01:48:40 +02:00
|
|
|
ATTR_KIND_DEREFERENCEABLE_OR_NULL = 42,
|
Protection against stack-based memory corruption errors using SafeStack
This patch adds the safe stack instrumentation pass to LLVM, which separates
the program stack into a safe stack, which stores return addresses, register
spills, and local variables that are statically verified to be accessed
in a safe way, and the unsafe stack, which stores everything else. Such
separation makes it much harder for an attacker to corrupt objects on the
safe stack, including function pointers stored in spilled registers and
return addresses. You can find more information about the safe stack, as
well as other parts of or control-flow hijack protection technique in our
OSDI paper on code-pointer integrity (http://dslab.epfl.ch/pubs/cpi.pdf)
and our project website (http://levee.epfl.ch).
The overhead of our implementation of the safe stack is very close to zero
(0.01% on the Phoronix benchmarks). This is lower than the overhead of
stack cookies, which are supported by LLVM and are commonly used today,
yet the security guarantees of the safe stack are strictly stronger than
stack cookies. In some cases, the safe stack improves performance due to
better cache locality.
Our current implementation of the safe stack is stable and robust, we
used it to recompile multiple projects on Linux including Chromium, and
we also recompiled the entire FreeBSD user-space system and more than 100
packages. We ran unit tests on the FreeBSD system and many of the packages
and observed no errors caused by the safe stack. The safe stack is also fully
binary compatible with non-instrumented code and can be applied to parts of
a program selectively.
This patch is our implementation of the safe stack on top of LLVM. The
patches make the following changes:
- Add the safestack function attribute, similar to the ssp, sspstrong and
sspreq attributes.
- Add the SafeStack instrumentation pass that applies the safe stack to all
functions that have the safestack attribute. This pass moves all unsafe local
variables to the unsafe stack with a separate stack pointer, whereas all
safe variables remain on the regular stack that is managed by LLVM as usual.
- Invoke the pass as the last stage before code generation (at the same time
the existing cookie-based stack protector pass is invoked).
- Add unit tests for the safe stack.
Original patch by Volodymyr Kuznetsov and others at the Dependable Systems
Lab at EPFL; updates and upstreaming by myself.
Differential Revision: http://reviews.llvm.org/D6094
llvm-svn: 239761
2015-06-15 23:07:11 +02:00
|
|
|
ATTR_KIND_CONVERGENT = 43,
|
|
|
|
ATTR_KIND_SAFESTACK = 44,
|
2015-07-28 06:05:45 +02:00
|
|
|
ATTR_KIND_ARGMEMONLY = 45,
|
|
|
|
ATTR_KIND_SWIFT_SELF = 46,
|
|
|
|
ATTR_KIND_SWIFT_ERROR = 47
|
2013-07-26 06:16:55 +02:00
|
|
|
};
|
|
|
|
|
2014-06-27 20:19:56 +02:00
|
|
|
enum ComdatSelectionKindCodes {
|
|
|
|
COMDAT_SELECTION_KIND_ANY = 1,
|
|
|
|
COMDAT_SELECTION_KIND_EXACT_MATCH = 2,
|
|
|
|
COMDAT_SELECTION_KIND_LARGEST = 3,
|
|
|
|
COMDAT_SELECTION_KIND_NO_DUPLICATES = 4,
|
|
|
|
COMDAT_SELECTION_KIND_SAME_SIZE = 5,
|
|
|
|
};
|
|
|
|
|
2015-06-23 11:49:53 +02:00
|
|
|
} // End bitc namespace
|
|
|
|
} // End llvm namespace
|
2007-04-23 03:01:15 +02:00
|
|
|
|
|
|
|
#endif
|