It's not necessary to do rounding for alloca operations when the requested
alignment is equal to the stack alignment.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40004 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/tools/llvm-upgrade/UpgradeInternals.h b/tools/llvm-upgrade/UpgradeInternals.h
new file mode 100644
index 0000000..0e00400
--- /dev/null
+++ b/tools/llvm-upgrade/UpgradeInternals.h
@@ -0,0 +1,395 @@
+//===-- ParserInternals.h - Definitions internal to the parser --*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This header file defines the various variables that are shared among the
+// different components of the parser...
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef PARSER_INTERNALS_H
+#define PARSER_INTERNALS_H
+
+#include "llvm/Constants.h"
+#include "llvm/DerivedTypes.h"
+#include "llvm/Function.h"
+#include "llvm/Instructions.h"
+#include "llvm/ADT/StringExtras.h"
+#include <list>
+#include <iostream>
+
+
+// Global variables exported from the lexer.
+extern int yydebug;
+extern void error(const std::string& msg, int line = -1);
+extern char* Upgradetext;
+extern int Upgradeleng;
+extern int Upgradelineno;
+
+namespace llvm {
+
+class Module;
+Module* UpgradeAssembly(const std::string &infile, std::istream& in,
+ bool debug, bool addAttrs);
+
+extern std::istream* LexInput;
+
+// UnEscapeLexed - Run through the specified buffer and change \xx codes to the
+// appropriate character. If AllowNull is set to false, a \00 value will cause
+// an error.
+//
+// If AllowNull is set to true, the return value of the function points to the
+// last character of the string in memory.
+//
+char *UnEscapeLexed(char *Buffer, bool AllowNull = false);
+
+/// InlineAsmDescriptor - This is a simple class that holds info about inline
+/// asm blocks, for use by ValID.
+struct InlineAsmDescriptor {
+ std::string AsmString, Constraints;
+ bool HasSideEffects;
+
+ InlineAsmDescriptor(const std::string &as, const std::string &c, bool HSE)
+ : AsmString(as), Constraints(c), HasSideEffects(HSE) {}
+};
+
+/// This class keeps track of the signedness of a type or value. It allows the
+/// signedness of a composite type to be captured in a relatively simple form.
+/// This is needed in order to retain the signedness of pre LLVM 2.0 types so
+/// they can be upgraded properly. Signedness of composite types must be
+/// captured in order to accurately get the signedness of a value through a
+/// GEP instruction.
+/// @brief Class to track signedness of types and values.
+struct Signedness {
+ /// The basic kinds of signedness values.
+ enum Kind {
+ Signless, ///< The type doesn't have any sign.
+ Unsigned, ///< The type is an unsigned integer.
+ Signed, ///< The type is a signed integer.
+ Named, ///< The type is a named type (probably forward ref or up ref).
+ Composite ///< The type is composite (struct, array, pointer).
+ };
+
+private:
+ /// @brief Keeps track of Signedness for composite types
+ typedef std::vector<Signedness> SignVector;
+ Kind kind; ///< The kind of signedness node
+ union {
+ SignVector *sv; ///< The vector of Signedness for composite types
+ std::string *name; ///< The name of the type for named types.
+ };
+public:
+ /// The Signedness class is used as a member of a union so it cannot have
+ /// a constructor or assignment operator. This function suffices.
+ /// @brief Copy one signedness value to another
+ void copy(const Signedness &that);
+ /// The Signedness class is used as a member of a union so it cannot have
+ /// a destructor.
+ /// @brief Release memory, if any allocated.
+ void destroy();
+
+ /// @brief Make a Signless node.
+ void makeSignless() { kind = Signless; sv = 0; }
+ /// @brief Make a Signed node.
+ void makeSigned() { kind = Signed; sv = 0; }
+ /// @brief Make an Unsigned node.
+ void makeUnsigned() { kind = Unsigned; sv = 0; }
+ /// @brief Make a Named node.
+ void makeNamed(const std::string& nm){
+ kind = Named; name = new std::string(nm);
+ }
+ /// @brief Make an empty Composite node.
+ void makeComposite() { kind = Composite; sv = new SignVector(); }
+ /// @brief Make an Composite node, with the first element given.
+ void makeComposite(const Signedness &S) {
+ kind = Composite;
+ sv = new SignVector();
+ sv->push_back(S);
+ }
+ /// @brief Add an element to a Composite node.
+ void add(const Signedness &S) {
+ assert(isComposite() && "Must be composite to use add");
+ sv->push_back(S);
+ }
+ bool operator<(const Signedness &that) const;
+ bool operator==(const Signedness &that) const;
+ bool isSigned() const { return kind == Signed; }
+ bool isUnsigned() const { return kind == Unsigned; }
+ bool isSignless() const { return kind == Signless; }
+ bool isNamed() const { return kind == Named; }
+ bool isComposite() const { return kind == Composite; }
+ /// This is used by GetElementPtr to extract the sign of an element.
+ /// @brief Get a specific element from a Composite node.
+ Signedness get(uint64_t idx) const {
+ assert(isComposite() && "Invalid Signedness type for get()");
+ assert(sv && idx < sv->size() && "Invalid index");
+ return (*sv)[idx];
+ }
+ /// @brief Get the name from a Named node.
+ const std::string& getName() const {
+ assert(isNamed() && "Can't get name from non-name Sign");
+ return *name;
+ }
+#ifndef NDEBUG
+ void dump() const;
+#endif
+};
+
+
+// ValID - Represents a reference of a definition of some sort. This may either
+// be a numeric reference or a symbolic (%var) reference. This is just a
+// discriminated union.
+//
+// Note that I can't implement this class in a straight forward manner with
+// constructors and stuff because it goes in a union.
+//
+struct ValID {
+ enum {
+ NumberVal, NameVal, ConstSIntVal, ConstUIntVal, ConstFPVal, ConstNullVal,
+ ConstUndefVal, ConstZeroVal, ConstantVal, InlineAsmVal
+ } Type;
+
+ union {
+ int Num; // If it's a numeric reference
+ char *Name; // If it's a named reference. Memory must be free'd.
+ int64_t ConstPool64; // Constant pool reference. This is the value
+ uint64_t UConstPool64;// Unsigned constant pool reference.
+ double ConstPoolFP; // Floating point constant pool reference
+ Constant *ConstantValue; // Fully resolved constant for ConstantVal case.
+ InlineAsmDescriptor *IAD;
+ };
+ Signedness S;
+
+ static ValID create(int Num) {
+ ValID D; D.Type = NumberVal; D.Num = Num; D.S.makeSignless();
+ return D;
+ }
+
+ static ValID create(char *Name) {
+ ValID D; D.Type = NameVal; D.Name = Name; D.S.makeSignless();
+ return D;
+ }
+
+ static ValID create(int64_t Val) {
+ ValID D; D.Type = ConstSIntVal; D.ConstPool64 = Val;
+ D.S.makeSigned();
+ return D;
+ }
+
+ static ValID create(uint64_t Val) {
+ ValID D; D.Type = ConstUIntVal; D.UConstPool64 = Val;
+ D.S.makeUnsigned();
+ return D;
+ }
+
+ static ValID create(double Val) {
+ ValID D; D.Type = ConstFPVal; D.ConstPoolFP = Val;
+ D.S.makeSignless();
+ return D;
+ }
+
+ static ValID createNull() {
+ ValID D; D.Type = ConstNullVal;
+ D.S.makeSignless();
+ return D;
+ }
+
+ static ValID createUndef() {
+ ValID D; D.Type = ConstUndefVal;
+ D.S.makeSignless();
+ return D;
+ }
+
+ static ValID createZeroInit() {
+ ValID D; D.Type = ConstZeroVal;
+ D.S.makeSignless();
+ return D;
+ }
+
+ static ValID create(Constant *Val) {
+ ValID D; D.Type = ConstantVal; D.ConstantValue = Val;
+ D.S.makeSignless();
+ return D;
+ }
+
+ static ValID createInlineAsm(const std::string &AsmString,
+ const std::string &Constraints,
+ bool HasSideEffects) {
+ ValID D;
+ D.Type = InlineAsmVal;
+ D.IAD = new InlineAsmDescriptor(AsmString, Constraints, HasSideEffects);
+ D.S.makeSignless();
+ return D;
+ }
+
+ inline void destroy() const {
+ if (Type == NameVal)
+ free(Name); // Free this strdup'd memory.
+ else if (Type == InlineAsmVal)
+ delete IAD;
+ }
+
+ inline ValID copy() const {
+ if (Type != NameVal) return *this;
+ ValID Result = *this;
+ Result.Name = strdup(Name);
+ return Result;
+ }
+
+ inline std::string getName() const {
+ switch (Type) {
+ case NumberVal : return std::string("#") + itostr(Num);
+ case NameVal : return Name;
+ case ConstFPVal : return ftostr(ConstPoolFP);
+ case ConstNullVal : return "null";
+ case ConstUndefVal : return "undef";
+ case ConstZeroVal : return "zeroinitializer";
+ case ConstUIntVal :
+ case ConstSIntVal : return std::string("%") + itostr(ConstPool64);
+ case ConstantVal:
+ if (ConstantValue == ConstantInt::get(Type::Int1Ty, true))
+ return "true";
+ if (ConstantValue == ConstantInt::get(Type::Int1Ty, false))
+ return "false";
+ return "<constant expression>";
+ default:
+ assert(0 && "Unknown value!");
+ abort();
+ return "";
+ }
+ }
+
+ bool operator<(const ValID &V) const {
+ if (Type != V.Type) return Type < V.Type;
+ switch (Type) {
+ case NumberVal: return Num < V.Num;
+ case NameVal: return strcmp(Name, V.Name) < 0;
+ case ConstSIntVal: return ConstPool64 < V.ConstPool64;
+ case ConstUIntVal: return UConstPool64 < V.UConstPool64;
+ case ConstFPVal: return ConstPoolFP < V.ConstPoolFP;
+ case ConstNullVal: return false;
+ case ConstUndefVal: return false;
+ case ConstZeroVal: return false;
+ case ConstantVal: return ConstantValue < V.ConstantValue;
+ default: assert(0 && "Unknown value type!"); return false;
+ }
+ }
+};
+
+/// The following enums are used to keep track of prior opcodes. The lexer will
+/// retain the ability to parse obsolete opcode mnemonics and generates semantic
+/// values containing one of these enumerators.
+enum TermOps {
+ RetOp, BrOp, SwitchOp, InvokeOp, UnwindOp, UnreachableOp
+};
+
+enum BinaryOps {
+ AddOp, SubOp, MulOp,
+ DivOp, UDivOp, SDivOp, FDivOp,
+ RemOp, URemOp, SRemOp, FRemOp,
+ AndOp, OrOp, XorOp,
+ ShlOp, ShrOp, LShrOp, AShrOp,
+ SetEQ, SetNE, SetLE, SetGE, SetLT, SetGT
+};
+
+enum MemoryOps {
+ MallocOp, FreeOp, AllocaOp, LoadOp, StoreOp, GetElementPtrOp
+};
+
+enum OtherOps {
+ PHIOp, CallOp, SelectOp, UserOp1, UserOp2, VAArg,
+ ExtractElementOp, InsertElementOp, ShuffleVectorOp,
+ ICmpOp, FCmpOp
+};
+
+enum CastOps {
+ CastOp, TruncOp, ZExtOp, SExtOp, FPTruncOp, FPExtOp, FPToUIOp, FPToSIOp,
+ UIToFPOp, SIToFPOp, PtrToIntOp, IntToPtrOp, BitCastOp
+};
+
+// An enumeration for the old calling conventions, ala LLVM 1.9
+namespace OldCallingConv {
+ enum ID {
+ C = 0, CSRet = 1, Fast = 8, Cold = 9, X86_StdCall = 64, X86_FastCall = 65,
+ None = 99999
+ };
+}
+
+/// These structures are used as the semantic values returned from various
+/// productions in the grammar. They simply bundle an LLVM IR object with
+/// its Signedness value. These help track signedness through the various
+/// productions.
+struct TypeInfo {
+ const llvm::Type *T;
+ Signedness S;
+ bool operator<(const TypeInfo& that) const {
+ if (this == &that)
+ return false;
+ if (T < that.T)
+ return true;
+ if (T == that.T) {
+ bool result = S < that.S;
+//#define TYPEINFO_DEBUG
+#ifdef TYPEINFO_DEBUG
+ std::cerr << (result?"true ":"false ") << T->getDescription() << " (";
+ S.dump();
+ std::cerr << ") < " << that.T->getDescription() << " (";
+ that.S.dump();
+ std::cerr << ")\n";
+#endif
+ return result;
+ }
+ return false;
+ }
+ bool operator==(const TypeInfo& that) const {
+ if (this == &that)
+ return true;
+ return T == that.T && S == that.S;
+ }
+ void destroy() { S.destroy(); }
+};
+
+struct PATypeInfo {
+ llvm::PATypeHolder* PAT;
+ Signedness S;
+ void destroy() { S.destroy(); delete PAT; }
+};
+
+struct ConstInfo {
+ llvm::Constant* C;
+ Signedness S;
+ void destroy() { S.destroy(); }
+};
+
+struct ValueInfo {
+ llvm::Value* V;
+ Signedness S;
+ void destroy() { S.destroy(); }
+};
+
+struct InstrInfo {
+ llvm::Instruction *I;
+ Signedness S;
+ void destroy() { S.destroy(); }
+};
+
+struct TermInstInfo {
+ llvm::TerminatorInst *TI;
+ Signedness S;
+ void destroy() { S.destroy(); }
+};
+
+struct PHIListInfo {
+ std::list<std::pair<llvm::Value*, llvm::BasicBlock*> > *P;
+ Signedness S;
+ void destroy() { S.destroy(); delete P; }
+};
+
+} // End llvm namespace
+
+#endif