lib/VMCore/AutoUpgrade.cpp

   1 //===-- AutoUpgrade.cpp - Implement auto-upgrade helper functions ---------===//
   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 // This file implements the auto-upgrade helper functions
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/AutoUpgrade.h"
  15 #include "llvm/Constants.h"
  16 #include "llvm/Function.h"
  17 #include "llvm/LLVMContext.h"
  18 #include "llvm/Module.h"
  19 #include "llvm/IntrinsicInst.h"
  20 #include "llvm/ADT/SmallVector.h"
  21 #include "llvm/Support/CallSite.h"
  22 #include "llvm/Support/ErrorHandling.h"
  23 #include "llvm/Support/IRBuilder.h"
  24 #include <cstring>
  25 using namespace llvm;
  26
  27
  28 static bool UpgradeIntrinsicFunction1(Function *F, Function *&NewFn) {
  29   assert(F && "Illegal to upgrade a non-existent Function.");
  30
  31   // Get the Function's name.
  32   const std::string& Name = F->getName();
  33
  34   // Convenience
  35   const FunctionType *FTy = F->getFunctionType();
  36
  37   // Quickly eliminate it, if it's not a candidate.
  38   if (Name.length() <= 8 || Name[0] != 'l' || Name[1] != 'l' ||
  39       Name[2] != 'v' || Name[3] != 'm' || Name[4] != '.')
  40     return false;
  41
  42   Module *M = F->getParent();
  43   switch (Name[5]) {
  44   default: break;
  45   case 'a':
  46     // This upgrades the llvm.atomic.lcs, llvm.atomic.las, llvm.atomic.lss,
  47     // and atomics with default address spaces to their new names to their new
  48     // function name (e.g. llvm.atomic.add.i32 => llvm.atomic.add.i32.p0i32)
  49     if (Name.compare(5,7,"atomic.",7) == 0) {
  50       if (Name.compare(12,3,"lcs",3) == 0) {
  51         std::string::size_type delim = Name.find('.',12);
  52         F->setName("llvm.atomic.cmp.swap" + Name.substr(delim) +
  53                    ".p0" + Name.substr(delim+1));
  54         NewFn = F;
  55         return true;
  56       }
  57       else if (Name.compare(12,3,"las",3) == 0) {
  58         std::string::size_type delim = Name.find('.',12);
  59         F->setName("llvm.atomic.load.add"+Name.substr(delim)
  60                    + ".p0" + Name.substr(delim+1));
  61         NewFn = F;
  62         return true;
  63       }
  64       else if (Name.compare(12,3,"lss",3) == 0) {
  65         std::string::size_type delim = Name.find('.',12);
  66         F->setName("llvm.atomic.load.sub"+Name.substr(delim)
  67                    + ".p0" + Name.substr(delim+1));
  68         NewFn = F;
  69         return true;
  70       }
  71       else if (Name.rfind(".p") == std::string::npos) {
  72         // We don't have an address space qualifier so this has be upgraded
  73         // to the new name.  Copy the type name at the end of the intrinsic
  74         // and add to it
  75         std::string::size_type delim = Name.find_last_of('.');
  76         assert(delim != std::string::npos && "can not find type");
  77         F->setName(Name + ".p0" + Name.substr(delim+1));
  78         NewFn = F;
  79         return true;
  80       }
  81     } else if (Name.compare(5, 9, "arm.neon.", 9) == 0) {
  82       if (((Name.compare(14, 5, "vmovl", 5) == 0 ||
  83             Name.compare(14, 5, "vaddl", 5) == 0 ||
  84             Name.compare(14, 5, "vsubl", 5) == 0 ||
  85             Name.compare(14, 5, "vaddw", 5) == 0 ||
  86             Name.compare(14, 5, "vsubw", 5) == 0 ||
  87             Name.compare(14, 5, "vmlal", 5) == 0 ||
  88             Name.compare(14, 5, "vmlsl", 5) == 0 ||
  89             Name.compare(14, 5, "vabdl", 5) == 0 ||
  90             Name.compare(14, 5, "vabal", 5) == 0) &&
  91            (Name.compare(19, 2, "s.", 2) == 0 ||
  92             Name.compare(19, 2, "u.", 2) == 0)) ||
  93
  94           (Name.compare(14, 4, "vaba", 4) == 0 &&
  95            (Name.compare(18, 2, "s.", 2) == 0 ||
  96             Name.compare(18, 2, "u.", 2) == 0)) ||
  97
  98           (Name.compare(14, 6, "vmovn.", 6) == 0)) {
  99
 100         // Calls to these are transformed into IR without intrinsics.
 101         NewFn = 0;
 102         return true;
 103       }
 104       // Old versions of NEON ld/st intrinsics are missing alignment arguments.
 105       bool isVLd = (Name.compare(14, 3, "vld", 3) == 0);
 106       bool isVSt = (Name.compare(14, 3, "vst", 3) == 0);
 107       if (isVLd || isVSt) {
 108         unsigned NumVecs = Name.at(17) - '0';
 109         if (NumVecs == 0 || NumVecs > 4)
 110           return false;
 111         bool isLaneOp = (Name.compare(18, 5, "lane.", 5) == 0);
 112         if (!isLaneOp && Name.at(18) != '.')
 113           return false;
 114         unsigned ExpectedArgs = 2; // for the address and alignment
 115         if (isVSt || isLaneOp)
 116           ExpectedArgs += NumVecs;
 117         if (isLaneOp)
 118           ExpectedArgs += 1; // for the lane number
 119         unsigned NumP = FTy->getNumParams();
 120         if (NumP != ExpectedArgs - 1)
 121           return false;
 122
 123         // Change the name of the old (bad) intrinsic, because
 124         // its type is incorrect, but we cannot overload that name.
 125         F->setName("");
 126
 127         // One argument is missing: add the alignment argument.
 128         std::vector<const Type*> NewParams;
 129         for (unsigned p = 0; p < NumP; ++p)
 130           NewParams.push_back(FTy->getParamType(p));
 131         NewParams.push_back(Type::getInt32Ty(F->getContext()));
 132         FunctionType *NewFTy = FunctionType::get(FTy->getReturnType(),
 133                                                  NewParams, false);
 134         NewFn = cast<Function>(M->getOrInsertFunction(Name, NewFTy));
 135         return true;
 136       }
 137     }
 138     break;
 139   case 'b':
 140     //  This upgrades the name of the llvm.bswap intrinsic function to only use
 141     //  a single type name for overloading. We only care about the old format
 142     //  'llvm.bswap.i*.i*', so check for 'bswap.' and then for there being
 143     //  a '.' after 'bswap.'
 144     if (Name.compare(5,6,"bswap.",6) == 0) {
 145       std::string::size_type delim = Name.find('.',11);
 146
 147       if (delim != std::string::npos) {
 148         //  Construct the new name as 'llvm.bswap' + '.i*'
 149         F->setName(Name.substr(0,10)+Name.substr(delim));
 150         NewFn = F;
 151         return true;
 152       }
 153     }
 154     break;
 155
 156   case 'c':
 157     //  We only want to fix the 'llvm.ct*' intrinsics which do not have the
 158     //  correct return type, so we check for the name, and then check if the
 159     //  return type does not match the parameter type.
 160     if ( (Name.compare(5,5,"ctpop",5) == 0 ||
 161           Name.compare(5,4,"ctlz",4) == 0 ||
 162           Name.compare(5,4,"cttz",4) == 0) &&
 163         FTy->getReturnType() != FTy->getParamType(0)) {
 164       //  We first need to change the name of the old (bad) intrinsic, because
 165       //  its type is incorrect, but we cannot overload that name. We
 166       //  arbitrarily unique it here allowing us to construct a correctly named
 167       //  and typed function below.
 168       F->setName("");
 169
 170       //  Now construct the new intrinsic with the correct name and type. We
 171       //  leave the old function around in order to query its type, whatever it
 172       //  may be, and correctly convert up to the new type.
 173       NewFn = cast<Function>(M->getOrInsertFunction(Name,
 174                                                     FTy->getParamType(0),
 175                                                     FTy->getParamType(0),
 176                                                     (Type *)0));
 177       return true;
 178     }
 179     break;
 180
 181   case 'e':
 182     //  The old llvm.eh.selector.i32 is equivalent to the new llvm.eh.selector.
 183     if (Name.compare("llvm.eh.selector.i32") == 0) {
 184       F->setName("llvm.eh.selector");
 185       NewFn = F;
 186       return true;
 187     }
 188     //  The old llvm.eh.typeid.for.i32 is equivalent to llvm.eh.typeid.for.
 189     if (Name.compare("llvm.eh.typeid.for.i32") == 0) {
 190       F->setName("llvm.eh.typeid.for");
 191       NewFn = F;
 192       return true;
 193     }
 194     //  Convert the old llvm.eh.selector.i64 to a call to llvm.eh.selector.
 195     if (Name.compare("llvm.eh.selector.i64") == 0) {
 196       NewFn = Intrinsic::getDeclaration(M, Intrinsic::eh_selector);
 197       return true;
 198     }
 199     //  Convert the old llvm.eh.typeid.for.i64 to a call to llvm.eh.typeid.for.
 200     if (Name.compare("llvm.eh.typeid.for.i64") == 0) {
 201       NewFn = Intrinsic::getDeclaration(M, Intrinsic::eh_typeid_for);
 202       return true;
 203     }
 204     break;
 205
 206   case 'm': {
 207     // This upgrades the llvm.memcpy, llvm.memmove, and llvm.memset to the
 208     // new format that allows overloading the pointer for different address
 209     // space (e.g., llvm.memcpy.i16 => llvm.memcpy.p0i8.p0i8.i16)
 210     const char* NewFnName = NULL;
 211     if (Name.compare(5,8,"memcpy.i",8) == 0) {
 212       if (Name[13] == '8')
 213         NewFnName = "llvm.memcpy.p0i8.p0i8.i8";
 214       else if (Name.compare(13,2,"16") == 0)
 215         NewFnName = "llvm.memcpy.p0i8.p0i8.i16";
 216       else if (Name.compare(13,2,"32") == 0)
 217         NewFnName = "llvm.memcpy.p0i8.p0i8.i32";
 218       else if (Name.compare(13,2,"64") == 0)
 219         NewFnName = "llvm.memcpy.p0i8.p0i8.i64";
 220     } else if (Name.compare(5,9,"memmove.i",9) == 0) {
 221       if (Name[14] == '8')
 222         NewFnName = "llvm.memmove.p0i8.p0i8.i8";
 223       else if (Name.compare(14,2,"16") == 0)
 224         NewFnName = "llvm.memmove.p0i8.p0i8.i16";
 225       else if (Name.compare(14,2,"32") == 0)
 226         NewFnName = "llvm.memmove.p0i8.p0i8.i32";
 227       else if (Name.compare(14,2,"64") == 0)
 228         NewFnName = "llvm.memmove.p0i8.p0i8.i64";
 229     }
 230     else if (Name.compare(5,8,"memset.i",8) == 0) {
 231       if (Name[13] == '8')
 232         NewFnName = "llvm.memset.p0i8.i8";
 233       else if (Name.compare(13,2,"16") == 0)
 234         NewFnName = "llvm.memset.p0i8.i16";
 235       else if (Name.compare(13,2,"32") == 0)
 236         NewFnName = "llvm.memset.p0i8.i32";
 237       else if (Name.compare(13,2,"64") == 0)
 238         NewFnName = "llvm.memset.p0i8.i64";
 239     }
 240     if (NewFnName) {
 241       NewFn = cast<Function>(M->getOrInsertFunction(NewFnName,
 242                                             FTy->getReturnType(),
 243                                             FTy->getParamType(0),
 244                                             FTy->getParamType(1),
 245                                             FTy->getParamType(2),
 246                                             FTy->getParamType(3),
 247                                             Type::getInt1Ty(F->getContext()),
 248                                             (Type *)0));
 249       return true;
 250     }
 251     break;
 252   }
 253   case 'p':
 254     //  This upgrades the llvm.part.select overloaded intrinsic names to only
 255     //  use one type specifier in the name. We only care about the old format
 256     //  'llvm.part.select.i*.i*', and solve as above with bswap.
 257     if (Name.compare(5,12,"part.select.",12) == 0) {
 258       std::string::size_type delim = Name.find('.',17);
 259
 260       if (delim != std::string::npos) {
 261         //  Construct a new name as 'llvm.part.select' + '.i*'
 262         F->setName(Name.substr(0,16)+Name.substr(delim));
 263         NewFn = F;
 264         return true;
 265       }
 266       break;
 267     }
 268
 269     //  This upgrades the llvm.part.set intrinsics similarly as above, however
 270     //  we care about 'llvm.part.set.i*.i*.i*', but only the first two types
 271     //  must match. There is an additional type specifier after these two
 272     //  matching types that we must retain when upgrading.  Thus, we require
 273     //  finding 2 periods, not just one, after the intrinsic name.
 274     if (Name.compare(5,9,"part.set.",9) == 0) {
 275       std::string::size_type delim = Name.find('.',14);
 276
 277       if (delim != std::string::npos &&
 278           Name.find('.',delim+1) != std::string::npos) {
 279         //  Construct a new name as 'llvm.part.select' + '.i*.i*'
 280         F->setName(Name.substr(0,13)+Name.substr(delim));
 281         NewFn = F;
 282         return true;
 283       }
 284       break;
 285     }
 286
 287     break;
 288   case 'x':
 289     // This fixes all MMX shift intrinsic instructions to take a
 290     // x86_mmx instead of a v1i64, v2i32, v4i16, or v8i8.
 291     if (Name.compare(5, 8, "x86.mmx.", 8) == 0) {
 292       const Type *X86_MMXTy = VectorType::getX86_MMXTy(FTy->getContext());
 293
 294       if (Name.compare(13, 4, "padd", 4) == 0   ||
 295           Name.compare(13, 4, "psub", 4) == 0   ||
 296           Name.compare(13, 4, "pmul", 4) == 0   ||
 297           Name.compare(13, 5, "pmadd", 5) == 0  ||
 298           Name.compare(13, 4, "pand", 4) == 0   ||
 299           Name.compare(13, 3, "por", 3) == 0    ||
 300           Name.compare(13, 4, "pxor", 4) == 0   ||
 301           Name.compare(13, 4, "pavg", 4) == 0   ||
 302           Name.compare(13, 4, "pmax", 4) == 0   ||
 303           Name.compare(13, 4, "pmin", 4) == 0   ||
 304           Name.compare(13, 4, "psad", 4) == 0   ||
 305           Name.compare(13, 4, "psll", 4) == 0   ||
 306           Name.compare(13, 4, "psrl", 4) == 0   ||
 307           Name.compare(13, 4, "psra", 4) == 0   ||
 308           Name.compare(13, 4, "pack", 4) == 0   ||
 309           Name.compare(13, 6, "punpck", 6) == 0 ||
 310           Name.compare(13, 4, "pcmp", 4) == 0) {
 311         assert(FTy->getNumParams() == 2 && "MMX intrinsic takes 2 args!");
 312         const Type *SecondParamTy = X86_MMXTy;
 313
 314         if (Name.compare(13, 5, "pslli", 5) == 0 ||
 315             Name.compare(13, 5, "psrli", 5) == 0 ||
 316             Name.compare(13, 5, "psrai", 5) == 0)
 317           SecondParamTy = FTy->getParamType(1);
 318
 319         // Don't do anything if it has the correct types.
 320         if (FTy->getReturnType() == X86_MMXTy &&
 321             FTy->getParamType(0) == X86_MMXTy &&
 322             FTy->getParamType(1) == SecondParamTy)
 323           break;
 324
 325         // We first need to change the name of the old (bad) intrinsic, because
 326         // its type is incorrect, but we cannot overload that name. We
 327         // arbitrarily unique it here allowing us to construct a correctly named
 328         // and typed function below.
 329         F->setName("");
 330
 331         // Now construct the new intrinsic with the correct name and type. We
 332         // leave the old function around in order to query its type, whatever it
 333         // may be, and correctly convert up to the new type.
 334         NewFn = cast<Function>(M->getOrInsertFunction(Name,
 335                                                       X86_MMXTy, X86_MMXTy,
 336                                                       SecondParamTy, (Type*)0));
 337         return true;
 338       }
 339
 340       if (Name.compare(13, 8, "maskmovq", 8) == 0) {
 341         // Don't do anything if it has the correct types.
 342         if (FTy->getParamType(0) == X86_MMXTy &&
 343             FTy->getParamType(1) == X86_MMXTy)
 344           break;
 345
 346         F->setName("");
 347         NewFn = cast<Function>(M->getOrInsertFunction(Name,
 348                                                       FTy->getReturnType(),
 349                                                       X86_MMXTy,
 350                                                       X86_MMXTy,
 351                                                       FTy->getParamType(2),
 352                                                       (Type*)0));
 353         return true;
 354       }
 355
 356       if (Name.compare(13, 8, "pmovmskb", 8) == 0) {
 357         if (FTy->getParamType(0) == X86_MMXTy)
 358           break;
 359
 360         F->setName("");
 361         NewFn = cast<Function>(M->getOrInsertFunction(Name,
 362                                                       FTy->getReturnType(),
 363                                                       X86_MMXTy,
 364                                                       (Type*)0));
 365         return true;
 366       }
 367
 368       if (Name.compare(13, 5, "movnt", 5) == 0) {
 369         if (FTy->getParamType(1) == X86_MMXTy)
 370           break;
 371
 372         F->setName("");
 373         NewFn = cast<Function>(M->getOrInsertFunction(Name,
 374                                                       FTy->getReturnType(),
 375                                                       FTy->getParamType(0),
 376                                                       X86_MMXTy,
 377                                                       (Type*)0));
 378         return true;
 379       }
 380
 381       if (Name.compare(13, 7, "palignr", 7) == 0) {
 382         if (FTy->getReturnType() == X86_MMXTy &&
 383             FTy->getParamType(0) == X86_MMXTy &&
 384             FTy->getParamType(1) == X86_MMXTy)
 385           break;
 386
 387         F->setName("");
 388         NewFn = cast<Function>(M->getOrInsertFunction(Name,
 389                                                       X86_MMXTy,
 390                                                       X86_MMXTy,
 391                                                       X86_MMXTy,
 392                                                       FTy->getParamType(2),
 393                                                       (Type*)0));
 394         return true;
 395       }
 396
 397       if (Name.compare(13, 5, "pextr", 5) == 0) {
 398         if (FTy->getParamType(0) == X86_MMXTy)
 399           break;
 400
 401         F->setName("");
 402         NewFn = cast<Function>(M->getOrInsertFunction(Name,
 403                                                       FTy->getReturnType(),
 404                                                       X86_MMXTy,
 405                                                       FTy->getParamType(1),
 406                                                       (Type*)0));
 407         return true;
 408       }
 409
 410       if (Name.compare(13, 5, "pinsr", 5) == 0) {
 411         if (FTy->getReturnType() == X86_MMXTy &&
 412             FTy->getParamType(0) == X86_MMXTy)
 413           break;
 414
 415         F->setName("");
 416         NewFn = cast<Function>(M->getOrInsertFunction(Name,
 417                                                       X86_MMXTy,
 418                                                       X86_MMXTy,
 419                                                       FTy->getParamType(1),
 420                                                       FTy->getParamType(2),
 421                                                       (Type*)0));
 422         return true;
 423       }
 424
 425       if (Name.compare(13, 12, "cvtsi32.si64", 12) == 0) {
 426         if (FTy->getReturnType() == X86_MMXTy)
 427           break;
 428
 429         F->setName("");
 430         NewFn = cast<Function>(M->getOrInsertFunction(Name,
 431                                                       X86_MMXTy,
 432                                                       FTy->getParamType(0),
 433                                                       (Type*)0));
 434         return true;
 435       }
 436
 437       if (Name.compare(13, 12, "cvtsi64.si32", 12) == 0) {
 438         if (FTy->getParamType(0) == X86_MMXTy)
 439           break;
 440
 441         F->setName("");
 442         NewFn = cast<Function>(M->getOrInsertFunction(Name,
 443                                                       FTy->getReturnType(),
 444                                                       X86_MMXTy,
 445                                                       (Type*)0));
 446         return true;
 447       }
 448
 449       if (Name.compare(13, 8, "vec.init", 8) == 0) {
 450         if (FTy->getReturnType() == X86_MMXTy)
 451           break;
 452
 453         F->setName("");
 454
 455         if (Name.compare(21, 2, ".b", 2) == 0)
 456           NewFn = cast<Function>(M->getOrInsertFunction(Name,
 457                                                         X86_MMXTy,
 458                                                         FTy->getParamType(0),
 459                                                         FTy->getParamType(1),
 460                                                         FTy->getParamType(2),
 461                                                         FTy->getParamType(3),
 462                                                         FTy->getParamType(4),
 463                                                         FTy->getParamType(5),
 464                                                         FTy->getParamType(6),
 465                                                         FTy->getParamType(7),
 466                                                         (Type*)0));
 467         else if (Name.compare(21, 2, ".w", 2) == 0)
 468           NewFn = cast<Function>(M->getOrInsertFunction(Name,
 469                                                         X86_MMXTy,
 470                                                         FTy->getParamType(0),
 471                                                         FTy->getParamType(1),
 472                                                         FTy->getParamType(2),
 473                                                         FTy->getParamType(3),
 474                                                         (Type*)0));
 475         else if (Name.compare(21, 2, ".d", 2) == 0)
 476           NewFn = cast<Function>(M->getOrInsertFunction(Name,
 477                                                         X86_MMXTy,
 478                                                         FTy->getParamType(0),
 479                                                         FTy->getParamType(1),
 480                                                         (Type*)0));
 481         return true;
 482       }
 483
 484
 485       if (Name.compare(13, 9, "vec.ext.d", 9) == 0) {
 486         if (FTy->getReturnType() == X86_MMXTy &&
 487             FTy->getParamType(0) == X86_MMXTy)
 488           break;
 489
 490         F->setName("");
 491         NewFn = cast<Function>(M->getOrInsertFunction(Name,
 492                                                       X86_MMXTy,
 493                                                       X86_MMXTy,
 494                                                       FTy->getParamType(1),
 495                                                       (Type*)0));
 496         return true;
 497       }
 498
 499       if (Name.compare(13, 9, "emms", 4) == 0 ||
 500           Name.compare(13, 9, "femms", 5) == 0) {
 501         NewFn = 0;
 502         break;
 503       }
 504
 505       // We really shouldn't get here ever.
 506       assert(0 && "Invalid MMX intrinsic!");
 507       break;
 508     } else if (Name.compare(5,17,"x86.sse2.loadh.pd",17) == 0 ||
 509                Name.compare(5,17,"x86.sse2.loadl.pd",17) == 0 ||
 510                Name.compare(5,16,"x86.sse2.movl.dq",16) == 0 ||
 511                Name.compare(5,15,"x86.sse2.movs.d",15) == 0 ||
 512                Name.compare(5,16,"x86.sse2.shuf.pd",16) == 0 ||
 513                Name.compare(5,18,"x86.sse2.unpckh.pd",18) == 0 ||
 514                Name.compare(5,18,"x86.sse2.unpckl.pd",18) == 0 ||
 515                Name.compare(5,20,"x86.sse2.punpckh.qdq",20) == 0 ||
 516                Name.compare(5,20,"x86.sse2.punpckl.qdq",20) == 0) {
 517       // Calls to these intrinsics are transformed into ShuffleVector's.
 518       NewFn = 0;
 519       return true;
 520     } else if (Name.compare(5, 16, "x86.sse41.pmulld", 16) == 0) {
 521       // Calls to these intrinsics are transformed into vector multiplies.
 522       NewFn = 0;
 523       return true;
 524     } else if (Name.compare(5, 18, "x86.ssse3.palign.r", 18) == 0 ||
 525                Name.compare(5, 22, "x86.ssse3.palign.r.128", 22) == 0) {
 526       // Calls to these intrinsics are transformed into vector shuffles, shifts,
 527       // or 0.
 528       NewFn = 0;
 529       return true;
 530     } else if (Name.compare(5, 17, "x86.ssse3.pshuf.w", 17) == 0) {
 531       // This is an SSE/MMX instruction.
 532       const Type *X86_MMXTy = VectorType::getX86_MMXTy(FTy->getContext());
 533       NewFn =
 534         cast<Function>(M->getOrInsertFunction("llvm.x86.sse.pshuf.w",
 535                                               X86_MMXTy,
 536                                               X86_MMXTy,
 537                                               Type::getInt8Ty(F->getContext()),
 538                                               (Type*)0));
 539       return true;
 540     }
 541
 542     break;
 543   }
 544
 545   //  This may not belong here. This function is effectively being overloaded
 546   //  to both detect an intrinsic which needs upgrading, and to provide the
 547   //  upgraded form of the intrinsic. We should perhaps have two separate
 548   //  functions for this.
 549   return false;
 550 }
 551
 552 bool llvm::UpgradeIntrinsicFunction(Function *F, Function *&NewFn) {
 553   NewFn = 0;
 554   bool Upgraded = UpgradeIntrinsicFunction1(F, NewFn);
 555
 556   // Upgrade intrinsic attributes.  This does not change the function.
 557   if (NewFn)
 558     F = NewFn;
 559   if (unsigned id = F->getIntrinsicID())
 560     F->setAttributes(Intrinsic::getAttributes((Intrinsic::ID)id));
 561   return Upgraded;
 562 }
 563
 564 bool llvm::UpgradeGlobalVariable(GlobalVariable *GV) {
 565   StringRef Name(GV->getName());
 566
 567   // We are only upgrading one symbol here.
 568   if (Name == ".llvm.eh.catch.all.value") {
 569     GV->setName("llvm.eh.catch.all.value");
 570     return true;
 571   }
 572
 573   return false;
 574 }
 575
 576 /// ExtendNEONArgs - For NEON "long" and "wide" operations, where the results
 577 /// have vector elements twice as big as one or both source operands, do the
 578 /// sign- or zero-extension that used to be handled by intrinsics.  The
 579 /// extended values are returned via V0 and V1.
 580 static void ExtendNEONArgs(CallInst *CI, Value *Arg0, Value *Arg1,
 581                            Value *&V0, Value *&V1) {
 582   Function *F = CI->getCalledFunction();
 583   const std::string& Name = F->getName();
 584   bool isLong = (Name.at(18) == 'l');
 585   bool isSigned = (Name.at(19) == 's');
 586
 587   if (isSigned) {
 588     if (isLong)
 589       V0 = new SExtInst(Arg0, CI->getType(), "", CI);
 590     else
 591       V0 = Arg0;
 592     V1 = new SExtInst(Arg1, CI->getType(), "", CI);
 593   } else {
 594     if (isLong)
 595       V0 = new ZExtInst(Arg0, CI->getType(), "", CI);
 596     else
 597       V0 = Arg0;
 598     V1 = new ZExtInst(Arg1, CI->getType(), "", CI);
 599   }
 600 }
 601
 602 /// CallVABD - As part of expanding a call to one of the old NEON vabdl, vaba,
 603 /// or vabal intrinsics, construct a call to a vabd intrinsic.  Examine the
 604 /// name of the old intrinsic to determine whether to use a signed or unsigned
 605 /// vabd intrinsic.  Get the type from the old call instruction, adjusted for
 606 /// half-size vector elements if the old intrinsic was vabdl or vabal.
 607 static Instruction *CallVABD(CallInst *CI, Value *Arg0, Value *Arg1) {
 608   Function *F = CI->getCalledFunction();
 609   const std::string& Name = F->getName();
 610   bool isLong = (Name.at(18) == 'l');
 611   bool isSigned = (Name.at(isLong ? 19 : 18) == 's');
 612
 613   Intrinsic::ID intID;
 614   if (isSigned)
 615     intID = Intrinsic::arm_neon_vabds;
 616   else
 617     intID = Intrinsic::arm_neon_vabdu;
 618
 619   const Type *Ty = CI->getType();
 620   if (isLong)
 621     Ty = VectorType::getTruncatedElementVectorType(cast<const VectorType>(Ty));
 622
 623   Function *VABD = Intrinsic::getDeclaration(F->getParent(), intID, &Ty, 1);
 624   Value *Operands[2];
 625   Operands[0] = Arg0;
 626   Operands[1] = Arg1;
 627   return CallInst::Create(VABD, Operands, Operands+2,
 628                           "upgraded."+CI->getName(), CI);
 629 }
 630
 631 /// ConstructNewCallInst - Construct a new CallInst with the signature of NewFn.
 632 static void ConstructNewCallInst(Function *NewFn, CallInst *OldCI,
 633                                  Value **Operands, unsigned NumOps,
 634                                  bool AssignName = true) {
 635   // Construct a new CallInst.
 636   CallInst *NewCI =
 637     CallInst::Create(NewFn, Operands, Operands + NumOps,
 638                      AssignName ? "upgraded." + OldCI->getName() : "", OldCI);
 639
 640   NewCI->setTailCall(OldCI->isTailCall());
 641   NewCI->setCallingConv(OldCI->getCallingConv());
 642
 643   // Handle any uses of the old CallInst. If the type has changed, add a cast.
 644   if (!OldCI->use_empty()) {
 645     if (OldCI->getType() != NewCI->getType()) {
 646       Function *OldFn = OldCI->getCalledFunction();
 647       CastInst *RetCast =
 648         CastInst::Create(CastInst::getCastOpcode(NewCI, true,
 649                                                  OldFn->getReturnType(), true),
 650                          NewCI, OldFn->getReturnType(), NewCI->getName(),OldCI);
 651
 652       // Replace all uses of the old call with the new cast which has the
 653       // correct type.
 654       OldCI->replaceAllUsesWith(RetCast);
 655     } else {
 656       OldCI->replaceAllUsesWith(NewCI);
 657     }
 658   }
 659
 660   // Clean up the old call now that it has been completely upgraded.
 661   OldCI->eraseFromParent();
 662 }
 663
 664 // UpgradeIntrinsicCall - Upgrade a call to an old intrinsic to be a call the
 665 // upgraded intrinsic. All argument and return casting must be provided in
 666 // order to seamlessly integrate with existing context.
 667 void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) {
 668   Function *F = CI->getCalledFunction();
 669   LLVMContext &C = CI->getContext();
 670   ImmutableCallSite CS(CI);
 671
 672   assert(F && "CallInst has no function associated with it.");
 673
 674   if (!NewFn) {
 675     // Get the Function's name.
 676     const std::string& Name = F->getName();
 677
 678     // Upgrade ARM NEON intrinsics.
 679     if (Name.compare(5, 9, "arm.neon.", 9) == 0) {
 680       Instruction *NewI;
 681       Value *V0, *V1;
 682       if (Name.compare(14, 7, "vmovls.", 7) == 0) {
 683         NewI = new SExtInst(CI->getArgOperand(0), CI->getType(),
 684                             "upgraded." + CI->getName(), CI);
 685       } else if (Name.compare(14, 7, "vmovlu.", 7) == 0) {
 686         NewI = new ZExtInst(CI->getArgOperand(0), CI->getType(),
 687                             "upgraded." + CI->getName(), CI);
 688       } else if (Name.compare(14, 4, "vadd", 4) == 0) {
 689         ExtendNEONArgs(CI, CI->getArgOperand(0), CI->getArgOperand(1), V0, V1);
 690         NewI = BinaryOperator::CreateAdd(V0, V1, "upgraded."+CI->getName(), CI);
 691       } else if (Name.compare(14, 4, "vsub", 4) == 0) {
 692         ExtendNEONArgs(CI, CI->getArgOperand(0), CI->getArgOperand(1), V0, V1);
 693         NewI = BinaryOperator::CreateSub(V0, V1,"upgraded."+CI->getName(),CI);
 694       } else if (Name.compare(14, 4, "vmul", 4) == 0) {
 695         ExtendNEONArgs(CI, CI->getArgOperand(0), CI->getArgOperand(1), V0, V1);
 696         NewI = BinaryOperator::CreateMul(V0, V1,"upgraded."+CI->getName(),CI);
 697       } else if (Name.compare(14, 4, "vmla", 4) == 0) {
 698         ExtendNEONArgs(CI, CI->getArgOperand(1), CI->getArgOperand(2), V0, V1);
 699         Instruction *MulI = BinaryOperator::CreateMul(V0, V1, "", CI);
 700         NewI = BinaryOperator::CreateAdd(CI->getArgOperand(0), MulI,
 701                                          "upgraded."+CI->getName(), CI);
 702       } else if (Name.compare(14, 4, "vmls", 4) == 0) {
 703         ExtendNEONArgs(CI, CI->getArgOperand(1), CI->getArgOperand(2), V0, V1);
 704         Instruction *MulI = BinaryOperator::CreateMul(V0, V1, "", CI);
 705         NewI = BinaryOperator::CreateSub(CI->getArgOperand(0), MulI,
 706                                          "upgraded."+CI->getName(), CI);
 707       } else if (Name.compare(14, 4, "vabd", 4) == 0) {
 708         NewI = CallVABD(CI, CI->getArgOperand(0), CI->getArgOperand(1));
 709         NewI = new ZExtInst(NewI, CI->getType(), "upgraded."+CI->getName(), CI);
 710       } else if (Name.compare(14, 4, "vaba", 4) == 0) {
 711         NewI = CallVABD(CI, CI->getArgOperand(1), CI->getArgOperand(2));
 712         if (Name.at(18) == 'l')
 713           NewI = new ZExtInst(NewI, CI->getType(), "", CI);
 714         NewI = BinaryOperator::CreateAdd(CI->getArgOperand(0), NewI,
 715                                          "upgraded."+CI->getName(), CI);
 716       } else if (Name.compare(14, 6, "vmovn.", 6) == 0) {
 717         NewI = new TruncInst(CI->getArgOperand(0), CI->getType(),
 718                              "upgraded." + CI->getName(), CI);
 719       } else {
 720         llvm_unreachable("Unknown arm.neon function for CallInst upgrade.");
 721       }
 722       // Replace any uses of the old CallInst.
 723       if (!CI->use_empty())
 724         CI->replaceAllUsesWith(NewI);
 725       CI->eraseFromParent();
 726       return;
 727     }
 728
 729     bool isLoadH = false, isLoadL = false, isMovL = false;
 730     bool isMovSD = false, isShufPD = false;
 731     bool isUnpckhPD = false, isUnpcklPD = false;
 732     bool isPunpckhQPD = false, isPunpcklQPD = false;
 733     if (F->getName() == "llvm.x86.sse2.loadh.pd")
 734       isLoadH = true;
 735     else if (F->getName() == "llvm.x86.sse2.loadl.pd")
 736       isLoadL = true;
 737     else if (F->getName() == "llvm.x86.sse2.movl.dq")
 738       isMovL = true;
 739     else if (F->getName() == "llvm.x86.sse2.movs.d")
 740       isMovSD = true;
 741     else if (F->getName() == "llvm.x86.sse2.shuf.pd")
 742       isShufPD = true;
 743     else if (F->getName() == "llvm.x86.sse2.unpckh.pd")
 744       isUnpckhPD = true;
 745     else if (F->getName() == "llvm.x86.sse2.unpckl.pd")
 746       isUnpcklPD = true;
 747     else if (F->getName() ==  "llvm.x86.sse2.punpckh.qdq")
 748       isPunpckhQPD = true;
 749     else if (F->getName() ==  "llvm.x86.sse2.punpckl.qdq")
 750       isPunpcklQPD = true;
 751
 752     if (isLoadH || isLoadL || isMovL || isMovSD || isShufPD ||
 753         isUnpckhPD || isUnpcklPD || isPunpckhQPD || isPunpcklQPD) {
 754       std::vector<Constant*> Idxs;
 755       Value *Op0 = CI->getArgOperand(0);
 756       ShuffleVectorInst *SI = NULL;
 757       if (isLoadH || isLoadL) {
 758         Value *Op1 = UndefValue::get(Op0->getType());
 759         Value *Addr = new BitCastInst(CI->getArgOperand(1),
 760                                   Type::getDoublePtrTy(C),
 761                                       "upgraded.", CI);
 762         Value *Load = new LoadInst(Addr, "upgraded.", false, 8, CI);
 763         Value *Idx = ConstantInt::get(Type::getInt32Ty(C), 0);
 764         Op1 = InsertElementInst::Create(Op1, Load, Idx, "upgraded.", CI);
 765
 766         if (isLoadH) {
 767           Idxs.push_back(ConstantInt::get(Type::getInt32Ty(C), 0));
 768           Idxs.push_back(ConstantInt::get(Type::getInt32Ty(C), 2));
 769         } else {
 770           Idxs.push_back(ConstantInt::get(Type::getInt32Ty(C), 2));
 771           Idxs.push_back(ConstantInt::get(Type::getInt32Ty(C), 1));
 772         }
 773         Value *Mask = ConstantVector::get(Idxs);
 774         SI = new ShuffleVectorInst(Op0, Op1, Mask, "upgraded.", CI);
 775       } else if (isMovL) {
 776         Constant *Zero = ConstantInt::get(Type::getInt32Ty(C), 0);
 777         Idxs.push_back(Zero);
 778         Idxs.push_back(Zero);
 779         Idxs.push_back(Zero);
 780         Idxs.push_back(Zero);
 781         Value *ZeroV = ConstantVector::get(Idxs);
 782
 783         Idxs.clear();
 784         Idxs.push_back(ConstantInt::get(Type::getInt32Ty(C), 4));
 785         Idxs.push_back(ConstantInt::get(Type::getInt32Ty(C), 5));
 786         Idxs.push_back(ConstantInt::get(Type::getInt32Ty(C), 2));
 787         Idxs.push_back(ConstantInt::get(Type::getInt32Ty(C), 3));
 788         Value *Mask = ConstantVector::get(Idxs);
 789         SI = new ShuffleVectorInst(ZeroV, Op0, Mask, "upgraded.", CI);
 790       } else if (isMovSD ||
 791                  isUnpckhPD || isUnpcklPD || isPunpckhQPD || isPunpcklQPD) {
 792         Value *Op1 = CI->getArgOperand(1);
 793         if (isMovSD) {
 794           Idxs.push_back(ConstantInt::get(Type::getInt32Ty(C), 2));
 795           Idxs.push_back(ConstantInt::get(Type::getInt32Ty(C), 1));
 796         } else if (isUnpckhPD || isPunpckhQPD) {
 797           Idxs.push_back(ConstantInt::get(Type::getInt32Ty(C), 1));
 798           Idxs.push_back(ConstantInt::get(Type::getInt32Ty(C), 3));
 799         } else {
 800           Idxs.push_back(ConstantInt::get(Type::getInt32Ty(C), 0));
 801           Idxs.push_back(ConstantInt::get(Type::getInt32Ty(C), 2));
 802         }
 803         Value *Mask = ConstantVector::get(Idxs);
 804         SI = new ShuffleVectorInst(Op0, Op1, Mask, "upgraded.", CI);
 805       } else if (isShufPD) {
 806         Value *Op1 = CI->getArgOperand(1);
 807         unsigned MaskVal =
 808                         cast<ConstantInt>(CI->getArgOperand(2))->getZExtValue();
 809         Idxs.push_back(ConstantInt::get(Type::getInt32Ty(C), MaskVal & 1));
 810         Idxs.push_back(ConstantInt::get(Type::getInt32Ty(C),
 811                                                ((MaskVal >> 1) & 1)+2));
 812         Value *Mask = ConstantVector::get(Idxs);
 813         SI = new ShuffleVectorInst(Op0, Op1, Mask, "upgraded.", CI);
 814       }
 815
 816       assert(SI && "Unexpected!");
 817
 818       // Handle any uses of the old CallInst.
 819       if (!CI->use_empty())
 820         //  Replace all uses of the old call with the new cast which has the
 821         //  correct type.
 822         CI->replaceAllUsesWith(SI);
 823
 824       //  Clean up the old call now that it has been completely upgraded.
 825       CI->eraseFromParent();
 826     } else if (F->getName() == "llvm.x86.sse41.pmulld") {
 827       // Upgrade this set of intrinsics into vector multiplies.
 828       Instruction *Mul = BinaryOperator::CreateMul(CI->getArgOperand(0),
 829                                                    CI->getArgOperand(1),
 830                                                    CI->getName(),
 831                                                    CI);
 832       // Fix up all the uses with our new multiply.
 833       if (!CI->use_empty())
 834         CI->replaceAllUsesWith(Mul);
 835
 836       // Remove upgraded multiply.
 837       CI->eraseFromParent();
 838     } else if (F->getName() == "llvm.x86.ssse3.palign.r") {
 839       Value *Op1 = CI->getArgOperand(0);
 840       Value *Op2 = CI->getArgOperand(1);
 841       Value *Op3 = CI->getArgOperand(2);
 842       unsigned shiftVal = cast<ConstantInt>(Op3)->getZExtValue();
 843       Value *Rep;
 844       IRBuilder<> Builder(C);
 845       Builder.SetInsertPoint(CI->getParent(), CI);
 846
 847       // If palignr is shifting the pair of input vectors less than 9 bytes,
 848       // emit a shuffle instruction.
 849       if (shiftVal <= 8) {
 850         const Type *IntTy = Type::getInt32Ty(C);
 851         const Type *EltTy = Type::getInt8Ty(C);
 852         const Type *VecTy = VectorType::get(EltTy, 8);
 853
 854         Op2 = Builder.CreateBitCast(Op2, VecTy);
 855         Op1 = Builder.CreateBitCast(Op1, VecTy);
 856
 857         llvm::SmallVector<llvm::Constant*, 8> Indices;
 858         for (unsigned i = 0; i != 8; ++i)
 859           Indices.push_back(ConstantInt::get(IntTy, shiftVal + i));
 860
 861         Value *SV = ConstantVector::get(Indices);
 862         Rep = Builder.CreateShuffleVector(Op2, Op1, SV, "palignr");
 863         Rep = Builder.CreateBitCast(Rep, F->getReturnType());
 864       }
 865
 866       // If palignr is shifting the pair of input vectors more than 8 but less
 867       // than 16 bytes, emit a logical right shift of the destination.
 868       else if (shiftVal < 16) {
 869         // MMX has these as 1 x i64 vectors for some odd optimization reasons.
 870         const Type *EltTy = Type::getInt64Ty(C);
 871         const Type *VecTy = VectorType::get(EltTy, 1);
 872
 873         Op1 = Builder.CreateBitCast(Op1, VecTy, "cast");
 874         Op2 = ConstantInt::get(VecTy, (shiftVal-8) * 8);
 875
 876         // create i32 constant
 877         Function *I =
 878           Intrinsic::getDeclaration(F->getParent(), Intrinsic::x86_mmx_psrl_q);
 879         Rep = Builder.CreateCall2(I, Op1, Op2, "palignr");
 880       }
 881
 882       // If palignr is shifting the pair of vectors more than 32 bytes, emit zero.
 883       else {
 884         Rep = Constant::getNullValue(F->getReturnType());
 885       }
 886
 887       // Replace any uses with our new instruction.
 888       if (!CI->use_empty())
 889         CI->replaceAllUsesWith(Rep);
 890
 891       // Remove upgraded instruction.
 892       CI->eraseFromParent();
 893
 894     } else if (F->getName() == "llvm.x86.ssse3.palign.r.128") {
 895       Value *Op1 = CI->getArgOperand(0);
 896       Value *Op2 = CI->getArgOperand(1);
 897       Value *Op3 = CI->getArgOperand(2);
 898       unsigned shiftVal = cast<ConstantInt>(Op3)->getZExtValue();
 899       Value *Rep;
 900       IRBuilder<> Builder(C);
 901       Builder.SetInsertPoint(CI->getParent(), CI);
 902
 903       // If palignr is shifting the pair of input vectors less than 17 bytes,
 904       // emit a shuffle instruction.
 905       if (shiftVal <= 16) {
 906         const Type *IntTy = Type::getInt32Ty(C);
 907         const Type *EltTy = Type::getInt8Ty(C);
 908         const Type *VecTy = VectorType::get(EltTy, 16);
 909
 910         Op2 = Builder.CreateBitCast(Op2, VecTy);
 911         Op1 = Builder.CreateBitCast(Op1, VecTy);
 912
 913         llvm::SmallVector<llvm::Constant*, 16> Indices;
 914         for (unsigned i = 0; i != 16; ++i)
 915           Indices.push_back(ConstantInt::get(IntTy, shiftVal + i));
 916
 917         Value *SV = ConstantVector::get(Indices);
 918         Rep = Builder.CreateShuffleVector(Op2, Op1, SV, "palignr");
 919         Rep = Builder.CreateBitCast(Rep, F->getReturnType());
 920       }
 921
 922       // If palignr is shifting the pair of input vectors more than 16 but less
 923       // than 32 bytes, emit a logical right shift of the destination.
 924       else if (shiftVal < 32) {
 925         const Type *EltTy = Type::getInt64Ty(C);
 926         const Type *VecTy = VectorType::get(EltTy, 2);
 927         const Type *IntTy = Type::getInt32Ty(C);
 928
 929         Op1 = Builder.CreateBitCast(Op1, VecTy, "cast");
 930         Op2 = ConstantInt::get(IntTy, (shiftVal-16) * 8);
 931
 932         // create i32 constant
 933         Function *I =
 934           Intrinsic::getDeclaration(F->getParent(), Intrinsic::x86_sse2_psrl_dq);
 935         Rep = Builder.CreateCall2(I, Op1, Op2, "palignr");
 936       }
 937
 938       // If palignr is shifting the pair of vectors more than 32 bytes, emit zero.
 939       else {
 940         Rep = Constant::getNullValue(F->getReturnType());
 941       }
 942
 943       // Replace any uses with our new instruction.
 944       if (!CI->use_empty())
 945         CI->replaceAllUsesWith(Rep);
 946
 947       // Remove upgraded instruction.
 948       CI->eraseFromParent();
 949
 950     } else {
 951       llvm_unreachable("Unknown function for CallInst upgrade.");
 952     }
 953     return;
 954   }
 955
 956   switch (NewFn->getIntrinsicID()) {
 957   default: llvm_unreachable("Unknown function for CallInst upgrade.");
 958   case Intrinsic::arm_neon_vld1:
 959   case Intrinsic::arm_neon_vld2:
 960   case Intrinsic::arm_neon_vld3:
 961   case Intrinsic::arm_neon_vld4:
 962   case Intrinsic::arm_neon_vst1:
 963   case Intrinsic::arm_neon_vst2:
 964   case Intrinsic::arm_neon_vst3:
 965   case Intrinsic::arm_neon_vst4:
 966   case Intrinsic::arm_neon_vld2lane:
 967   case Intrinsic::arm_neon_vld3lane:
 968   case Intrinsic::arm_neon_vld4lane:
 969   case Intrinsic::arm_neon_vst2lane:
 970   case Intrinsic::arm_neon_vst3lane:
 971   case Intrinsic::arm_neon_vst4lane: {
 972     // Add a default alignment argument of 1.
 973     SmallVector<Value*, 8> Operands(CS.arg_begin(), CS.arg_end());
 974     Operands.push_back(ConstantInt::get(Type::getInt32Ty(C), 1));
 975     CallInst *NewCI = CallInst::Create(NewFn, Operands.begin(), Operands.end(),
 976                                        CI->getName(), CI);
 977     NewCI->setTailCall(CI->isTailCall());
 978     NewCI->setCallingConv(CI->getCallingConv());
 979
 980     //  Handle any uses of the old CallInst.
 981     if (!CI->use_empty())
 982       //  Replace all uses of the old call with the new cast which has the
 983       //  correct type.
 984       CI->replaceAllUsesWith(NewCI);
 985
 986     //  Clean up the old call now that it has been completely upgraded.
 987     CI->eraseFromParent();
 988     break;
 989   }
 990
 991   case Intrinsic::x86_mmx_padd_b:
 992   case Intrinsic::x86_mmx_padd_w:
 993   case Intrinsic::x86_mmx_padd_d:
 994   case Intrinsic::x86_mmx_padd_q:
 995   case Intrinsic::x86_mmx_padds_b:
 996   case Intrinsic::x86_mmx_padds_w:
 997   case Intrinsic::x86_mmx_paddus_b:
 998   case Intrinsic::x86_mmx_paddus_w:
 999   case Intrinsic::x86_mmx_psub_b:
1000   case Intrinsic::x86_mmx_psub_w:
1001   case Intrinsic::x86_mmx_psub_d:
1002   case Intrinsic::x86_mmx_psub_q:
1003   case Intrinsic::x86_mmx_psubs_b:
1004   case Intrinsic::x86_mmx_psubs_w:
1005   case Intrinsic::x86_mmx_psubus_b:
1006   case Intrinsic::x86_mmx_psubus_w:
1007   case Intrinsic::x86_mmx_pmulh_w:
1008   case Intrinsic::x86_mmx_pmull_w:
1009   case Intrinsic::x86_mmx_pmulhu_w:
1010   case Intrinsic::x86_mmx_pmulu_dq:
1011   case Intrinsic::x86_mmx_pmadd_wd:
1012   case Intrinsic::x86_mmx_pand:
1013   case Intrinsic::x86_mmx_pandn:
1014   case Intrinsic::x86_mmx_por:
1015   case Intrinsic::x86_mmx_pxor:
1016   case Intrinsic::x86_mmx_pavg_b:
1017   case Intrinsic::x86_mmx_pavg_w:
1018   case Intrinsic::x86_mmx_pmaxu_b:
1019   case Intrinsic::x86_mmx_pmaxs_w:
1020   case Intrinsic::x86_mmx_pminu_b:
1021   case Intrinsic::x86_mmx_pmins_w:
1022   case Intrinsic::x86_mmx_psad_bw:
1023   case Intrinsic::x86_mmx_psll_w:
1024   case Intrinsic::x86_mmx_psll_d:
1025   case Intrinsic::x86_mmx_psll_q:
1026   case Intrinsic::x86_mmx_pslli_w:
1027   case Intrinsic::x86_mmx_pslli_d:
1028   case Intrinsic::x86_mmx_pslli_q:
1029   case Intrinsic::x86_mmx_psrl_w:
1030   case Intrinsic::x86_mmx_psrl_d:
1031   case Intrinsic::x86_mmx_psrl_q:
1032   case Intrinsic::x86_mmx_psrli_w:
1033   case Intrinsic::x86_mmx_psrli_d:
1034   case Intrinsic::x86_mmx_psrli_q:
1035   case Intrinsic::x86_mmx_psra_w:
1036   case Intrinsic::x86_mmx_psra_d:
1037   case Intrinsic::x86_mmx_psrai_w:
1038   case Intrinsic::x86_mmx_psrai_d:
1039   case Intrinsic::x86_mmx_packsswb:
1040   case Intrinsic::x86_mmx_packssdw:
1041   case Intrinsic::x86_mmx_packuswb:
1042   case Intrinsic::x86_mmx_punpckhbw:
1043   case Intrinsic::x86_mmx_punpckhwd:
1044   case Intrinsic::x86_mmx_punpckhdq:
1045   case Intrinsic::x86_mmx_punpcklbw:
1046   case Intrinsic::x86_mmx_punpcklwd:
1047   case Intrinsic::x86_mmx_punpckldq:
1048   case Intrinsic::x86_mmx_pcmpeq_b:
1049   case Intrinsic::x86_mmx_pcmpeq_w:
1050   case Intrinsic::x86_mmx_pcmpeq_d:
1051   case Intrinsic::x86_mmx_pcmpgt_b:
1052   case Intrinsic::x86_mmx_pcmpgt_w:
1053   case Intrinsic::x86_mmx_pcmpgt_d: {
1054     Value *Operands[2];
1055
1056     // Cast the operand to the X86 MMX type.
1057     Operands[0] = new BitCastInst(CI->getArgOperand(0),
1058                                   NewFn->getFunctionType()->getParamType(0),
1059                                   "upgraded.", CI);
1060
1061     switch (NewFn->getIntrinsicID()) {
1062     default:
1063       // Cast to the X86 MMX type.
1064       Operands[1] = new BitCastInst(CI->getArgOperand(1),
1065                                     NewFn->getFunctionType()->getParamType(1),
1066                                     "upgraded.", CI);
1067       break;
1068     case Intrinsic::x86_mmx_pslli_w:
1069     case Intrinsic::x86_mmx_pslli_d:
1070     case Intrinsic::x86_mmx_pslli_q:
1071     case Intrinsic::x86_mmx_psrli_w:
1072     case Intrinsic::x86_mmx_psrli_d:
1073     case Intrinsic::x86_mmx_psrli_q:
1074     case Intrinsic::x86_mmx_psrai_w:
1075     case Intrinsic::x86_mmx_psrai_d:
1076       // These take an i32 as their second parameter.
1077       Operands[1] = CI->getArgOperand(1);
1078       break;
1079     }
1080
1081     ConstructNewCallInst(NewFn, CI, Operands, 2);
1082     break;
1083   }
1084   case Intrinsic::x86_mmx_maskmovq: {
1085     Value *Operands[3];
1086
1087     // Cast the operands to the X86 MMX type.
1088     Operands[0] = new BitCastInst(CI->getArgOperand(0),
1089                                   NewFn->getFunctionType()->getParamType(0),
1090                                   "upgraded.", CI);
1091     Operands[1] = new BitCastInst(CI->getArgOperand(1),
1092                                   NewFn->getFunctionType()->getParamType(1),
1093                                   "upgraded.", CI);
1094     Operands[2] = CI->getArgOperand(2);
1095
1096     ConstructNewCallInst(NewFn, CI, Operands, 3, false);
1097     break;
1098   }
1099   case Intrinsic::x86_mmx_pmovmskb: {
1100     Value *Operands[1];
1101
1102     // Cast the operand to the X86 MMX type.
1103     Operands[0] = new BitCastInst(CI->getArgOperand(0),
1104                                   NewFn->getFunctionType()->getParamType(0),
1105                                   "upgraded.", CI);
1106
1107     ConstructNewCallInst(NewFn, CI, Operands, 1);
1108     break;
1109   }
1110   case Intrinsic::x86_mmx_movnt_dq: {
1111     Value *Operands[2];
1112
1113     Operands[0] = CI->getArgOperand(0);
1114
1115     // Cast the operand to the X86 MMX type.
1116     Operands[1] = new BitCastInst(CI->getArgOperand(1),
1117                                   NewFn->getFunctionType()->getParamType(1),
1118                                   "upgraded.", CI);
1119
1120     ConstructNewCallInst(NewFn, CI, Operands, 2, false);
1121     break;
1122   }
1123   case Intrinsic::x86_mmx_palignr_b: {
1124     Value *Operands[3];
1125
1126     // Cast the operands to the X86 MMX type.
1127     Operands[0] = new BitCastInst(CI->getArgOperand(0),
1128                                   NewFn->getFunctionType()->getParamType(0),
1129                                   "upgraded.", CI);
1130     Operands[1] = new BitCastInst(CI->getArgOperand(1),
1131                                   NewFn->getFunctionType()->getParamType(1),
1132                                   "upgraded.", CI);
1133     Operands[2] = CI->getArgOperand(2);
1134
1135     ConstructNewCallInst(NewFn, CI, Operands, 3);
1136     break;
1137   }
1138   case Intrinsic::x86_mmx_pextr_w: {
1139     Value *Operands[2];
1140
1141     // Cast the operands to the X86 MMX type.
1142     Operands[0] = new BitCastInst(CI->getArgOperand(0),
1143                                   NewFn->getFunctionType()->getParamType(0),
1144                                   "upgraded.", CI);
1145     Operands[1] = CI->getArgOperand(1);
1146
1147     ConstructNewCallInst(NewFn, CI, Operands, 2);
1148     break;
1149   }
1150   case Intrinsic::x86_mmx_pinsr_w: {
1151     Value *Operands[3];
1152
1153     // Cast the operands to the X86 MMX type.
1154     Operands[0] = new BitCastInst(CI->getArgOperand(0),
1155                                   NewFn->getFunctionType()->getParamType(0),
1156                                   "upgraded.", CI);
1157     Operands[1] = CI->getArgOperand(1);
1158     Operands[2] = CI->getArgOperand(2);
1159
1160     ConstructNewCallInst(NewFn, CI, Operands, 3);
1161     break;
1162   }
1163   case Intrinsic::x86_sse_pshuf_w: {
1164     IRBuilder<> Builder(C);
1165     Builder.SetInsertPoint(CI->getParent(), CI);
1166
1167     // Cast the operand to the X86 MMX type.
1168     Value *Operands[2];
1169     Operands[0] =
1170       Builder.CreateBitCast(CI->getArgOperand(0),
1171                             NewFn->getFunctionType()->getParamType(0),
1172                             "upgraded.");
1173     Operands[1] =
1174       Builder.CreateTrunc(CI->getArgOperand(1),
1175                           Type::getInt8Ty(C),
1176                           "upgraded.");
1177
1178     ConstructNewCallInst(NewFn, CI, Operands, 2);
1179     break;
1180   }
1181
1182 #if 0
1183   case Intrinsic::x86_mmx_cvtsi32_si64: {
1184     // The return type needs to be changed.
1185     Value *Operands[1];
1186     Operands[0] = CI->getArgOperand(0);
1187     ConstructNewCallInst(NewFn, CI, Operands, 1);
1188     break;
1189   }
1190   case Intrinsic::x86_mmx_cvtsi64_si32: {
1191     Value *Operands[1];
1192
1193     // Cast the operand to the X86 MMX type.
1194     Operands[0] = new BitCastInst(CI->getArgOperand(0),
1195                                   NewFn->getFunctionType()->getParamType(0),
1196                                   "upgraded.", CI);
1197
1198     ConstructNewCallInst(NewFn, CI, Operands, 1);
1199     break;
1200   }
1201   case Intrinsic::x86_mmx_vec_init_b:
1202   case Intrinsic::x86_mmx_vec_init_w:
1203   case Intrinsic::x86_mmx_vec_init_d: {
1204     // The return type needs to be changed.
1205     Value *Operands[8];
1206     unsigned NumOps = 0;
1207
1208     switch (NewFn->getIntrinsicID()) {
1209     default: break;
1210     case Intrinsic::x86_mmx_vec_init_b: NumOps = 8; break;
1211     case Intrinsic::x86_mmx_vec_init_w: NumOps = 4; break;
1212     case Intrinsic::x86_mmx_vec_init_d: NumOps = 2; break;
1213     }
1214
1215     switch (NewFn->getIntrinsicID()) {
1216     default: break;
1217     case Intrinsic::x86_mmx_vec_init_b:
1218       Operands[7] = CI->getArgOperand(7);
1219       Operands[6] = CI->getArgOperand(6);
1220       Operands[5] = CI->getArgOperand(5);
1221       Operands[4] = CI->getArgOperand(4);
1222       // FALLTHRU
1223     case Intrinsic::x86_mmx_vec_init_w:
1224       Operands[3] = CI->getArgOperand(3);
1225       Operands[2] = CI->getArgOperand(2);
1226       // FALLTHRU
1227     case Intrinsic::x86_mmx_vec_init_d:
1228       Operands[1] = CI->getArgOperand(1);
1229       Operands[0] = CI->getArgOperand(0);
1230       break;
1231     }
1232
1233     ConstructNewCallInst(NewFn, CI, Operands, NumOps);
1234     break;
1235   }
1236   case Intrinsic::x86_mmx_vec_ext_d: {
1237     Value *Operands[2];
1238
1239     // Cast the operand to the X86 MMX type.
1240     Operands[0] = new BitCastInst(CI->getArgOperand(0),
1241                                   NewFn->getFunctionType()->getParamType(0),
1242                                   "upgraded.", CI);
1243     Operands[1] = CI->getArgOperand(1);
1244
1245     ConstructNewCallInst(NewFn, CI, Operands, 2);
1246     break;
1247   }
1248 #endif
1249
1250   case Intrinsic::ctlz:
1251   case Intrinsic::ctpop:
1252   case Intrinsic::cttz: {
1253     //  Build a small vector of the original arguments.
1254     SmallVector<Value*, 8> Operands(CS.arg_begin(), CS.arg_end());
1255
1256     //  Construct a new CallInst
1257     CallInst *NewCI = CallInst::Create(NewFn, Operands.begin(), Operands.end(),
1258                                        "upgraded."+CI->getName(), CI);
1259     NewCI->setTailCall(CI->isTailCall());
1260     NewCI->setCallingConv(CI->getCallingConv());
1261
1262     //  Handle any uses of the old CallInst.
1263     if (!CI->use_empty()) {
1264       //  Check for sign extend parameter attributes on the return values.
1265       bool SrcSExt = NewFn->getAttributes().paramHasAttr(0, Attribute::SExt);
1266       bool DestSExt = F->getAttributes().paramHasAttr(0, Attribute::SExt);
1267
1268       //  Construct an appropriate cast from the new return type to the old.
1269       CastInst *RetCast = CastInst::Create(
1270                             CastInst::getCastOpcode(NewCI, SrcSExt,
1271                                                     F->getReturnType(),
1272                                                     DestSExt),
1273                             NewCI, F->getReturnType(),
1274                             NewCI->getName(), CI);
1275       NewCI->moveBefore(RetCast);
1276
1277       //  Replace all uses of the old call with the new cast which has the
1278       //  correct type.
1279       CI->replaceAllUsesWith(RetCast);
1280     }
1281
1282     //  Clean up the old call now that it has been completely upgraded.
1283     CI->eraseFromParent();
1284   }
1285   break;
1286   case Intrinsic::eh_selector:
1287   case Intrinsic::eh_typeid_for: {
1288     // Only the return type changed.
1289     SmallVector<Value*, 8> Operands(CS.arg_begin(), CS.arg_end());
1290     CallInst *NewCI = CallInst::Create(NewFn, Operands.begin(), Operands.end(),
1291                                        "upgraded." + CI->getName(), CI);
1292     NewCI->setTailCall(CI->isTailCall());
1293     NewCI->setCallingConv(CI->getCallingConv());
1294
1295     //  Handle any uses of the old CallInst.
1296     if (!CI->use_empty()) {
1297       //  Construct an appropriate cast from the new return type to the old.
1298       CastInst *RetCast =
1299         CastInst::Create(CastInst::getCastOpcode(NewCI, true,
1300                                                  F->getReturnType(), true),
1301                          NewCI, F->getReturnType(), NewCI->getName(), CI);
1302       CI->replaceAllUsesWith(RetCast);
1303     }
1304     CI->eraseFromParent();
1305   }
1306   break;
1307   case Intrinsic::memcpy:
1308   case Intrinsic::memmove:
1309   case Intrinsic::memset: {
1310     // Add isVolatile
1311     const llvm::Type *I1Ty = llvm::Type::getInt1Ty(CI->getContext());
1312     Value *Operands[5] = { CI->getArgOperand(0), CI->getArgOperand(1),
1313                            CI->getArgOperand(2), CI->getArgOperand(3),
1314                            llvm::ConstantInt::get(I1Ty, 0) };
1315     CallInst *NewCI = CallInst::Create(NewFn, Operands, Operands+5,
1316                                        CI->getName(), CI);
1317     NewCI->setTailCall(CI->isTailCall());
1318     NewCI->setCallingConv(CI->getCallingConv());
1319     //  Handle any uses of the old CallInst.
1320     if (!CI->use_empty())
1321       //  Replace all uses of the old call with the new cast which has the
1322       //  correct type.
1323       CI->replaceAllUsesWith(NewCI);
1324
1325     //  Clean up the old call now that it has been completely upgraded.
1326     CI->eraseFromParent();
1327     break;
1328   }
1329   }
1330 }
1331
1332 // This tests each Function to determine if it needs upgrading. When we find
1333 // one we are interested in, we then upgrade all calls to reflect the new
1334 // function.
1335 void llvm::UpgradeCallsToIntrinsic(Function* F) {
1336   assert(F && "Illegal attempt to upgrade a non-existent intrinsic.");
1337
1338   // Upgrade the function and check if it is a totaly new function.
1339   Function* NewFn;
1340   if (UpgradeIntrinsicFunction(F, NewFn)) {
1341     if (NewFn != F) {
1342       // Replace all uses to the old function with the new one if necessary.
1343       for (Value::use_iterator UI = F->use_begin(), UE = F->use_end();
1344            UI != UE; ) {
1345         if (CallInst* CI = dyn_cast<CallInst>(*UI++))
1346           UpgradeIntrinsicCall(CI, NewFn);
1347       }
1348       // Remove old function, no longer used, from the module.
1349       F->eraseFromParent();
1350     }
1351   }
1352 }
1353
1354 /// This function strips all debug info intrinsics, except for llvm.dbg.declare.
1355 /// If an llvm.dbg.declare intrinsic is invalid, then this function simply
1356 /// strips that use.
1357 void llvm::CheckDebugInfoIntrinsics(Module *M) {
1358
1359
1360   if (Function *FuncStart = M->getFunction("llvm.dbg.func.start")) {
1361     while (!FuncStart->use_empty()) {
1362       CallInst *CI = cast<CallInst>(FuncStart->use_back());
1363       CI->eraseFromParent();
1364     }
1365     FuncStart->eraseFromParent();
1366   }
1367
1368   if (Function *StopPoint = M->getFunction("llvm.dbg.stoppoint")) {
1369     while (!StopPoint->use_empty()) {
1370       CallInst *CI = cast<CallInst>(StopPoint->use_back());
1371       CI->eraseFromParent();
1372     }
1373     StopPoint->eraseFromParent();
1374   }
1375
1376   if (Function *RegionStart = M->getFunction("llvm.dbg.region.start")) {
1377     while (!RegionStart->use_empty()) {
1378       CallInst *CI = cast<CallInst>(RegionStart->use_back());
1379       CI->eraseFromParent();
1380     }
1381     RegionStart->eraseFromParent();
1382   }
1383
1384   if (Function *RegionEnd = M->getFunction("llvm.dbg.region.end")) {
1385     while (!RegionEnd->use_empty()) {
1386       CallInst *CI = cast<CallInst>(RegionEnd->use_back());
1387       CI->eraseFromParent();
1388     }
1389     RegionEnd->eraseFromParent();
1390   }
1391
1392   if (Function *Declare = M->getFunction("llvm.dbg.declare")) {
1393     if (!Declare->use_empty()) {
1394       DbgDeclareInst *DDI = cast<DbgDeclareInst>(Declare->use_back());
1395       if (!isa<MDNode>(DDI->getArgOperand(0)) ||
1396           !isa<MDNode>(DDI->getArgOperand(1))) {
1397         while (!Declare->use_empty()) {
1398           CallInst *CI = cast<CallInst>(Declare->use_back());
1399           CI->eraseFromParent();
1400         }
1401         Declare->eraseFromParent();
1402       }
1403     }
1404   }
1405 }