2007-08-04 01:51:18 +00:00
|
|
|
//===-- AutoUpgrade.cpp - Implement auto-upgrade helper functions ---------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2007-08-04 01:51:18 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
2013-07-20 17:46:00 +00:00
|
|
|
// This file implements the auto-upgrade helper functions
|
2007-08-04 01:51:18 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2014-03-05 10:34:14 +00:00
|
|
|
#include "llvm/IR/AutoUpgrade.h"
|
2014-03-04 11:45:46 +00:00
|
|
|
#include "llvm/IR/CFG.h"
|
2014-03-04 11:01:28 +00:00
|
|
|
#include "llvm/IR/CallSite.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/Constants.h"
|
2015-01-14 11:23:27 +00:00
|
|
|
#include "llvm/IR/DIBuilder.h"
|
2014-03-06 00:46:21 +00:00
|
|
|
#include "llvm/IR/DebugInfo.h"
|
2014-01-16 01:51:12 +00:00
|
|
|
#include "llvm/IR/DiagnosticInfo.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/Function.h"
|
|
|
|
#include "llvm/IR/IRBuilder.h"
|
|
|
|
#include "llvm/IR/Instruction.h"
|
|
|
|
#include "llvm/IR/IntrinsicInst.h"
|
|
|
|
#include "llvm/IR/LLVMContext.h"
|
|
|
|
#include "llvm/IR/Module.h"
|
2009-07-11 20:10:48 +00:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
2008-02-20 11:08:44 +00:00
|
|
|
#include <cstring>
|
2007-08-04 01:51:18 +00:00
|
|
|
using namespace llvm;
|
|
|
|
|
2012-06-10 18:42:51 +00:00
|
|
|
// Upgrade the declarations of the SSE4.1 functions whose arguments have
|
|
|
|
// changed their type from v4f32 to v2i64.
|
|
|
|
static bool UpgradeSSE41Function(Function* F, Intrinsic::ID IID,
|
|
|
|
Function *&NewFn) {
|
|
|
|
// Check whether this is an old version of the function, which received
|
|
|
|
// v4f32 arguments.
|
|
|
|
Type *Arg0Type = F->getFunctionType()->getParamType(0);
|
|
|
|
if (Arg0Type != VectorType::get(Type::getFloatTy(F->getContext()), 4))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Yes, it's old, replace it with new version.
|
|
|
|
F->setName(F->getName() + ".old");
|
|
|
|
NewFn = Intrinsic::getDeclaration(F->getParent(), IID);
|
|
|
|
return true;
|
|
|
|
}
|
2007-08-04 01:51:18 +00:00
|
|
|
|
[x86] Fix a pretty horrible bug and inconsistency in the x86 asm
parsing (and latent bug in the instruction definitions).
This is effectively a revert of r136287 which tried to address
a specific and narrow case of immediate operands failing to be accepted
by x86 instructions with a pretty heavy hammer: it introduced a new kind
of operand that behaved differently. All of that is removed with this
commit, but the test cases are both preserved and enhanced.
The core problem that r136287 and this commit are trying to handle is
that gas accepts both of the following instructions:
insertps $192, %xmm0, %xmm1
insertps $-64, %xmm0, %xmm1
These will encode to the same byte sequence, with the immediate
occupying an 8-bit entry. The first form was fixed by r136287 but that
broke the prior handling of the second form! =[ Ironically, we would
still emit the second form in some cases and then be unable to
re-assemble the output.
The reason why the first instruction failed to be handled is because
prior to r136287 the operands ere marked 'i32i8imm' which forces them to
be sign-extenable. Clearly, that won't work for 192 in a single byte.
However, making thim zero-extended or "unsigned" doesn't really address
the core issue either because it breaks negative immediates. The correct
fix is to make these operands 'i8imm' reflecting that they can be either
signed or unsigned but must be 8-bit immediates. This patch backs out
r136287 and then changes those places as well as some others to use
'i8imm' rather than one of the extended variants.
Naturally, this broke something else. The custom DAG nodes had to be
updated to have a much more accurate type constraint of an i8 node, and
a bunch of Pat immediates needed to be specified as i8 values.
The fallout didn't end there though. We also then ceased to be able to
match the instruction-specific intrinsics to the instructions so
modified. Digging, this is because they too used i32 rather than i8 in
their signature. So I've also switched those intrinsics to i8 arguments
in line with the instructions.
In order to make the intrinsic adjustments of course, I also had to add
auto upgrading for the intrinsics.
I suspect that the intrinsic argument types may have led everything down
this rabbit hole. Pretty happy with the result.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@217310 91177308-0d34-0410-b5e6-96231b3b80d8
2014-09-06 10:00:01 +00:00
|
|
|
// Upgrade the declarations of intrinsic functions whose 8-bit immediate mask
|
|
|
|
// arguments have changed their type from i32 to i8.
|
|
|
|
static bool UpgradeX86IntrinsicsWith8BitMask(Function *F, Intrinsic::ID IID,
|
|
|
|
Function *&NewFn) {
|
|
|
|
// Check that the last argument is an i32.
|
|
|
|
Type *LastArgType = F->getFunctionType()->getParamType(
|
|
|
|
F->getFunctionType()->getNumParams() - 1);
|
|
|
|
if (!LastArgType->isIntegerTy(32))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Move this function aside and map down.
|
|
|
|
F->setName(F->getName() + ".old");
|
|
|
|
NewFn = Intrinsic::getDeclaration(F->getParent(), IID);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-01-19 06:07:27 +00:00
|
|
|
// Upgrade the declarations of AVX-512 cmp intrinsic functions whose 8-bit
|
|
|
|
// immediates have changed their type from i32 to i8.
|
|
|
|
static bool UpgradeAVX512CmpIntrinsic(Function *F, Intrinsic::ID IID,
|
|
|
|
Function *&NewFn) {
|
|
|
|
// Check that the last argument is an i32.
|
|
|
|
Type *LastArgType = F->getFunctionType()->getParamType(2);
|
|
|
|
if (!LastArgType->isIntegerTy(32))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Move this function aside and map down.
|
|
|
|
F->setName(F->getName() + ".old");
|
|
|
|
NewFn = Intrinsic::getDeclaration(F->getParent(), IID);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2007-12-17 22:33:23 +00:00
|
|
|
static bool UpgradeIntrinsicFunction1(Function *F, Function *&NewFn) {
|
2007-08-04 01:51:18 +00:00
|
|
|
assert(F && "Illegal to upgrade a non-existent Function.");
|
|
|
|
|
|
|
|
// Quickly eliminate it, if it's not a candidate.
|
2011-06-18 18:56:39 +00:00
|
|
|
StringRef Name = F->getName();
|
|
|
|
if (Name.size() <= 8 || !Name.startswith("llvm."))
|
2007-12-17 22:33:23 +00:00
|
|
|
return false;
|
2011-06-18 18:56:39 +00:00
|
|
|
Name = Name.substr(5); // Strip off "llvm."
|
2011-11-27 08:42:07 +00:00
|
|
|
|
2011-06-18 18:56:39 +00:00
|
|
|
switch (Name[0]) {
|
2007-08-04 01:51:18 +00:00
|
|
|
default: break;
|
2012-07-13 23:25:25 +00:00
|
|
|
case 'a': {
|
|
|
|
if (Name.startswith("arm.neon.vclz")) {
|
|
|
|
Type* args[2] = {
|
2013-07-20 17:46:00 +00:00
|
|
|
F->arg_begin()->getType(),
|
2012-07-13 23:25:25 +00:00
|
|
|
Type::getInt1Ty(F->getContext())
|
|
|
|
};
|
|
|
|
// Can't use Intrinsic::getDeclaration here as it adds a ".i1" to
|
|
|
|
// the end of the name. Change name from llvm.arm.neon.vclz.* to
|
|
|
|
// llvm.ctlz.*
|
|
|
|
FunctionType* fType = FunctionType::get(F->getReturnType(), args, false);
|
2013-07-20 17:46:00 +00:00
|
|
|
NewFn = Function::Create(fType, F->getLinkage(),
|
2012-07-13 23:25:25 +00:00
|
|
|
"llvm.ctlz." + Name.substr(14), F->getParent());
|
|
|
|
return true;
|
|
|
|
}
|
2012-07-18 00:02:16 +00:00
|
|
|
if (Name.startswith("arm.neon.vcnt")) {
|
|
|
|
NewFn = Intrinsic::getDeclaration(F->getParent(), Intrinsic::ctpop,
|
|
|
|
F->arg_begin()->getType());
|
|
|
|
return true;
|
|
|
|
}
|
2012-07-13 23:25:25 +00:00
|
|
|
break;
|
|
|
|
}
|
2011-12-12 04:26:04 +00:00
|
|
|
case 'c': {
|
|
|
|
if (Name.startswith("ctlz.") && F->arg_size() == 1) {
|
|
|
|
F->setName(Name + ".old");
|
2011-12-12 10:57:20 +00:00
|
|
|
NewFn = Intrinsic::getDeclaration(F->getParent(), Intrinsic::ctlz,
|
|
|
|
F->arg_begin()->getType());
|
2011-12-12 04:26:04 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if (Name.startswith("cttz.") && F->arg_size() == 1) {
|
|
|
|
F->setName(Name + ".old");
|
2011-12-12 10:57:20 +00:00
|
|
|
NewFn = Intrinsic::getDeclaration(F->getParent(), Intrinsic::cttz,
|
|
|
|
F->arg_begin()->getType());
|
2011-12-12 04:26:04 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
Move the complex address expression out of DIVariable and into an extra
argument of the llvm.dbg.declare/llvm.dbg.value intrinsics.
Previously, DIVariable was a variable-length field that has an optional
reference to a Metadata array consisting of a variable number of
complex address expressions. In the case of OpPiece expressions this is
wasting a lot of storage in IR, because when an aggregate type is, e.g.,
SROA'd into all of its n individual members, the IR will contain n copies
of the DIVariable, all alike, only differing in the complex address
reference at the end.
By making the complex address into an extra argument of the
dbg.value/dbg.declare intrinsics, all of the pieces can reference the
same variable and the complex address expressions can be uniqued across
the CU, too.
Down the road, this will allow us to move other flags, such as
"indirection" out of the DIVariable, too.
The new intrinsics look like this:
declare void @llvm.dbg.declare(metadata %storage, metadata %var, metadata %expr)
declare void @llvm.dbg.value(metadata %storage, i64 %offset, metadata %var, metadata %expr)
This patch adds a new LLVM-local tag to DIExpressions, so we can detect
and pretty-print DIExpression metadata nodes.
What this patch doesn't do:
This patch does not touch the "Indirect" field in DIVariable; but moving
that into the expression would be a natural next step.
http://reviews.llvm.org/D4919
rdar://problem/17994491
Thanks to dblaikie and dexonsmith for reviewing this patch!
Note: I accidentally committed a bogus older version of this patch previously.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@218787 91177308-0d34-0410-b5e6-96231b3b80d8
2014-10-01 18:55:02 +00:00
|
|
|
case 'd': {
|
|
|
|
if (Name.startswith("dbg.declare") && F->arg_size() == 2) {
|
|
|
|
F->setName(Name + ".old");
|
|
|
|
NewFn = Intrinsic::getDeclaration(F->getParent(), Intrinsic::dbg_declare);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if (Name.startswith("dbg.value") && F->arg_size() == 3) {
|
|
|
|
F->setName(Name + ".old");
|
|
|
|
NewFn = Intrinsic::getDeclaration(F->getParent(), Intrinsic::dbg_value);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-10-07 18:06:48 +00:00
|
|
|
case 'o':
|
|
|
|
// We only need to change the name to match the mangling including the
|
|
|
|
// address space.
|
|
|
|
if (F->arg_size() == 2 && Name.startswith("objectsize.")) {
|
|
|
|
Type *Tys[2] = { F->getReturnType(), F->arg_begin()->getType() };
|
|
|
|
if (F->getName() != Intrinsic::getName(Intrinsic::objectsize, Tys)) {
|
|
|
|
F->setName(Name + ".old");
|
|
|
|
NewFn = Intrinsic::getDeclaration(F->getParent(),
|
|
|
|
Intrinsic::objectsize, Tys);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2012-02-03 06:10:55 +00:00
|
|
|
case 'x': {
|
|
|
|
if (Name.startswith("x86.sse2.pcmpeq.") ||
|
|
|
|
Name.startswith("x86.sse2.pcmpgt.") ||
|
|
|
|
Name.startswith("x86.avx2.pcmpeq.") ||
|
2012-04-18 05:24:00 +00:00
|
|
|
Name.startswith("x86.avx2.pcmpgt.") ||
|
2012-05-08 06:58:15 +00:00
|
|
|
Name.startswith("x86.avx.vpermil.") ||
|
|
|
|
Name == "x86.avx.movnt.dq.256" ||
|
|
|
|
Name == "x86.avx.movnt.pd.256" ||
|
2012-06-09 16:46:13 +00:00
|
|
|
Name == "x86.avx.movnt.ps.256" ||
|
2013-10-15 05:20:47 +00:00
|
|
|
Name == "x86.sse42.crc32.64.8" ||
|
2014-05-29 23:35:33 +00:00
|
|
|
Name == "x86.avx.vbroadcast.ss" ||
|
|
|
|
Name == "x86.avx.vbroadcast.ss.256" ||
|
|
|
|
Name == "x86.avx.vbroadcast.sd.256" ||
|
2015-02-18 06:24:44 +00:00
|
|
|
Name == "x86.sse2.psll.dq" ||
|
|
|
|
Name == "x86.sse2.psrl.dq" ||
|
|
|
|
Name == "x86.avx2.psll.dq" ||
|
|
|
|
Name == "x86.avx2.psrl.dq" ||
|
2015-02-13 06:07:24 +00:00
|
|
|
Name == "x86.sse2.psll.dq.bs" ||
|
|
|
|
Name == "x86.sse2.psrl.dq.bs" ||
|
2015-02-16 20:51:59 +00:00
|
|
|
Name == "x86.avx2.psll.dq.bs" ||
|
|
|
|
Name == "x86.avx2.psrl.dq.bs" ||
|
2015-02-28 19:33:17 +00:00
|
|
|
Name == "x86.sse41.pblendw" ||
|
|
|
|
Name == "x86.sse41.blendpd" ||
|
|
|
|
Name == "x86.sse41.blendps" ||
|
|
|
|
Name == "x86.avx.blend.pd.256" ||
|
|
|
|
Name == "x86.avx.blend.ps.256" ||
|
|
|
|
Name == "x86.avx2.pblendw" ||
|
|
|
|
Name == "x86.avx2.pblendd.128" ||
|
|
|
|
Name == "x86.avx2.pblendd.256" ||
|
2015-03-04 00:13:25 +00:00
|
|
|
Name == "x86.avx2.vbroadcasti128" ||
|
2012-06-09 16:46:13 +00:00
|
|
|
(Name.startswith("x86.xop.vpcom") && F->arg_size() == 2)) {
|
2014-04-09 06:08:46 +00:00
|
|
|
NewFn = nullptr;
|
2012-02-03 06:10:55 +00:00
|
|
|
return true;
|
|
|
|
}
|
2012-06-10 18:42:51 +00:00
|
|
|
// SSE4.1 ptest functions may have an old signature.
|
|
|
|
if (Name.startswith("x86.sse41.ptest")) {
|
|
|
|
if (Name == "x86.sse41.ptestc")
|
|
|
|
return UpgradeSSE41Function(F, Intrinsic::x86_sse41_ptestc, NewFn);
|
|
|
|
if (Name == "x86.sse41.ptestz")
|
|
|
|
return UpgradeSSE41Function(F, Intrinsic::x86_sse41_ptestz, NewFn);
|
|
|
|
if (Name == "x86.sse41.ptestnzc")
|
|
|
|
return UpgradeSSE41Function(F, Intrinsic::x86_sse41_ptestnzc, NewFn);
|
|
|
|
}
|
2015-02-28 22:25:06 +00:00
|
|
|
// Several blend and other instructions with masks used the wrong number of
|
[x86] Fix a pretty horrible bug and inconsistency in the x86 asm
parsing (and latent bug in the instruction definitions).
This is effectively a revert of r136287 which tried to address
a specific and narrow case of immediate operands failing to be accepted
by x86 instructions with a pretty heavy hammer: it introduced a new kind
of operand that behaved differently. All of that is removed with this
commit, but the test cases are both preserved and enhanced.
The core problem that r136287 and this commit are trying to handle is
that gas accepts both of the following instructions:
insertps $192, %xmm0, %xmm1
insertps $-64, %xmm0, %xmm1
These will encode to the same byte sequence, with the immediate
occupying an 8-bit entry. The first form was fixed by r136287 but that
broke the prior handling of the second form! =[ Ironically, we would
still emit the second form in some cases and then be unable to
re-assemble the output.
The reason why the first instruction failed to be handled is because
prior to r136287 the operands ere marked 'i32i8imm' which forces them to
be sign-extenable. Clearly, that won't work for 192 in a single byte.
However, making thim zero-extended or "unsigned" doesn't really address
the core issue either because it breaks negative immediates. The correct
fix is to make these operands 'i8imm' reflecting that they can be either
signed or unsigned but must be 8-bit immediates. This patch backs out
r136287 and then changes those places as well as some others to use
'i8imm' rather than one of the extended variants.
Naturally, this broke something else. The custom DAG nodes had to be
updated to have a much more accurate type constraint of an i8 node, and
a bunch of Pat immediates needed to be specified as i8 values.
The fallout didn't end there though. We also then ceased to be able to
match the instruction-specific intrinsics to the instructions so
modified. Digging, this is because they too used i32 rather than i8 in
their signature. So I've also switched those intrinsics to i8 arguments
in line with the instructions.
In order to make the intrinsic adjustments of course, I also had to add
auto upgrading for the intrinsics.
I suspect that the intrinsic argument types may have led everything down
this rabbit hole. Pretty happy with the result.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@217310 91177308-0d34-0410-b5e6-96231b3b80d8
2014-09-06 10:00:01 +00:00
|
|
|
// bits.
|
|
|
|
if (Name == "x86.sse41.insertps")
|
|
|
|
return UpgradeX86IntrinsicsWith8BitMask(F, Intrinsic::x86_sse41_insertps,
|
|
|
|
NewFn);
|
|
|
|
if (Name == "x86.sse41.dppd")
|
|
|
|
return UpgradeX86IntrinsicsWith8BitMask(F, Intrinsic::x86_sse41_dppd,
|
|
|
|
NewFn);
|
|
|
|
if (Name == "x86.sse41.dpps")
|
|
|
|
return UpgradeX86IntrinsicsWith8BitMask(F, Intrinsic::x86_sse41_dpps,
|
|
|
|
NewFn);
|
|
|
|
if (Name == "x86.sse41.mpsadbw")
|
|
|
|
return UpgradeX86IntrinsicsWith8BitMask(F, Intrinsic::x86_sse41_mpsadbw,
|
|
|
|
NewFn);
|
|
|
|
if (Name == "x86.avx.dp.ps.256")
|
|
|
|
return UpgradeX86IntrinsicsWith8BitMask(F, Intrinsic::x86_avx_dp_ps_256,
|
|
|
|
NewFn);
|
|
|
|
if (Name == "x86.avx2.mpsadbw")
|
|
|
|
return UpgradeX86IntrinsicsWith8BitMask(F, Intrinsic::x86_avx2_mpsadbw,
|
|
|
|
NewFn);
|
|
|
|
|
2015-01-19 06:07:27 +00:00
|
|
|
if (Name == "x86.avx512.mask.cmp.ps.512")
|
|
|
|
return UpgradeAVX512CmpIntrinsic(F, Intrinsic::x86_avx512_mask_cmp_ps_512,
|
|
|
|
NewFn);
|
|
|
|
if (Name == "x86.avx512.mask.cmp.pd.512")
|
|
|
|
return UpgradeAVX512CmpIntrinsic(F, Intrinsic::x86_avx512_mask_cmp_pd_512,
|
|
|
|
NewFn);
|
|
|
|
|
2015-01-25 23:26:02 +00:00
|
|
|
if (Name == "x86.avx512.mask.cmp.b.512")
|
|
|
|
return UpgradeAVX512CmpIntrinsic(F, Intrinsic::x86_avx512_mask_cmp_b_512,
|
|
|
|
NewFn);
|
|
|
|
if (Name == "x86.avx512.mask.cmp.w.512")
|
|
|
|
return UpgradeAVX512CmpIntrinsic(F, Intrinsic::x86_avx512_mask_cmp_w_512,
|
|
|
|
NewFn);
|
|
|
|
if (Name == "x86.avx512.mask.cmp.d.512")
|
|
|
|
return UpgradeAVX512CmpIntrinsic(F, Intrinsic::x86_avx512_mask_cmp_d_512,
|
|
|
|
NewFn);
|
|
|
|
if (Name == "x86.avx512.mask.cmp.q.512")
|
|
|
|
return UpgradeAVX512CmpIntrinsic(F, Intrinsic::x86_avx512_mask_cmp_q_512,
|
|
|
|
NewFn);
|
|
|
|
if (Name == "x86.avx512.mask.ucmp.b.512")
|
|
|
|
return UpgradeAVX512CmpIntrinsic(F, Intrinsic::x86_avx512_mask_ucmp_b_512,
|
|
|
|
NewFn);
|
|
|
|
if (Name == "x86.avx512.mask.ucmp.w.512")
|
|
|
|
return UpgradeAVX512CmpIntrinsic(F, Intrinsic::x86_avx512_mask_ucmp_w_512,
|
|
|
|
NewFn);
|
|
|
|
if (Name == "x86.avx512.mask.ucmp.d.512")
|
|
|
|
return UpgradeAVX512CmpIntrinsic(F, Intrinsic::x86_avx512_mask_ucmp_d_512,
|
|
|
|
NewFn);
|
|
|
|
if (Name == "x86.avx512.mask.ucmp.q.512")
|
|
|
|
return UpgradeAVX512CmpIntrinsic(F, Intrinsic::x86_avx512_mask_ucmp_q_512,
|
|
|
|
NewFn);
|
|
|
|
|
|
|
|
if (Name == "x86.avx512.mask.cmp.b.256")
|
|
|
|
return UpgradeAVX512CmpIntrinsic(F, Intrinsic::x86_avx512_mask_cmp_b_256,
|
|
|
|
NewFn);
|
|
|
|
if (Name == "x86.avx512.mask.cmp.w.256")
|
|
|
|
return UpgradeAVX512CmpIntrinsic(F, Intrinsic::x86_avx512_mask_cmp_w_256,
|
|
|
|
NewFn);
|
|
|
|
if (Name == "x86.avx512.mask.cmp.d.256")
|
|
|
|
return UpgradeAVX512CmpIntrinsic(F, Intrinsic::x86_avx512_mask_cmp_d_256,
|
|
|
|
NewFn);
|
|
|
|
if (Name == "x86.avx512.mask.cmp.q.256")
|
|
|
|
return UpgradeAVX512CmpIntrinsic(F, Intrinsic::x86_avx512_mask_cmp_q_256,
|
|
|
|
NewFn);
|
|
|
|
if (Name == "x86.avx512.mask.ucmp.b.256")
|
|
|
|
return UpgradeAVX512CmpIntrinsic(F, Intrinsic::x86_avx512_mask_ucmp_b_256,
|
|
|
|
NewFn);
|
|
|
|
if (Name == "x86.avx512.mask.ucmp.w.256")
|
|
|
|
return UpgradeAVX512CmpIntrinsic(F, Intrinsic::x86_avx512_mask_ucmp_w_256,
|
|
|
|
NewFn);
|
|
|
|
if (Name == "x86.avx512.mask.ucmp.d.256")
|
|
|
|
return UpgradeAVX512CmpIntrinsic(F, Intrinsic::x86_avx512_mask_ucmp_d_256,
|
|
|
|
NewFn);
|
|
|
|
if (Name == "x86.avx512.mask.ucmp.q.256")
|
|
|
|
return UpgradeAVX512CmpIntrinsic(F, Intrinsic::x86_avx512_mask_ucmp_q_256,
|
|
|
|
NewFn);
|
|
|
|
|
|
|
|
if (Name == "x86.avx512.mask.cmp.b.128")
|
|
|
|
return UpgradeAVX512CmpIntrinsic(F, Intrinsic::x86_avx512_mask_cmp_b_128,
|
|
|
|
NewFn);
|
|
|
|
if (Name == "x86.avx512.mask.cmp.w.128")
|
|
|
|
return UpgradeAVX512CmpIntrinsic(F, Intrinsic::x86_avx512_mask_cmp_w_128,
|
|
|
|
NewFn);
|
|
|
|
if (Name == "x86.avx512.mask.cmp.d.128")
|
|
|
|
return UpgradeAVX512CmpIntrinsic(F, Intrinsic::x86_avx512_mask_cmp_d_128,
|
|
|
|
NewFn);
|
|
|
|
if (Name == "x86.avx512.mask.cmp.q.128")
|
|
|
|
return UpgradeAVX512CmpIntrinsic(F, Intrinsic::x86_avx512_mask_cmp_q_128,
|
|
|
|
NewFn);
|
|
|
|
if (Name == "x86.avx512.mask.ucmp.b.128")
|
|
|
|
return UpgradeAVX512CmpIntrinsic(F, Intrinsic::x86_avx512_mask_ucmp_b_128,
|
|
|
|
NewFn);
|
|
|
|
if (Name == "x86.avx512.mask.ucmp.w.128")
|
|
|
|
return UpgradeAVX512CmpIntrinsic(F, Intrinsic::x86_avx512_mask_ucmp_w_128,
|
|
|
|
NewFn);
|
|
|
|
if (Name == "x86.avx512.mask.ucmp.d.128")
|
|
|
|
return UpgradeAVX512CmpIntrinsic(F, Intrinsic::x86_avx512_mask_ucmp_d_128,
|
|
|
|
NewFn);
|
|
|
|
if (Name == "x86.avx512.mask.ucmp.q.128")
|
|
|
|
return UpgradeAVX512CmpIntrinsic(F, Intrinsic::x86_avx512_mask_ucmp_q_128,
|
|
|
|
NewFn);
|
|
|
|
|
2012-06-13 07:18:53 +00:00
|
|
|
// frcz.ss/sd may need to have an argument dropped
|
|
|
|
if (Name.startswith("x86.xop.vfrcz.ss") && F->arg_size() == 2) {
|
|
|
|
F->setName(Name + ".old");
|
|
|
|
NewFn = Intrinsic::getDeclaration(F->getParent(),
|
|
|
|
Intrinsic::x86_xop_vfrcz_ss);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if (Name.startswith("x86.xop.vfrcz.sd") && F->arg_size() == 2) {
|
|
|
|
F->setName(Name + ".old");
|
|
|
|
NewFn = Intrinsic::getDeclaration(F->getParent(),
|
|
|
|
Intrinsic::x86_xop_vfrcz_sd);
|
|
|
|
return true;
|
|
|
|
}
|
2012-06-03 08:07:25 +00:00
|
|
|
// Fix the FMA4 intrinsics to remove the 4
|
|
|
|
if (Name.startswith("x86.fma4.")) {
|
2012-06-03 16:48:52 +00:00
|
|
|
F->setName("llvm.x86.fma" + Name.substr(8));
|
|
|
|
NewFn = F;
|
|
|
|
return true;
|
2012-06-03 08:07:25 +00:00
|
|
|
}
|
2012-02-03 06:10:55 +00:00
|
|
|
break;
|
|
|
|
}
|
2007-08-04 01:51:18 +00:00
|
|
|
}
|
|
|
|
|
2012-06-10 18:42:51 +00:00
|
|
|
// This may not belong here. This function is effectively being overloaded
|
|
|
|
// to both detect an intrinsic which needs upgrading, and to provide the
|
|
|
|
// upgraded form of the intrinsic. We should perhaps have two separate
|
2007-08-04 01:51:18 +00:00
|
|
|
// functions for this.
|
2007-12-17 22:33:23 +00:00
|
|
|
return false;
|
2007-08-04 01:51:18 +00:00
|
|
|
}
|
|
|
|
|
2007-12-17 22:33:23 +00:00
|
|
|
bool llvm::UpgradeIntrinsicFunction(Function *F, Function *&NewFn) {
|
2014-04-09 06:08:46 +00:00
|
|
|
NewFn = nullptr;
|
2007-12-17 22:33:23 +00:00
|
|
|
bool Upgraded = UpgradeIntrinsicFunction1(F, NewFn);
|
2007-12-03 20:06:50 +00:00
|
|
|
|
|
|
|
// Upgrade intrinsic attributes. This does not change the function.
|
2007-12-17 22:33:23 +00:00
|
|
|
if (NewFn)
|
|
|
|
F = NewFn;
|
2009-02-05 01:49:45 +00:00
|
|
|
if (unsigned id = F->getIntrinsicID())
|
2012-10-15 04:46:55 +00:00
|
|
|
F->setAttributes(Intrinsic::getAttributes(F->getContext(),
|
|
|
|
(Intrinsic::ID)id));
|
2007-12-03 20:06:50 +00:00
|
|
|
return Upgraded;
|
|
|
|
}
|
|
|
|
|
2010-09-10 18:51:56 +00:00
|
|
|
bool llvm::UpgradeGlobalVariable(GlobalVariable *GV) {
|
2011-06-18 06:05:24 +00:00
|
|
|
// Nothing to do yet.
|
2010-09-10 18:51:56 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
Move the complex address expression out of DIVariable and into an extra
argument of the llvm.dbg.declare/llvm.dbg.value intrinsics.
Previously, DIVariable was a variable-length field that has an optional
reference to a Metadata array consisting of a variable number of
complex address expressions. In the case of OpPiece expressions this is
wasting a lot of storage in IR, because when an aggregate type is, e.g.,
SROA'd into all of its n individual members, the IR will contain n copies
of the DIVariable, all alike, only differing in the complex address
reference at the end.
By making the complex address into an extra argument of the
dbg.value/dbg.declare intrinsics, all of the pieces can reference the
same variable and the complex address expressions can be uniqued across
the CU, too.
Down the road, this will allow us to move other flags, such as
"indirection" out of the DIVariable, too.
The new intrinsics look like this:
declare void @llvm.dbg.declare(metadata %storage, metadata %var, metadata %expr)
declare void @llvm.dbg.value(metadata %storage, i64 %offset, metadata %var, metadata %expr)
This patch adds a new LLVM-local tag to DIExpressions, so we can detect
and pretty-print DIExpression metadata nodes.
What this patch doesn't do:
This patch does not touch the "Indirect" field in DIVariable; but moving
that into the expression would be a natural next step.
http://reviews.llvm.org/D4919
rdar://problem/17994491
Thanks to dblaikie and dexonsmith for reviewing this patch!
Note: I accidentally committed a bogus older version of this patch previously.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@218787 91177308-0d34-0410-b5e6-96231b3b80d8
2014-10-01 18:55:02 +00:00
|
|
|
static MDNode *getNodeField(const MDNode *DbgNode, unsigned Elt) {
|
|
|
|
if (!DbgNode || Elt >= DbgNode->getNumOperands())
|
|
|
|
return nullptr;
|
|
|
|
return dyn_cast_or_null<MDNode>(DbgNode->getOperand(Elt));
|
|
|
|
}
|
|
|
|
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
static MetadataAsValue *getExpression(Value *VarOperand, Function *F) {
|
Move the complex address expression out of DIVariable and into an extra
argument of the llvm.dbg.declare/llvm.dbg.value intrinsics.
Previously, DIVariable was a variable-length field that has an optional
reference to a Metadata array consisting of a variable number of
complex address expressions. In the case of OpPiece expressions this is
wasting a lot of storage in IR, because when an aggregate type is, e.g.,
SROA'd into all of its n individual members, the IR will contain n copies
of the DIVariable, all alike, only differing in the complex address
reference at the end.
By making the complex address into an extra argument of the
dbg.value/dbg.declare intrinsics, all of the pieces can reference the
same variable and the complex address expressions can be uniqued across
the CU, too.
Down the road, this will allow us to move other flags, such as
"indirection" out of the DIVariable, too.
The new intrinsics look like this:
declare void @llvm.dbg.declare(metadata %storage, metadata %var, metadata %expr)
declare void @llvm.dbg.value(metadata %storage, i64 %offset, metadata %var, metadata %expr)
This patch adds a new LLVM-local tag to DIExpressions, so we can detect
and pretty-print DIExpression metadata nodes.
What this patch doesn't do:
This patch does not touch the "Indirect" field in DIVariable; but moving
that into the expression would be a natural next step.
http://reviews.llvm.org/D4919
rdar://problem/17994491
Thanks to dblaikie and dexonsmith for reviewing this patch!
Note: I accidentally committed a bogus older version of this patch previously.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@218787 91177308-0d34-0410-b5e6-96231b3b80d8
2014-10-01 18:55:02 +00:00
|
|
|
// Old-style DIVariables have an optional expression as the 8th element.
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
DIExpression Expr(getNodeField(
|
|
|
|
cast<MDNode>(cast<MetadataAsValue>(VarOperand)->getMetadata()), 8));
|
Move the complex address expression out of DIVariable and into an extra
argument of the llvm.dbg.declare/llvm.dbg.value intrinsics.
Previously, DIVariable was a variable-length field that has an optional
reference to a Metadata array consisting of a variable number of
complex address expressions. In the case of OpPiece expressions this is
wasting a lot of storage in IR, because when an aggregate type is, e.g.,
SROA'd into all of its n individual members, the IR will contain n copies
of the DIVariable, all alike, only differing in the complex address
reference at the end.
By making the complex address into an extra argument of the
dbg.value/dbg.declare intrinsics, all of the pieces can reference the
same variable and the complex address expressions can be uniqued across
the CU, too.
Down the road, this will allow us to move other flags, such as
"indirection" out of the DIVariable, too.
The new intrinsics look like this:
declare void @llvm.dbg.declare(metadata %storage, metadata %var, metadata %expr)
declare void @llvm.dbg.value(metadata %storage, i64 %offset, metadata %var, metadata %expr)
This patch adds a new LLVM-local tag to DIExpressions, so we can detect
and pretty-print DIExpression metadata nodes.
What this patch doesn't do:
This patch does not touch the "Indirect" field in DIVariable; but moving
that into the expression would be a natural next step.
http://reviews.llvm.org/D4919
rdar://problem/17994491
Thanks to dblaikie and dexonsmith for reviewing this patch!
Note: I accidentally committed a bogus older version of this patch previously.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@218787 91177308-0d34-0410-b5e6-96231b3b80d8
2014-10-01 18:55:02 +00:00
|
|
|
if (!Expr) {
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
DIBuilder DIB(*F->getParent(), /*AllowUnresolved*/ false);
|
Move the complex address expression out of DIVariable and into an extra
argument of the llvm.dbg.declare/llvm.dbg.value intrinsics.
Previously, DIVariable was a variable-length field that has an optional
reference to a Metadata array consisting of a variable number of
complex address expressions. In the case of OpPiece expressions this is
wasting a lot of storage in IR, because when an aggregate type is, e.g.,
SROA'd into all of its n individual members, the IR will contain n copies
of the DIVariable, all alike, only differing in the complex address
reference at the end.
By making the complex address into an extra argument of the
dbg.value/dbg.declare intrinsics, all of the pieces can reference the
same variable and the complex address expressions can be uniqued across
the CU, too.
Down the road, this will allow us to move other flags, such as
"indirection" out of the DIVariable, too.
The new intrinsics look like this:
declare void @llvm.dbg.declare(metadata %storage, metadata %var, metadata %expr)
declare void @llvm.dbg.value(metadata %storage, i64 %offset, metadata %var, metadata %expr)
This patch adds a new LLVM-local tag to DIExpressions, so we can detect
and pretty-print DIExpression metadata nodes.
What this patch doesn't do:
This patch does not touch the "Indirect" field in DIVariable; but moving
that into the expression would be a natural next step.
http://reviews.llvm.org/D4919
rdar://problem/17994491
Thanks to dblaikie and dexonsmith for reviewing this patch!
Note: I accidentally committed a bogus older version of this patch previously.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@218787 91177308-0d34-0410-b5e6-96231b3b80d8
2014-10-01 18:55:02 +00:00
|
|
|
Expr = DIB.createExpression();
|
|
|
|
}
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
return MetadataAsValue::get(F->getContext(), Expr);
|
Move the complex address expression out of DIVariable and into an extra
argument of the llvm.dbg.declare/llvm.dbg.value intrinsics.
Previously, DIVariable was a variable-length field that has an optional
reference to a Metadata array consisting of a variable number of
complex address expressions. In the case of OpPiece expressions this is
wasting a lot of storage in IR, because when an aggregate type is, e.g.,
SROA'd into all of its n individual members, the IR will contain n copies
of the DIVariable, all alike, only differing in the complex address
reference at the end.
By making the complex address into an extra argument of the
dbg.value/dbg.declare intrinsics, all of the pieces can reference the
same variable and the complex address expressions can be uniqued across
the CU, too.
Down the road, this will allow us to move other flags, such as
"indirection" out of the DIVariable, too.
The new intrinsics look like this:
declare void @llvm.dbg.declare(metadata %storage, metadata %var, metadata %expr)
declare void @llvm.dbg.value(metadata %storage, i64 %offset, metadata %var, metadata %expr)
This patch adds a new LLVM-local tag to DIExpressions, so we can detect
and pretty-print DIExpression metadata nodes.
What this patch doesn't do:
This patch does not touch the "Indirect" field in DIVariable; but moving
that into the expression would be a natural next step.
http://reviews.llvm.org/D4919
rdar://problem/17994491
Thanks to dblaikie and dexonsmith for reviewing this patch!
Note: I accidentally committed a bogus older version of this patch previously.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@218787 91177308-0d34-0410-b5e6-96231b3b80d8
2014-10-01 18:55:02 +00:00
|
|
|
}
|
|
|
|
|
2015-02-18 06:24:44 +00:00
|
|
|
// Handles upgrading SSE2 and AVX2 PSLLDQ intrinsics by converting them
|
|
|
|
// to byte shuffles.
|
|
|
|
static Value *UpgradeX86PSLLDQIntrinsics(IRBuilder<> &Builder, LLVMContext &C,
|
|
|
|
Value *Op, unsigned NumLanes,
|
|
|
|
unsigned Shift) {
|
|
|
|
// Each lane is 16 bytes.
|
|
|
|
unsigned NumElts = NumLanes * 16;
|
|
|
|
|
|
|
|
// Bitcast from a 64-bit element type to a byte element type.
|
|
|
|
Op = Builder.CreateBitCast(Op,
|
|
|
|
VectorType::get(Type::getInt8Ty(C), NumElts),
|
|
|
|
"cast");
|
|
|
|
// We'll be shuffling in zeroes.
|
|
|
|
Value *Res = ConstantVector::getSplat(NumElts, Builder.getInt8(0));
|
|
|
|
|
|
|
|
// If shift is less than 16, emit a shuffle to move the bytes. Otherwise,
|
|
|
|
// we'll just return the zero vector.
|
|
|
|
if (Shift < 16) {
|
|
|
|
SmallVector<Constant*, 32> Idxs;
|
|
|
|
// 256-bit version is split into two 16-byte lanes.
|
|
|
|
for (unsigned l = 0; l != NumElts; l += 16)
|
|
|
|
for (unsigned i = 0; i != 16; ++i) {
|
|
|
|
unsigned Idx = NumElts + i - Shift;
|
|
|
|
if (Idx < NumElts)
|
|
|
|
Idx -= NumElts - 16; // end of lane, switch operand.
|
|
|
|
Idxs.push_back(Builder.getInt32(Idx + l));
|
|
|
|
}
|
|
|
|
|
|
|
|
Res = Builder.CreateShuffleVector(Res, Op, ConstantVector::get(Idxs));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Bitcast back to a 64-bit element type.
|
|
|
|
return Builder.CreateBitCast(Res,
|
|
|
|
VectorType::get(Type::getInt64Ty(C), 2*NumLanes),
|
|
|
|
"cast");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Handles upgrading SSE2 and AVX2 PSRLDQ intrinsics by converting them
|
|
|
|
// to byte shuffles.
|
|
|
|
static Value *UpgradeX86PSRLDQIntrinsics(IRBuilder<> &Builder, LLVMContext &C,
|
|
|
|
Value *Op, unsigned NumLanes,
|
|
|
|
unsigned Shift) {
|
|
|
|
// Each lane is 16 bytes.
|
|
|
|
unsigned NumElts = NumLanes * 16;
|
|
|
|
|
|
|
|
// Bitcast from a 64-bit element type to a byte element type.
|
|
|
|
Op = Builder.CreateBitCast(Op,
|
|
|
|
VectorType::get(Type::getInt8Ty(C), NumElts),
|
|
|
|
"cast");
|
|
|
|
// We'll be shuffling in zeroes.
|
|
|
|
Value *Res = ConstantVector::getSplat(NumElts, Builder.getInt8(0));
|
|
|
|
|
|
|
|
// If shift is less than 16, emit a shuffle to move the bytes. Otherwise,
|
|
|
|
// we'll just return the zero vector.
|
|
|
|
if (Shift < 16) {
|
|
|
|
SmallVector<Constant*, 32> Idxs;
|
|
|
|
// 256-bit version is split into two 16-byte lanes.
|
|
|
|
for (unsigned l = 0; l != NumElts; l += 16)
|
|
|
|
for (unsigned i = 0; i != 16; ++i) {
|
|
|
|
unsigned Idx = i + Shift;
|
|
|
|
if (Idx >= 16)
|
|
|
|
Idx += NumElts - 16; // end of lane, switch operand.
|
|
|
|
Idxs.push_back(Builder.getInt32(Idx + l));
|
|
|
|
}
|
|
|
|
|
|
|
|
Res = Builder.CreateShuffleVector(Op, Res, ConstantVector::get(Idxs));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Bitcast back to a 64-bit element type.
|
|
|
|
return Builder.CreateBitCast(Res,
|
|
|
|
VectorType::get(Type::getInt64Ty(C), 2*NumLanes),
|
|
|
|
"cast");
|
|
|
|
}
|
|
|
|
|
2012-06-10 18:42:51 +00:00
|
|
|
// UpgradeIntrinsicCall - Upgrade a call to an old intrinsic to be a call the
|
|
|
|
// upgraded intrinsic. All argument and return casting must be provided in
|
2007-08-04 01:51:18 +00:00
|
|
|
// order to seamlessly integrate with existing context.
|
|
|
|
void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) {
|
2012-02-03 06:10:55 +00:00
|
|
|
Function *F = CI->getCalledFunction();
|
2011-12-12 22:59:34 +00:00
|
|
|
LLVMContext &C = CI->getContext();
|
2011-12-12 04:26:04 +00:00
|
|
|
IRBuilder<> Builder(C);
|
|
|
|
Builder.SetInsertPoint(CI->getParent(), CI);
|
|
|
|
|
2012-02-03 06:10:55 +00:00
|
|
|
assert(F && "Intrinsic call is not direct?");
|
|
|
|
|
|
|
|
if (!NewFn) {
|
|
|
|
// Get the Function's name.
|
|
|
|
StringRef Name = F->getName();
|
|
|
|
|
|
|
|
Value *Rep;
|
|
|
|
// Upgrade packed integer vector compares intrinsics to compare instructions
|
|
|
|
if (Name.startswith("llvm.x86.sse2.pcmpeq.") ||
|
|
|
|
Name.startswith("llvm.x86.avx2.pcmpeq.")) {
|
|
|
|
Rep = Builder.CreateICmpEQ(CI->getArgOperand(0), CI->getArgOperand(1),
|
|
|
|
"pcmpeq");
|
|
|
|
// need to sign extend since icmp returns vector of i1
|
|
|
|
Rep = Builder.CreateSExt(Rep, CI->getType(), "");
|
|
|
|
} else if (Name.startswith("llvm.x86.sse2.pcmpgt.") ||
|
|
|
|
Name.startswith("llvm.x86.avx2.pcmpgt.")) {
|
|
|
|
Rep = Builder.CreateICmpSGT(CI->getArgOperand(0), CI->getArgOperand(1),
|
|
|
|
"pcmpgt");
|
|
|
|
// need to sign extend since icmp returns vector of i1
|
|
|
|
Rep = Builder.CreateSExt(Rep, CI->getType(), "");
|
2012-05-08 06:58:15 +00:00
|
|
|
} else if (Name == "llvm.x86.avx.movnt.dq.256" ||
|
|
|
|
Name == "llvm.x86.avx.movnt.ps.256" ||
|
|
|
|
Name == "llvm.x86.avx.movnt.pd.256") {
|
|
|
|
IRBuilder<> Builder(C);
|
|
|
|
Builder.SetInsertPoint(CI->getParent(), CI);
|
|
|
|
|
|
|
|
Module *M = F->getParent();
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
SmallVector<Metadata *, 1> Elts;
|
|
|
|
Elts.push_back(
|
|
|
|
ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(C), 1)));
|
2012-05-08 06:58:15 +00:00
|
|
|
MDNode *Node = MDNode::get(C, Elts);
|
|
|
|
|
|
|
|
Value *Arg0 = CI->getArgOperand(0);
|
|
|
|
Value *Arg1 = CI->getArgOperand(1);
|
|
|
|
|
|
|
|
// Convert the type of the pointer to a pointer to the stored type.
|
|
|
|
Value *BC = Builder.CreateBitCast(Arg0,
|
|
|
|
PointerType::getUnqual(Arg1->getType()),
|
|
|
|
"cast");
|
|
|
|
StoreInst *SI = Builder.CreateStore(Arg1, BC);
|
|
|
|
SI->setMetadata(M->getMDKindID("nontemporal"), Node);
|
|
|
|
SI->setAlignment(16);
|
|
|
|
|
|
|
|
// Remove intrinsic.
|
|
|
|
CI->eraseFromParent();
|
|
|
|
return;
|
2012-06-09 16:46:13 +00:00
|
|
|
} else if (Name.startswith("llvm.x86.xop.vpcom")) {
|
|
|
|
Intrinsic::ID intID;
|
|
|
|
if (Name.endswith("ub"))
|
|
|
|
intID = Intrinsic::x86_xop_vpcomub;
|
|
|
|
else if (Name.endswith("uw"))
|
|
|
|
intID = Intrinsic::x86_xop_vpcomuw;
|
|
|
|
else if (Name.endswith("ud"))
|
|
|
|
intID = Intrinsic::x86_xop_vpcomud;
|
|
|
|
else if (Name.endswith("uq"))
|
|
|
|
intID = Intrinsic::x86_xop_vpcomuq;
|
|
|
|
else if (Name.endswith("b"))
|
|
|
|
intID = Intrinsic::x86_xop_vpcomb;
|
|
|
|
else if (Name.endswith("w"))
|
|
|
|
intID = Intrinsic::x86_xop_vpcomw;
|
|
|
|
else if (Name.endswith("d"))
|
|
|
|
intID = Intrinsic::x86_xop_vpcomd;
|
|
|
|
else if (Name.endswith("q"))
|
|
|
|
intID = Intrinsic::x86_xop_vpcomq;
|
|
|
|
else
|
|
|
|
llvm_unreachable("Unknown suffix");
|
|
|
|
|
|
|
|
Name = Name.substr(18); // strip off "llvm.x86.xop.vpcom"
|
|
|
|
unsigned Imm;
|
|
|
|
if (Name.startswith("lt"))
|
|
|
|
Imm = 0;
|
|
|
|
else if (Name.startswith("le"))
|
|
|
|
Imm = 1;
|
|
|
|
else if (Name.startswith("gt"))
|
|
|
|
Imm = 2;
|
|
|
|
else if (Name.startswith("ge"))
|
|
|
|
Imm = 3;
|
|
|
|
else if (Name.startswith("eq"))
|
|
|
|
Imm = 4;
|
|
|
|
else if (Name.startswith("ne"))
|
|
|
|
Imm = 5;
|
|
|
|
else if (Name.startswith("false"))
|
2015-02-13 07:42:15 +00:00
|
|
|
Imm = 6;
|
|
|
|
else if (Name.startswith("true"))
|
2012-06-09 16:46:13 +00:00
|
|
|
Imm = 7;
|
|
|
|
else
|
|
|
|
llvm_unreachable("Unknown condition");
|
|
|
|
|
|
|
|
Function *VPCOM = Intrinsic::getDeclaration(F->getParent(), intID);
|
|
|
|
Rep = Builder.CreateCall3(VPCOM, CI->getArgOperand(0),
|
|
|
|
CI->getArgOperand(1), Builder.getInt8(Imm));
|
2013-10-15 05:20:47 +00:00
|
|
|
} else if (Name == "llvm.x86.sse42.crc32.64.8") {
|
|
|
|
Function *CRC32 = Intrinsic::getDeclaration(F->getParent(),
|
|
|
|
Intrinsic::x86_sse42_crc32_32_8);
|
|
|
|
Value *Trunc0 = Builder.CreateTrunc(CI->getArgOperand(0), Type::getInt32Ty(C));
|
|
|
|
Rep = Builder.CreateCall2(CRC32, Trunc0, CI->getArgOperand(1));
|
|
|
|
Rep = Builder.CreateZExt(Rep, CI->getType(), "");
|
2014-05-29 23:35:33 +00:00
|
|
|
} else if (Name.startswith("llvm.x86.avx.vbroadcast")) {
|
|
|
|
// Replace broadcasts with a series of insertelements.
|
|
|
|
Type *VecTy = CI->getType();
|
|
|
|
Type *EltTy = VecTy->getVectorElementType();
|
|
|
|
unsigned EltNum = VecTy->getVectorNumElements();
|
|
|
|
Value *Cast = Builder.CreateBitCast(CI->getArgOperand(0),
|
|
|
|
EltTy->getPointerTo());
|
|
|
|
Value *Load = Builder.CreateLoad(Cast);
|
|
|
|
Type *I32Ty = Type::getInt32Ty(C);
|
|
|
|
Rep = UndefValue::get(VecTy);
|
|
|
|
for (unsigned I = 0; I < EltNum; ++I)
|
|
|
|
Rep = Builder.CreateInsertElement(Rep, Load,
|
|
|
|
ConstantInt::get(I32Ty, I));
|
2015-03-04 00:13:25 +00:00
|
|
|
} else if (Name == "llvm.x86.avx2.vbroadcasti128") {
|
|
|
|
// Replace vbroadcasts with a vector shuffle.
|
|
|
|
Value *Op = Builder.CreatePointerCast(
|
|
|
|
CI->getArgOperand(0),
|
|
|
|
PointerType::getUnqual(VectorType::get(Type::getInt64Ty(C), 2)));
|
|
|
|
Value *Load = Builder.CreateLoad(Op);
|
|
|
|
SmallVector<Constant *, 4> Idxs; // 0, 1, 0, 1.
|
|
|
|
for (unsigned i = 0; i != 4; ++i)
|
|
|
|
Idxs.push_back(Builder.getInt32(i & 1));
|
|
|
|
Rep = Builder.CreateShuffleVector(Load, UndefValue::get(Load->getType()),
|
|
|
|
ConstantVector::get(Idxs));
|
2015-02-18 06:24:44 +00:00
|
|
|
} else if (Name == "llvm.x86.sse2.psll.dq") {
|
|
|
|
// 128-bit shift left specified in bits.
|
|
|
|
unsigned Shift = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
|
|
|
|
Rep = UpgradeX86PSLLDQIntrinsics(Builder, C, CI->getArgOperand(0), 1,
|
|
|
|
Shift / 8); // Shift is in bits.
|
|
|
|
} else if (Name == "llvm.x86.sse2.psrl.dq") {
|
|
|
|
// 128-bit shift right specified in bits.
|
|
|
|
unsigned Shift = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
|
|
|
|
Rep = UpgradeX86PSRLDQIntrinsics(Builder, C, CI->getArgOperand(0), 1,
|
|
|
|
Shift / 8); // Shift is in bits.
|
|
|
|
} else if (Name == "llvm.x86.avx2.psll.dq") {
|
|
|
|
// 256-bit shift left specified in bits.
|
|
|
|
unsigned Shift = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
|
|
|
|
Rep = UpgradeX86PSLLDQIntrinsics(Builder, C, CI->getArgOperand(0), 2,
|
|
|
|
Shift / 8); // Shift is in bits.
|
|
|
|
} else if (Name == "llvm.x86.avx2.psrl.dq") {
|
|
|
|
// 256-bit shift right specified in bits.
|
|
|
|
unsigned Shift = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
|
|
|
|
Rep = UpgradeX86PSRLDQIntrinsics(Builder, C, CI->getArgOperand(0), 2,
|
|
|
|
Shift / 8); // Shift is in bits.
|
2015-02-13 06:07:24 +00:00
|
|
|
} else if (Name == "llvm.x86.sse2.psll.dq.bs") {
|
2015-02-18 06:24:44 +00:00
|
|
|
// 128-bit shift left specified in bytes.
|
2015-02-13 06:07:24 +00:00
|
|
|
unsigned Shift = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
|
2015-02-18 06:24:44 +00:00
|
|
|
Rep = UpgradeX86PSLLDQIntrinsics(Builder, C, CI->getArgOperand(0), 1,
|
|
|
|
Shift);
|
2015-02-13 06:07:24 +00:00
|
|
|
} else if (Name == "llvm.x86.sse2.psrl.dq.bs") {
|
2015-02-18 06:24:44 +00:00
|
|
|
// 128-bit shift right specified in bytes.
|
2015-02-13 06:07:24 +00:00
|
|
|
unsigned Shift = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
|
2015-02-18 06:24:44 +00:00
|
|
|
Rep = UpgradeX86PSRLDQIntrinsics(Builder, C, CI->getArgOperand(0), 1,
|
|
|
|
Shift);
|
2015-02-16 20:51:59 +00:00
|
|
|
} else if (Name == "llvm.x86.avx2.psll.dq.bs") {
|
2015-02-18 06:24:44 +00:00
|
|
|
// 256-bit shift left specified in bytes.
|
2015-02-16 20:51:59 +00:00
|
|
|
unsigned Shift = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
|
2015-02-18 06:24:44 +00:00
|
|
|
Rep = UpgradeX86PSLLDQIntrinsics(Builder, C, CI->getArgOperand(0), 2,
|
|
|
|
Shift);
|
2015-02-16 20:51:59 +00:00
|
|
|
} else if (Name == "llvm.x86.avx2.psrl.dq.bs") {
|
2015-02-18 06:24:44 +00:00
|
|
|
// 256-bit shift right specified in bytes.
|
2015-02-16 20:51:59 +00:00
|
|
|
unsigned Shift = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
|
2015-02-18 06:24:44 +00:00
|
|
|
Rep = UpgradeX86PSRLDQIntrinsics(Builder, C, CI->getArgOperand(0), 2,
|
|
|
|
Shift);
|
2015-02-28 19:33:17 +00:00
|
|
|
} else if (Name == "llvm.x86.sse41.pblendw" ||
|
|
|
|
Name == "llvm.x86.sse41.blendpd" ||
|
|
|
|
Name == "llvm.x86.sse41.blendps" ||
|
|
|
|
Name == "llvm.x86.avx.blend.pd.256" ||
|
|
|
|
Name == "llvm.x86.avx.blend.ps.256" ||
|
|
|
|
Name == "llvm.x86.avx2.pblendw" ||
|
|
|
|
Name == "llvm.x86.avx2.pblendd.128" ||
|
|
|
|
Name == "llvm.x86.avx2.pblendd.256") {
|
|
|
|
Value *Op0 = CI->getArgOperand(0);
|
|
|
|
Value *Op1 = CI->getArgOperand(1);
|
|
|
|
unsigned Imm = cast <ConstantInt>(CI->getArgOperand(2))->getZExtValue();
|
|
|
|
VectorType *VecTy = cast<VectorType>(CI->getType());
|
|
|
|
unsigned NumElts = VecTy->getNumElements();
|
|
|
|
|
|
|
|
SmallVector<Constant*, 16> Idxs;
|
|
|
|
for (unsigned i = 0; i != NumElts; ++i) {
|
|
|
|
unsigned Idx = ((Imm >> (i%8)) & 1) ? i + NumElts : i;
|
|
|
|
Idxs.push_back(Builder.getInt32(Idx));
|
|
|
|
}
|
|
|
|
|
|
|
|
Rep = Builder.CreateShuffleVector(Op0, Op1, ConstantVector::get(Idxs));
|
2012-02-03 06:10:55 +00:00
|
|
|
} else {
|
2012-04-18 05:24:00 +00:00
|
|
|
bool PD128 = false, PD256 = false, PS128 = false, PS256 = false;
|
2012-05-08 06:58:15 +00:00
|
|
|
if (Name == "llvm.x86.avx.vpermil.pd.256")
|
2012-04-18 05:24:00 +00:00
|
|
|
PD256 = true;
|
2012-05-08 06:58:15 +00:00
|
|
|
else if (Name == "llvm.x86.avx.vpermil.pd")
|
2012-04-18 05:24:00 +00:00
|
|
|
PD128 = true;
|
2012-05-08 06:58:15 +00:00
|
|
|
else if (Name == "llvm.x86.avx.vpermil.ps.256")
|
2012-04-18 05:24:00 +00:00
|
|
|
PS256 = true;
|
2012-05-08 06:58:15 +00:00
|
|
|
else if (Name == "llvm.x86.avx.vpermil.ps")
|
2012-04-18 05:24:00 +00:00
|
|
|
PS128 = true;
|
|
|
|
|
|
|
|
if (PD256 || PD128 || PS256 || PS128) {
|
|
|
|
Value *Op0 = CI->getArgOperand(0);
|
|
|
|
unsigned Imm = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
|
|
|
|
SmallVector<Constant*, 8> Idxs;
|
|
|
|
|
|
|
|
if (PD128)
|
|
|
|
for (unsigned i = 0; i != 2; ++i)
|
|
|
|
Idxs.push_back(Builder.getInt32((Imm >> i) & 0x1));
|
|
|
|
else if (PD256)
|
|
|
|
for (unsigned l = 0; l != 4; l+=2)
|
|
|
|
for (unsigned i = 0; i != 2; ++i)
|
|
|
|
Idxs.push_back(Builder.getInt32(((Imm >> (l+i)) & 0x1) + l));
|
|
|
|
else if (PS128)
|
|
|
|
for (unsigned i = 0; i != 4; ++i)
|
|
|
|
Idxs.push_back(Builder.getInt32((Imm >> (2 * i)) & 0x3));
|
|
|
|
else if (PS256)
|
|
|
|
for (unsigned l = 0; l != 8; l+=4)
|
|
|
|
for (unsigned i = 0; i != 4; ++i)
|
|
|
|
Idxs.push_back(Builder.getInt32(((Imm >> (2 * i)) & 0x3) + l));
|
|
|
|
else
|
|
|
|
llvm_unreachable("Unexpected function");
|
|
|
|
|
|
|
|
Rep = Builder.CreateShuffleVector(Op0, Op0, ConstantVector::get(Idxs));
|
|
|
|
} else {
|
|
|
|
llvm_unreachable("Unknown function for CallInst upgrade.");
|
|
|
|
}
|
2012-02-03 06:10:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
CI->replaceAllUsesWith(Rep);
|
|
|
|
CI->eraseFromParent();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-07-20 21:09:18 +00:00
|
|
|
std::string Name = CI->getName().str();
|
Move the complex address expression out of DIVariable and into an extra
argument of the llvm.dbg.declare/llvm.dbg.value intrinsics.
Previously, DIVariable was a variable-length field that has an optional
reference to a Metadata array consisting of a variable number of
complex address expressions. In the case of OpPiece expressions this is
wasting a lot of storage in IR, because when an aggregate type is, e.g.,
SROA'd into all of its n individual members, the IR will contain n copies
of the DIVariable, all alike, only differing in the complex address
reference at the end.
By making the complex address into an extra argument of the
dbg.value/dbg.declare intrinsics, all of the pieces can reference the
same variable and the complex address expressions can be uniqued across
the CU, too.
Down the road, this will allow us to move other flags, such as
"indirection" out of the DIVariable, too.
The new intrinsics look like this:
declare void @llvm.dbg.declare(metadata %storage, metadata %var, metadata %expr)
declare void @llvm.dbg.value(metadata %storage, i64 %offset, metadata %var, metadata %expr)
This patch adds a new LLVM-local tag to DIExpressions, so we can detect
and pretty-print DIExpression metadata nodes.
What this patch doesn't do:
This patch does not touch the "Indirect" field in DIVariable; but moving
that into the expression would be a natural next step.
http://reviews.llvm.org/D4919
rdar://problem/17994491
Thanks to dblaikie and dexonsmith for reviewing this patch!
Note: I accidentally committed a bogus older version of this patch previously.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@218787 91177308-0d34-0410-b5e6-96231b3b80d8
2014-10-01 18:55:02 +00:00
|
|
|
if (!Name.empty())
|
|
|
|
CI->setName(Name + ".old");
|
2012-06-10 18:42:51 +00:00
|
|
|
|
2011-12-12 04:26:04 +00:00
|
|
|
switch (NewFn->getIntrinsicID()) {
|
|
|
|
default:
|
2011-11-27 08:42:07 +00:00
|
|
|
llvm_unreachable("Unknown function for CallInst upgrade.");
|
2011-12-12 04:26:04 +00:00
|
|
|
|
Move the complex address expression out of DIVariable and into an extra
argument of the llvm.dbg.declare/llvm.dbg.value intrinsics.
Previously, DIVariable was a variable-length field that has an optional
reference to a Metadata array consisting of a variable number of
complex address expressions. In the case of OpPiece expressions this is
wasting a lot of storage in IR, because when an aggregate type is, e.g.,
SROA'd into all of its n individual members, the IR will contain n copies
of the DIVariable, all alike, only differing in the complex address
reference at the end.
By making the complex address into an extra argument of the
dbg.value/dbg.declare intrinsics, all of the pieces can reference the
same variable and the complex address expressions can be uniqued across
the CU, too.
Down the road, this will allow us to move other flags, such as
"indirection" out of the DIVariable, too.
The new intrinsics look like this:
declare void @llvm.dbg.declare(metadata %storage, metadata %var, metadata %expr)
declare void @llvm.dbg.value(metadata %storage, i64 %offset, metadata %var, metadata %expr)
This patch adds a new LLVM-local tag to DIExpressions, so we can detect
and pretty-print DIExpression metadata nodes.
What this patch doesn't do:
This patch does not touch the "Indirect" field in DIVariable; but moving
that into the expression would be a natural next step.
http://reviews.llvm.org/D4919
rdar://problem/17994491
Thanks to dblaikie and dexonsmith for reviewing this patch!
Note: I accidentally committed a bogus older version of this patch previously.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@218787 91177308-0d34-0410-b5e6-96231b3b80d8
2014-10-01 18:55:02 +00:00
|
|
|
// Upgrade debug intrinsics to use an additional DIExpression argument.
|
|
|
|
case Intrinsic::dbg_declare: {
|
|
|
|
auto NewCI =
|
|
|
|
Builder.CreateCall3(NewFn, CI->getArgOperand(0), CI->getArgOperand(1),
|
|
|
|
getExpression(CI->getArgOperand(1), F), Name);
|
|
|
|
NewCI->setDebugLoc(CI->getDebugLoc());
|
|
|
|
CI->replaceAllUsesWith(NewCI);
|
|
|
|
CI->eraseFromParent();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case Intrinsic::dbg_value: {
|
|
|
|
auto NewCI = Builder.CreateCall4(
|
|
|
|
NewFn, CI->getArgOperand(0), CI->getArgOperand(1), CI->getArgOperand(2),
|
|
|
|
getExpression(CI->getArgOperand(2), F), Name);
|
|
|
|
NewCI->setDebugLoc(CI->getDebugLoc());
|
|
|
|
CI->replaceAllUsesWith(NewCI);
|
|
|
|
CI->eraseFromParent();
|
|
|
|
return;
|
|
|
|
}
|
2011-12-12 04:26:04 +00:00
|
|
|
case Intrinsic::ctlz:
|
2012-05-22 15:25:31 +00:00
|
|
|
case Intrinsic::cttz:
|
2011-12-12 04:26:04 +00:00
|
|
|
assert(CI->getNumArgOperands() == 1 &&
|
|
|
|
"Mismatch between function args and call args");
|
|
|
|
CI->replaceAllUsesWith(Builder.CreateCall2(NewFn, CI->getArgOperand(0),
|
|
|
|
Builder.getFalse(), Name));
|
|
|
|
CI->eraseFromParent();
|
|
|
|
return;
|
2012-06-10 18:42:51 +00:00
|
|
|
|
2013-10-07 18:06:48 +00:00
|
|
|
case Intrinsic::objectsize:
|
|
|
|
CI->replaceAllUsesWith(Builder.CreateCall2(NewFn,
|
|
|
|
CI->getArgOperand(0),
|
|
|
|
CI->getArgOperand(1),
|
|
|
|
Name));
|
|
|
|
CI->eraseFromParent();
|
|
|
|
return;
|
|
|
|
|
2012-07-18 00:02:16 +00:00
|
|
|
case Intrinsic::ctpop: {
|
|
|
|
CI->replaceAllUsesWith(Builder.CreateCall(NewFn, CI->getArgOperand(0)));
|
|
|
|
CI->eraseFromParent();
|
|
|
|
return;
|
|
|
|
}
|
2012-07-13 23:25:25 +00:00
|
|
|
|
2012-06-13 07:18:53 +00:00
|
|
|
case Intrinsic::x86_xop_vfrcz_ss:
|
|
|
|
case Intrinsic::x86_xop_vfrcz_sd:
|
|
|
|
CI->replaceAllUsesWith(Builder.CreateCall(NewFn, CI->getArgOperand(1),
|
|
|
|
Name));
|
|
|
|
CI->eraseFromParent();
|
|
|
|
return;
|
|
|
|
|
2012-06-10 18:42:51 +00:00
|
|
|
case Intrinsic::x86_sse41_ptestc:
|
|
|
|
case Intrinsic::x86_sse41_ptestz:
|
2012-06-13 07:18:53 +00:00
|
|
|
case Intrinsic::x86_sse41_ptestnzc: {
|
2012-06-10 18:42:51 +00:00
|
|
|
// The arguments for these intrinsics used to be v4f32, and changed
|
|
|
|
// to v2i64. This is purely a nop, since those are bitwise intrinsics.
|
|
|
|
// So, the only thing required is a bitcast for both arguments.
|
|
|
|
// First, check the arguments have the old type.
|
|
|
|
Value *Arg0 = CI->getArgOperand(0);
|
|
|
|
if (Arg0->getType() != VectorType::get(Type::getFloatTy(C), 4))
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Old intrinsic, add bitcasts
|
|
|
|
Value *Arg1 = CI->getArgOperand(1);
|
|
|
|
|
|
|
|
Value *BC0 =
|
|
|
|
Builder.CreateBitCast(Arg0,
|
|
|
|
VectorType::get(Type::getInt64Ty(C), 2),
|
|
|
|
"cast");
|
|
|
|
Value *BC1 =
|
|
|
|
Builder.CreateBitCast(Arg1,
|
|
|
|
VectorType::get(Type::getInt64Ty(C), 2),
|
|
|
|
"cast");
|
|
|
|
|
|
|
|
CallInst* NewCall = Builder.CreateCall2(NewFn, BC0, BC1, Name);
|
|
|
|
CI->replaceAllUsesWith(NewCall);
|
[x86] Fix a pretty horrible bug and inconsistency in the x86 asm
parsing (and latent bug in the instruction definitions).
This is effectively a revert of r136287 which tried to address
a specific and narrow case of immediate operands failing to be accepted
by x86 instructions with a pretty heavy hammer: it introduced a new kind
of operand that behaved differently. All of that is removed with this
commit, but the test cases are both preserved and enhanced.
The core problem that r136287 and this commit are trying to handle is
that gas accepts both of the following instructions:
insertps $192, %xmm0, %xmm1
insertps $-64, %xmm0, %xmm1
These will encode to the same byte sequence, with the immediate
occupying an 8-bit entry. The first form was fixed by r136287 but that
broke the prior handling of the second form! =[ Ironically, we would
still emit the second form in some cases and then be unable to
re-assemble the output.
The reason why the first instruction failed to be handled is because
prior to r136287 the operands ere marked 'i32i8imm' which forces them to
be sign-extenable. Clearly, that won't work for 192 in a single byte.
However, making thim zero-extended or "unsigned" doesn't really address
the core issue either because it breaks negative immediates. The correct
fix is to make these operands 'i8imm' reflecting that they can be either
signed or unsigned but must be 8-bit immediates. This patch backs out
r136287 and then changes those places as well as some others to use
'i8imm' rather than one of the extended variants.
Naturally, this broke something else. The custom DAG nodes had to be
updated to have a much more accurate type constraint of an i8 node, and
a bunch of Pat immediates needed to be specified as i8 values.
The fallout didn't end there though. We also then ceased to be able to
match the instruction-specific intrinsics to the instructions so
modified. Digging, this is because they too used i32 rather than i8 in
their signature. So I've also switched those intrinsics to i8 arguments
in line with the instructions.
In order to make the intrinsic adjustments of course, I also had to add
auto upgrading for the intrinsics.
I suspect that the intrinsic argument types may have led everything down
this rabbit hole. Pretty happy with the result.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@217310 91177308-0d34-0410-b5e6-96231b3b80d8
2014-09-06 10:00:01 +00:00
|
|
|
CI->eraseFromParent();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
case Intrinsic::x86_sse41_insertps:
|
|
|
|
case Intrinsic::x86_sse41_dppd:
|
|
|
|
case Intrinsic::x86_sse41_dpps:
|
|
|
|
case Intrinsic::x86_sse41_mpsadbw:
|
|
|
|
case Intrinsic::x86_avx_dp_ps_256:
|
|
|
|
case Intrinsic::x86_avx2_mpsadbw: {
|
|
|
|
// Need to truncate the last argument from i32 to i8 -- this argument models
|
|
|
|
// an inherently 8-bit immediate operand to these x86 instructions.
|
|
|
|
SmallVector<Value *, 4> Args(CI->arg_operands().begin(),
|
|
|
|
CI->arg_operands().end());
|
|
|
|
|
|
|
|
// Replace the last argument with a trunc.
|
|
|
|
Args.back() = Builder.CreateTrunc(Args.back(), Type::getInt8Ty(C), "trunc");
|
|
|
|
|
|
|
|
CallInst *NewCall = Builder.CreateCall(NewFn, Args);
|
|
|
|
CI->replaceAllUsesWith(NewCall);
|
2012-06-10 18:42:51 +00:00
|
|
|
CI->eraseFromParent();
|
|
|
|
return;
|
2007-12-17 22:33:23 +00:00
|
|
|
}
|
2015-01-19 06:07:27 +00:00
|
|
|
case Intrinsic::x86_avx512_mask_cmp_ps_512:
|
|
|
|
case Intrinsic::x86_avx512_mask_cmp_pd_512: {
|
|
|
|
// Need to truncate the last argument from i32 to i8 -- this argument models
|
|
|
|
// an inherently 8-bit immediate operand to these x86 instructions.
|
|
|
|
SmallVector<Value *, 5> Args(CI->arg_operands().begin(),
|
|
|
|
CI->arg_operands().end());
|
|
|
|
|
|
|
|
// Replace the last argument with a trunc.
|
|
|
|
Args[2] = Builder.CreateTrunc(Args[2], Type::getInt8Ty(C), "trunc");
|
|
|
|
|
|
|
|
CallInst *NewCall = Builder.CreateCall(NewFn, Args);
|
|
|
|
CI->replaceAllUsesWith(NewCall);
|
|
|
|
CI->eraseFromParent();
|
|
|
|
return;
|
|
|
|
}
|
2012-06-13 07:18:53 +00:00
|
|
|
}
|
2007-08-04 01:51:18 +00:00
|
|
|
}
|
|
|
|
|
2013-07-20 17:46:00 +00:00
|
|
|
// This tests each Function to determine if it needs upgrading. When we find
|
|
|
|
// one we are interested in, we then upgrade all calls to reflect the new
|
2007-08-04 01:51:18 +00:00
|
|
|
// function.
|
|
|
|
void llvm::UpgradeCallsToIntrinsic(Function* F) {
|
|
|
|
assert(F && "Illegal attempt to upgrade a non-existent intrinsic.");
|
|
|
|
|
|
|
|
// Upgrade the function and check if it is a totaly new function.
|
2011-06-18 06:05:24 +00:00
|
|
|
Function *NewFn;
|
2007-12-17 22:33:23 +00:00
|
|
|
if (UpgradeIntrinsicFunction(F, NewFn)) {
|
2007-08-04 01:51:18 +00:00
|
|
|
if (NewFn != F) {
|
|
|
|
// Replace all uses to the old function with the new one if necessary.
|
2014-03-09 03:16:01 +00:00
|
|
|
for (Value::user_iterator UI = F->user_begin(), UE = F->user_end();
|
2007-08-04 01:51:18 +00:00
|
|
|
UI != UE; ) {
|
2011-06-18 06:05:24 +00:00
|
|
|
if (CallInst *CI = dyn_cast<CallInst>(*UI++))
|
2007-08-04 01:51:18 +00:00
|
|
|
UpgradeIntrinsicCall(CI, NewFn);
|
|
|
|
}
|
|
|
|
// Remove old function, no longer used, from the module.
|
|
|
|
F->eraseFromParent();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-08-28 23:24:31 +00:00
|
|
|
|
2013-09-28 00:22:27 +00:00
|
|
|
void llvm::UpgradeInstWithTBAATag(Instruction *I) {
|
2014-11-11 21:30:22 +00:00
|
|
|
MDNode *MD = I->getMetadata(LLVMContext::MD_tbaa);
|
2013-09-28 00:22:27 +00:00
|
|
|
assert(MD && "UpgradeInstWithTBAATag should have a TBAA tag");
|
|
|
|
// Check if the tag uses struct-path aware TBAA format.
|
|
|
|
if (isa<MDNode>(MD->getOperand(0)) && MD->getNumOperands() >= 3)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (MD->getNumOperands() == 3) {
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
Metadata *Elts[] = {MD->getOperand(0), MD->getOperand(1)};
|
2013-09-28 00:22:27 +00:00
|
|
|
MDNode *ScalarType = MDNode::get(I->getContext(), Elts);
|
|
|
|
// Create a MDNode <ScalarType, ScalarType, offset 0, const>
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
Metadata *Elts2[] = {ScalarType, ScalarType,
|
|
|
|
ConstantAsMetadata::get(Constant::getNullValue(
|
|
|
|
Type::getInt64Ty(I->getContext()))),
|
|
|
|
MD->getOperand(2)};
|
2013-09-28 00:22:27 +00:00
|
|
|
I->setMetadata(LLVMContext::MD_tbaa, MDNode::get(I->getContext(), Elts2));
|
|
|
|
} else {
|
|
|
|
// Create a MDNode <MD, MD, offset 0>
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
Metadata *Elts[] = {MD, MD, ConstantAsMetadata::get(Constant::getNullValue(
|
|
|
|
Type::getInt64Ty(I->getContext())))};
|
2013-09-28 00:22:27 +00:00
|
|
|
I->setMetadata(LLVMContext::MD_tbaa, MDNode::get(I->getContext(), Elts));
|
|
|
|
}
|
|
|
|
}
|
2013-11-15 01:34:59 +00:00
|
|
|
|
|
|
|
Instruction *llvm::UpgradeBitCastInst(unsigned Opc, Value *V, Type *DestTy,
|
|
|
|
Instruction *&Temp) {
|
|
|
|
if (Opc != Instruction::BitCast)
|
2014-04-09 06:08:46 +00:00
|
|
|
return nullptr;
|
2013-11-15 01:34:59 +00:00
|
|
|
|
2014-04-09 06:08:46 +00:00
|
|
|
Temp = nullptr;
|
2013-11-15 01:34:59 +00:00
|
|
|
Type *SrcTy = V->getType();
|
|
|
|
if (SrcTy->isPtrOrPtrVectorTy() && DestTy->isPtrOrPtrVectorTy() &&
|
|
|
|
SrcTy->getPointerAddressSpace() != DestTy->getPointerAddressSpace()) {
|
|
|
|
LLVMContext &Context = V->getContext();
|
|
|
|
|
|
|
|
// We have no information about target data layout, so we assume that
|
|
|
|
// the maximum pointer size is 64bit.
|
|
|
|
Type *MidTy = Type::getInt64Ty(Context);
|
|
|
|
Temp = CastInst::Create(Instruction::PtrToInt, V, MidTy);
|
|
|
|
|
|
|
|
return CastInst::Create(Instruction::IntToPtr, Temp, DestTy);
|
|
|
|
}
|
|
|
|
|
2014-04-09 06:08:46 +00:00
|
|
|
return nullptr;
|
2013-11-15 01:34:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Value *llvm::UpgradeBitCastExpr(unsigned Opc, Constant *C, Type *DestTy) {
|
|
|
|
if (Opc != Instruction::BitCast)
|
2014-04-09 06:08:46 +00:00
|
|
|
return nullptr;
|
2013-11-15 01:34:59 +00:00
|
|
|
|
|
|
|
Type *SrcTy = C->getType();
|
|
|
|
if (SrcTy->isPtrOrPtrVectorTy() && DestTy->isPtrOrPtrVectorTy() &&
|
|
|
|
SrcTy->getPointerAddressSpace() != DestTy->getPointerAddressSpace()) {
|
|
|
|
LLVMContext &Context = C->getContext();
|
|
|
|
|
|
|
|
// We have no information about target data layout, so we assume that
|
|
|
|
// the maximum pointer size is 64bit.
|
|
|
|
Type *MidTy = Type::getInt64Ty(Context);
|
|
|
|
|
|
|
|
return ConstantExpr::getIntToPtr(ConstantExpr::getPtrToInt(C, MidTy),
|
|
|
|
DestTy);
|
|
|
|
}
|
|
|
|
|
2014-04-09 06:08:46 +00:00
|
|
|
return nullptr;
|
2013-11-15 01:34:59 +00:00
|
|
|
}
|
2013-12-02 21:29:56 +00:00
|
|
|
|
|
|
|
/// Check the debug info version number, if it is out-dated, drop the debug
|
|
|
|
/// info. Return true if module is modified.
|
|
|
|
bool llvm::UpgradeDebugInfo(Module &M) {
|
2014-01-16 01:51:12 +00:00
|
|
|
unsigned Version = getDebugMetadataVersionFromModule(M);
|
|
|
|
if (Version == DEBUG_METADATA_VERSION)
|
2013-12-02 21:29:56 +00:00
|
|
|
return false;
|
|
|
|
|
2014-01-16 01:51:12 +00:00
|
|
|
bool RetCode = StripDebugInfo(M);
|
|
|
|
if (RetCode) {
|
|
|
|
DiagnosticInfoDebugMetadataVersion DiagVersion(M, Version);
|
|
|
|
M.getContext().diagnose(DiagVersion);
|
|
|
|
}
|
|
|
|
return RetCode;
|
2013-12-02 21:29:56 +00:00
|
|
|
}
|
2014-06-25 15:41:00 +00:00
|
|
|
|
|
|
|
void llvm::UpgradeMDStringConstant(std::string &String) {
|
|
|
|
const std::string OldPrefix = "llvm.vectorizer.";
|
2014-07-21 23:11:03 +00:00
|
|
|
if (String == "llvm.vectorizer.unroll") {
|
|
|
|
String = "llvm.loop.interleave.count";
|
|
|
|
} else if (String.find(OldPrefix) == 0) {
|
|
|
|
String.replace(0, OldPrefix.size(), "llvm.loop.vectorize.");
|
2014-06-25 15:41:00 +00:00
|
|
|
}
|
|
|
|
}
|