lib/VMCore/LLVMContext.cpp

   1 //===-- LLVMContext.cpp - Implement LLVMContext -----------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/LLVMContext.h"
  11 #include "llvm/Constants.h"
  12 #include "LLVMContextImpl.h"
  13
  14 using namespace llvm;
  15
  16 LLVMContext::LLVMContext() : pImpl(new LLVMContextImpl()) { }
  17 LLVMContext::~LLVMContext() { delete pImpl; }
  18
  19 // ConstantInt accessors.
  20 ConstantInt* LLVMContext::getConstantIntTrue() {
  21   return ConstantInt::getTrue();
  22 }
  23
  24 ConstantInt* LLVMContext::getConstantIntFalse() {
  25   return ConstantInt::getFalse();
  26 }
  27
  28 ConstantInt* LLVMContext::getConstantInt(const IntegerType* Ty, uint64_t V,
  29                                          bool isSigned) {
  30   return ConstantInt::get(Ty, V, isSigned);
  31 }
  32
  33 ConstantInt* LLVMContext::getConstantIntSigned(const IntegerType* Ty,
  34                                                int64_t V) {
  35   return ConstantInt::getSigned(Ty, V);
  36 }
  37
  38 ConstantInt* LLVMContext::getConstantInt(const APInt& V) {
  39   return ConstantInt::get(V);
  40 }
  41
  42 Constant* LLVMContext::getConstantInt(const Type* Ty, const APInt& V) {
  43   return ConstantInt::get(Ty, V);
  44 }
  45
  46 ConstantInt* LLVMContext::getAllOnesConstantInt(const Type* Ty) {
  47   return ConstantInt::getAllOnesValue(Ty);
  48 }
  49
  50
  51 // ConstantPointerNull accessors.
  52 ConstantPointerNull* LLVMContext::getConstantPointerNull(const PointerType* T) {
  53   return ConstantPointerNull::get(T);
  54 }
  55
  56
  57 // ConstantStruct accessors.
  58 Constant* LLVMContext::getConstantStruct(const StructType* T,
  59                                          const std::vector<Constant*>& V) {
  60   return ConstantStruct::get(T, V);
  61 }
  62
  63 Constant* LLVMContext::getConstantStruct(const std::vector<Constant*>& V,
  64                                          bool Packed) {
  65   return ConstantStruct::get(V, Packed);
  66 }
  67
  68 Constant* LLVMContext::getConstantStruct(Constant* const *Vals,
  69                                          unsigned NumVals, bool Packed) {
  70   return ConstantStruct::get(Vals, NumVals, Packed);
  71 }
  72
  73
  74 // ConstantAggregateZero accessors.
  75 ConstantAggregateZero* LLVMContext::getConstantAggregateZero(const Type* Ty) {
  76   return ConstantAggregateZero::get(Ty);
  77 }
  78
  79
  80 // ConstantArray accessors.
  81 Constant* LLVMContext::getConstantArray(const ArrayType* T,
  82                                         const std::vector<Constant*>& V) {
  83   return ConstantArray::get(T, V);
  84 }
  85
  86 Constant* LLVMContext::getConstantArray(const ArrayType* T,
  87                                         Constant* const* Vals,
  88                                         unsigned NumVals) {
  89   return ConstantArray::get(T, Vals, NumVals);
  90 }
  91
  92 Constant* LLVMContext::getConstantArray(const std::string& Initializer,
  93                                         bool AddNull) {
  94   return ConstantArray::get(Initializer, AddNull);
  95 }
  96
  97
  98 // ConstantExpr accessors.
  99 Constant* LLVMContext::getConstantExpr(unsigned Opcode, Constant* C1,
 100                                        Constant* C2) {
 101   return ConstantExpr::get(Opcode, C1, C2);
 102 }
 103
 104 Constant* LLVMContext::getConstantExprTrunc(Constant* C, const Type* Ty) {
 105   return ConstantExpr::getTrunc(C, Ty);
 106 }
 107
 108 Constant* LLVMContext::getConstantExprSExt(Constant* C, const Type* Ty) {
 109   return ConstantExpr::getSExt(C, Ty);
 110 }
 111
 112 Constant* LLVMContext::getConstantExprZExt(Constant* C, const Type* Ty) {
 113   return ConstantExpr::getZExt(C, Ty);
 114 }
 115
 116 Constant* LLVMContext::getConstantExprFPTrunc(Constant* C, const Type* Ty) {
 117   return ConstantExpr::getFPTrunc(C, Ty);
 118 }
 119
 120 Constant* LLVMContext::getConstantExprFPExtend(Constant* C, const Type* Ty) {
 121   return ConstantExpr::getFPExtend(C, Ty);
 122 }
 123
 124 Constant* LLVMContext::getConstantExprUIToFP(Constant* C, const Type* Ty) {
 125   return ConstantExpr::getUIToFP(C, Ty);
 126 }
 127
 128 Constant* LLVMContext::getConstantExprSIToFP(Constant* C, const Type* Ty) {
 129   return ConstantExpr::getSIToFP(C, Ty);
 130 }
 131
 132 Constant* LLVMContext::getConstantExprFPToUI(Constant* C, const Type* Ty) {
 133   return ConstantExpr::getFPToUI(C, Ty);
 134 }
 135
 136 Constant* LLVMContext::getConstantExprFPToSI(Constant* C, const Type* Ty) {
 137   return ConstantExpr::getFPToSI(C, Ty);
 138 }
 139
 140 Constant* LLVMContext::getConstantExprPtrToInt(Constant* C, const Type* Ty) {
 141   return ConstantExpr::getPtrToInt(C, Ty);
 142 }
 143
 144 Constant* LLVMContext::getConstantExprIntToPtr(Constant* C, const Type* Ty) {
 145   return ConstantExpr::getIntToPtr(C, Ty);
 146 }
 147
 148 Constant* LLVMContext::getConstantExprBitCast(Constant* C, const Type* Ty) {
 149   return ConstantExpr::getBitCast(C, Ty);
 150 }
 151
 152 Constant* LLVMContext::getConstantExprCast(unsigned ops, Constant* C,
 153                                            const Type* Ty) {
 154   return ConstantExpr::getCast(ops, C, Ty);
 155 }
 156
 157 Constant* LLVMContext::getConstantExprZExtOrBitCast(Constant* C,
 158                                                     const Type* Ty) {
 159   return ConstantExpr::getZExtOrBitCast(C, Ty);
 160 }
 161
 162 Constant* LLVMContext::getConstantExprSExtOrBitCast(Constant* C,
 163                                                     const Type* Ty) {
 164   return ConstantExpr::getSExtOrBitCast(C, Ty);
 165 }
 166
 167 Constant* LLVMContext::getConstantExprTruncOrBitCast(Constant* C,
 168                                                      const Type* Ty) {
 169   return ConstantExpr::getTruncOrBitCast(C, Ty);
 170 }
 171
 172 Constant* LLVMContext::getConstantExprPointerCast(Constant* C, const Type* Ty) {
 173   return ConstantExpr::getPointerCast(C, Ty);
 174 }
 175
 176 Constant* LLVMContext::getConstantExprIntegerCast(Constant* C, const Type* Ty,
 177                                                   bool isSigned) {
 178   return ConstantExpr::getIntegerCast(C, Ty, isSigned);
 179 }
 180
 181 Constant* LLVMContext::getConstantExprFPCast(Constant* C, const Type* Ty) {
 182   return ConstantExpr::getFPCast(C, Ty);
 183 }
 184
 185 Constant* LLVMContext::getConstantExprSelect(Constant* C, Constant* V1,
 186                                              Constant* V2) {
 187   return ConstantExpr::getSelect(C, V1, V2);
 188 }
 189
 190 Constant* LLVMContext::getConstantExprAlignOf(const Type* Ty) {
 191   return ConstantExpr::getAlignOf(Ty);
 192 }
 193
 194 Constant* LLVMContext::getConstantExprCompare(unsigned short pred,
 195                                  Constant* C1, Constant* C2) {
 196   return ConstantExpr::getCompare(pred, C1, C2);
 197 }
 198
 199 Constant* LLVMContext::getConstantExprNeg(Constant* C) {
 200   return ConstantExpr::getNeg(C);
 201 }
 202
 203 Constant* LLVMContext::getConstantExprFNeg(Constant* C) {
 204   return ConstantExpr::getFNeg(C);
 205 }
 206
 207 Constant* LLVMContext::getConstantExprNot(Constant* C) {
 208   return ConstantExpr::getNot(C);
 209 }
 210
 211 Constant* LLVMContext::getConstantExprAdd(Constant* C1, Constant* C2) {
 212   return ConstantExpr::getAdd(C1, C2);
 213 }
 214
 215 Constant* LLVMContext::getConstantExprFAdd(Constant* C1, Constant* C2) {
 216   return ConstantExpr::getFAdd(C1, C2);
 217 }
 218
 219 Constant* LLVMContext::getConstantExprSub(Constant* C1, Constant* C2) {
 220   return ConstantExpr::getSub(C1, C2);
 221 }
 222
 223 Constant* LLVMContext::getConstantExprFSub(Constant* C1, Constant* C2) {
 224   return ConstantExpr::getFSub(C1, C2);
 225 }
 226
 227 Constant* LLVMContext::getConstantExprMul(Constant* C1, Constant* C2) {
 228   return ConstantExpr::getMul(C1, C2);
 229 }
 230
 231 Constant* LLVMContext::getConstantExprFMul(Constant* C1, Constant* C2) {
 232   return ConstantExpr::getFMul(C1, C2);
 233 }
 234
 235 Constant* LLVMContext::getConstantExprUDiv(Constant* C1, Constant* C2) {
 236   return ConstantExpr::getUDiv(C1, C2);
 237 }
 238
 239 Constant* LLVMContext::getConstantExprSDiv(Constant* C1, Constant* C2) {
 240   return ConstantExpr::getSDiv(C1, C2);
 241 }
 242
 243 Constant* LLVMContext::getConstantExprFDiv(Constant* C1, Constant* C2) {
 244   return ConstantExpr::getFDiv(C1, C2);
 245 }
 246
 247 Constant* LLVMContext::getConstantExprURem(Constant* C1, Constant* C2) {
 248   return ConstantExpr::getURem(C1, C2);
 249 }
 250
 251 Constant* LLVMContext::getConstantExprSRem(Constant* C1, Constant* C2) {
 252   return ConstantExpr::getSRem(C1, C2);
 253 }
 254
 255 Constant* LLVMContext::getConstantExprFRem(Constant* C1, Constant* C2) {
 256   return ConstantExpr::getFRem(C1, C2);
 257 }
 258
 259 Constant* LLVMContext::getConstantExprAnd(Constant* C1, Constant* C2) {
 260   return ConstantExpr::getAnd(C1, C2);
 261 }
 262
 263 Constant* LLVMContext::getConstantExprOr(Constant* C1, Constant* C2) {
 264   return ConstantExpr::getOr(C1, C2);
 265 }
 266
 267 Constant* LLVMContext::getConstantExprXor(Constant* C1, Constant* C2) {
 268   return ConstantExpr::getXor(C1, C2);
 269 }
 270
 271 Constant* LLVMContext::getConstantExprICmp(unsigned short pred, Constant* LHS,
 272                               Constant* RHS) {
 273   return ConstantExpr::getICmp(pred, LHS, RHS);
 274 }
 275
 276 Constant* LLVMContext::getConstantExprFCmp(unsigned short pred, Constant* LHS,
 277                               Constant* RHS) {
 278   return ConstantExpr::getFCmp(pred, LHS, RHS);
 279 }
 280
 281 Constant* LLVMContext::getConstantExprVICmp(unsigned short pred, Constant* LHS,
 282                                Constant* RHS) {
 283   return ConstantExpr::getVICmp(pred, LHS, RHS);
 284 }
 285
 286 Constant* LLVMContext::getConstantExprVFCmp(unsigned short pred, Constant* LHS,
 287                                Constant* RHS) {
 288   return ConstantExpr::getVFCmp(pred, LHS, RHS);
 289 }
 290
 291 Constant* LLVMContext::getConstantExprShl(Constant* C1, Constant* C2) {
 292   return ConstantExpr::getShl(C1, C2);
 293 }
 294
 295 Constant* LLVMContext::getConstantExprLShr(Constant* C1, Constant* C2) {
 296   return ConstantExpr::getLShr(C1, C2);
 297 }
 298
 299 Constant* LLVMContext::getConstantExprAShr(Constant* C1, Constant* C2) {
 300   return ConstantExpr::getAShr(C1, C2);
 301 }
 302
 303 Constant* LLVMContext::getConstantExprGetElementPtr(Constant* C,
 304                                                     Constant* const* IdxList,
 305                                                     unsigned NumIdx) {
 306   return ConstantExpr::getGetElementPtr(C, IdxList, NumIdx);
 307 }
 308
 309 Constant* LLVMContext::getConstantExprGetElementPtr(Constant* C,
 310                                                     Value* const* IdxList,
 311                                                     unsigned NumIdx) {
 312   return ConstantExpr::getGetElementPtr(C, IdxList, NumIdx);
 313 }
 314
 315 Constant* LLVMContext::getConstantExprExtractElement(Constant* Vec,
 316                                                      Constant* Idx) {
 317   return ConstantExpr::getExtractElement(Vec, Idx);
 318 }
 319
 320 Constant* LLVMContext::getConstantExprInsertElement(Constant* Vec,
 321                                                     Constant* Elt,
 322                                                     Constant* Idx) {
 323   return ConstantExpr::getInsertElement(Vec, Elt, Idx);
 324 }
 325
 326 Constant* LLVMContext::getConstantExprShuffleVector(Constant* V1, Constant* V2,
 327                                                     Constant* Mask) {
 328   return ConstantExpr::getShuffleVector(V1, V2, Mask);
 329 }
 330
 331 Constant* LLVMContext::getConstantExprExtractValue(Constant* Agg,
 332                                                    const unsigned* IdxList,
 333                                                    unsigned NumIdx) {
 334   return ConstantExpr::getExtractValue(Agg, IdxList, NumIdx);
 335 }
 336
 337 Constant* LLVMContext::getConstantExprInsertValue(Constant* Agg, Constant* Val,
 338                                                   const unsigned* IdxList,
 339                                                   unsigned NumIdx) {
 340   return ConstantExpr::getInsertValue(Agg, Val, IdxList, NumIdx);
 341 }
 342
 343 Constant* LLVMContext::getZeroValueForNegation(const Type* Ty) {
 344   return ConstantExpr::getZeroValueForNegationExpr(Ty);
 345 }
 346
 347
 348 // ConstantFP accessors.
 349 ConstantFP* LLVMContext::getConstantFP(const APFloat& V) {
 350   return ConstantFP::get(V);
 351 }
 352
 353 Constant* LLVMContext::getConstantFP(const Type* Ty, double V) {
 354   return ConstantFP::get(Ty, V);
 355 }
 356
 357 ConstantFP* LLVMContext::getConstantFPNegativeZero(const Type* Ty) {
 358   return ConstantFP::getNegativeZero(Ty);
 359 }
 360
 361
 362 // ConstantVector accessors.
 363 Constant* LLVMContext::getConstantVector(const VectorType* T,
 364                             const std::vector<Constant*>& V) {
 365   return ConstantVector::get(T, V);
 366 }
 367
 368 Constant* LLVMContext::getConstantVector(const std::vector<Constant*>& V) {
 369   return ConstantVector::get(V);
 370 }
 371
 372 Constant* LLVMContext::getConstantVector(Constant* const* Vals,
 373                                          unsigned NumVals) {
 374   return ConstantVector::get(Vals, NumVals);
 375 }
 376
 377 ConstantVector* LLVMContext::getConstantVectorAllOnes(const VectorType* Ty) {
 378   return ConstantVector::getAllOnesValue(Ty);
 379 }