StructType *createIdentifiedStructType(LLVMContext &Context, StringRef Name);
StructType *createIdentifiedStructType(LLVMContext &Context);
- /// Map all pointer types within \param Ty to the opaque pointer
- /// type in the same address space if opaque pointers are being
- /// used, otherwise nop. This converts a bitcode-reader internal
- /// type into one suitable for use in a Value.
- Type *flattenPointerTypes(Type *Ty) {
- return Ty;
- }
-
- /// Given a fully structured pointer type (i.e. not opaque), return
- /// the flattened form of its element, suitable for use in a Value.
- Type *getPointerElementFlatType(Type *Ty) {
- return flattenPointerTypes(cast<PointerType>(Ty)->getElementType());
- }
-
- /// Given a fully structured pointer type, get its element type in
- /// both fully structured form, and flattened form suitable for use
- /// in a Value.
- std::pair<Type *, Type *> getPointerElementTypes(Type *FullTy) {
- Type *ElTy = cast<PointerType>(FullTy)->getElementType();
- return std::make_pair(ElTy, flattenPointerTypes(ElTy));
- }
+ Type *getTypeByID(unsigned ID);
- /// Return the flattened type (suitable for use in a Value)
- /// specified by the given \param ID .
- Type *getTypeByID(unsigned ID) {
- return flattenPointerTypes(getFullyStructuredTypeByID(ID));
- }
-
- /// Return the fully structured (bitcode-reader internal) type
- /// corresponding to the given \param ID .
- Type *getFullyStructuredTypeByID(unsigned ID);
-
- Value *getFnValueByID(unsigned ID, Type *Ty, Type **FullTy = nullptr) {
+ Value *getFnValueByID(unsigned ID, Type *Ty) {
if (Ty && Ty->isMetadataTy())
return MetadataAsValue::get(Ty->getContext(), getFnMetadataByID(ID));
- return ValueList.getValueFwdRef(ID, Ty, FullTy);
+ return ValueList.getValueFwdRef(ID, Ty);
}
Metadata *getFnMetadataByID(unsigned ID) {
/// Increment Slot past the number of slots used in the record. Return true on
/// failure.
bool getValueTypePair(const SmallVectorImpl<uint64_t> &Record, unsigned &Slot,
- unsigned InstNum, Value *&ResVal,
- Type **FullTy = nullptr) {
+ unsigned InstNum, Value *&ResVal) {
if (Slot == Record.size()) return true;
unsigned ValNo = (unsigned)Record[Slot++];
// Adjust the ValNo, if it was encoded relative to the InstNum.
if (ValNo < InstNum) {
// If this is not a forward reference, just return the value we already
// have.
- ResVal = getFnValueByID(ValNo, nullptr, FullTy);
+ ResVal = getFnValueByID(ValNo, nullptr);
return ResVal == nullptr;
}
if (Slot == Record.size())
unsigned TypeNo = (unsigned)Record[Slot++];
ResVal = getFnValueByID(ValNo, getTypeByID(TypeNo));
- if (FullTy)
- *FullTy = getFullyStructuredTypeByID(TypeNo);
return ResVal == nullptr;
}
/// Upgrades old-style typeless byval or sret attributes by adding the
/// corresponding argument's pointee type.
- void propagateByValSRetTypes(CallBase *CB, ArrayRef<Type *> ArgsFullTys);
+ void propagateByValSRetTypes(CallBase *CB, ArrayRef<Type *> ArgsTys);
/// Converts alignment exponent (i.e. power of two (or zero)) to the
/// corresponding alignment to use. If alignment is too large, returns
}
}
-Type *BitcodeReader::getFullyStructuredTypeByID(unsigned ID) {
+Type *BitcodeReader::getTypeByID(unsigned ID) {
// The type table size is always specified correctly.
if (ID >= TypeList.size())
return nullptr;
// Read all the records for this value table.
Type *CurTy = Type::getInt32Ty(Context);
- Type *CurFullTy = Type::getInt32Ty(Context);
unsigned NextCstNo = ValueList.size();
struct DelayedShufTy {
VectorType *OpTy;
VectorType *RTy;
- Type *CurFullTy;
uint64_t Op0Idx;
uint64_t Op1Idx;
uint64_t Op2Idx;
SmallVector<int, 16> Mask;
ShuffleVectorInst::getShuffleMask(Op2, Mask);
Value *V = ConstantExpr::getShuffleVector(Op0, Op1, Mask);
- ValueList.assignValue(V, CstNo, DelayedShuffle.CurFullTy);
+ ValueList.assignValue(V, CstNo);
}
if (NextCstNo != ValueList.size())
return error("Invalid record");
if (TypeList[Record[0]] == VoidType)
return error("Invalid constant type");
- CurFullTy = TypeList[Record[0]];
- CurTy = flattenPointerTypes(CurFullTy);
+ CurTy = TypeList[Record[0]];
continue; // Skip the ValueList manipulation.
case bitc::CST_CODE_NULL: // NULL
if (CurTy->isVoidTy() || CurTy->isFunctionTy() || CurTy->isLabelTy())
Type *Elt0FullTy = nullptr;
while (OpNum != Record.size()) {
if (!Elt0FullTy)
- Elt0FullTy = getFullyStructuredTypeByID(Record[OpNum]);
+ Elt0FullTy = getTypeByID(Record[OpNum]);
Type *ElTy = getTypeByID(Record[OpNum++]);
if (!ElTy)
return error("Invalid record");
return error("Invalid gep with no operands");
Type *ImplicitPointeeType =
- getPointerElementFlatType(Elt0FullTy->getScalarType());
+ cast<PointerType>(Elt0FullTy->getScalarType())->getElementType();
if (!PointeeType)
PointeeType = ImplicitPointeeType;
else if (PointeeType != ImplicitPointeeType)
if (Record.size() < 3 || !OpTy)
return error("Invalid record");
DelayedShuffles.push_back(
- {OpTy, OpTy, CurFullTy, Record[0], Record[1], Record[2], NextCstNo});
+ {OpTy, OpTy, Record[0], Record[1], Record[2], NextCstNo});
++NextCstNo;
continue;
}
if (Record.size() < 4 || !RTy || !OpTy)
return error("Invalid record");
DelayedShuffles.push_back(
- {OpTy, RTy, CurFullTy, Record[1], Record[2], Record[3], NextCstNo});
+ {OpTy, RTy, Record[1], Record[2], Record[3], NextCstNo});
++NextCstNo;
continue;
}
ConstrStr += (char)Record[3+AsmStrSize+i];
UpgradeInlineAsmString(&AsmStr);
V = InlineAsm::get(
- cast<FunctionType>(getPointerElementFlatType(CurFullTy)), AsmStr,
- ConstrStr, HasSideEffects, IsAlignStack);
+ cast<FunctionType>(cast<PointerType>(CurTy)->getElementType()),
+ AsmStr, ConstrStr, HasSideEffects, IsAlignStack);
break;
}
// This version adds support for the asm dialect keywords (e.g.,
ConstrStr += (char)Record[3+AsmStrSize+i];
UpgradeInlineAsmString(&AsmStr);
V = InlineAsm::get(
- cast<FunctionType>(getPointerElementFlatType(CurFullTy)), AsmStr,
- ConstrStr, HasSideEffects, IsAlignStack,
+ cast<FunctionType>(cast<PointerType>(CurTy)->getElementType()),
+ AsmStr, ConstrStr, HasSideEffects, IsAlignStack,
InlineAsm::AsmDialect(AsmDialect));
break;
}
ConstrStr += (char)Record[3 + AsmStrSize + i];
UpgradeInlineAsmString(&AsmStr);
V = InlineAsm::get(
- cast<FunctionType>(getPointerElementFlatType(CurFullTy)), AsmStr,
- ConstrStr, HasSideEffects, IsAlignStack,
+ cast<FunctionType>(cast<PointerType>(CurTy)->getElementType()),
+ AsmStr, ConstrStr, HasSideEffects, IsAlignStack,
InlineAsm::AsmDialect(AsmDialect), CanThrow);
break;
}
}
}
- assert(V->getType() == flattenPointerTypes(CurFullTy) &&
- "Incorrect fully structured type provided for Constant");
- ValueList.assignValue(V, NextCstNo, CurFullTy);
+ ValueList.assignValue(V, NextCstNo);
++NextCstNo;
}
}
if (Record.size() < 6)
return error("Invalid record");
- Type *FullTy = getFullyStructuredTypeByID(Record[0]);
- Type *Ty = flattenPointerTypes(FullTy);
+ Type *Ty = getTypeByID(Record[0]);
if (!Ty)
return error("Invalid record");
bool isConstant = Record[1] & 1;
if (!Ty->isPointerTy())
return error("Invalid type for value");
AddressSpace = cast<PointerType>(Ty)->getAddressSpace();
- std::tie(FullTy, Ty) = getPointerElementTypes(FullTy);
+ Ty = cast<PointerType>(Ty)->getElementType();
}
uint64_t RawLinkage = Record[3];
else
upgradeDLLImportExportLinkage(NewGV, RawLinkage);
- FullTy = PointerType::get(FullTy, AddressSpace);
- assert(NewGV->getType() == flattenPointerTypes(FullTy) &&
- "Incorrect fully specified type for GlobalVariable");
- ValueList.push_back(NewGV, FullTy);
+ ValueList.push_back(NewGV);
// Remember which value to use for the global initializer.
if (unsigned InitID = Record[2])
if (Record.size() < 8)
return error("Invalid record");
- Type *FullFTy = getFullyStructuredTypeByID(Record[0]);
- Type *FTy = flattenPointerTypes(FullFTy);
+ Type *FTy = getTypeByID(Record[0]);
if (!FTy)
return error("Invalid record");
- if (isa<PointerType>(FTy))
- std::tie(FullFTy, FTy) = getPointerElementTypes(FullFTy);
+ if (auto *PTy = dyn_cast<PointerType>(FTy))
+ FTy = PTy->getElementType();
if (!isa<FunctionType>(FTy))
return error("Invalid type for value");
Function::Create(cast<FunctionType>(FTy), GlobalValue::ExternalLinkage,
AddrSpace, Name, TheModule);
- assert(Func->getFunctionType() == flattenPointerTypes(FullFTy) &&
+ assert(Func->getFunctionType() == FTy &&
"Incorrect fully specified type provided for function");
- FunctionTypes[Func] = cast<FunctionType>(FullFTy);
+ FunctionTypes[Func] = cast<FunctionType>(FTy);
Func->setCallingConv(CC);
bool isProto = Record[2];
Func->removeParamAttr(i, Kind);
- Type *PTy = cast<FunctionType>(FullFTy)->getParamType(i);
- Type *PtrEltTy = getPointerElementFlatType(PTy);
+ Type *PTy = cast<FunctionType>(FTy)->getParamType(i);
+ Type *PtrEltTy = cast<PointerType>(PTy)->getElementType();
Attribute NewAttr;
switch (Kind) {
case Attribute::ByVal:
if (Record.size() > 18)
Func->setPartition(StringRef(Strtab.data() + Record[17], Record[18]));
- Type *FullTy = PointerType::get(FullFTy, AddrSpace);
- assert(Func->getType() == flattenPointerTypes(FullTy) &&
- "Incorrect fully specified type provided for Function");
- ValueList.push_back(Func, FullTy);
+ ValueList.push_back(Func);
// If this is a function with a body, remember the prototype we are
// creating now, so that we can match up the body with them later.
if (Record.size() < (3 + (unsigned)NewRecord))
return error("Invalid record");
unsigned OpNum = 0;
- Type *FullTy = getFullyStructuredTypeByID(Record[OpNum++]);
- Type *Ty = flattenPointerTypes(FullTy);
+ Type *Ty = getTypeByID(Record[OpNum++]);
if (!Ty)
return error("Invalid record");
auto *PTy = dyn_cast<PointerType>(Ty);
if (!PTy)
return error("Invalid type for value");
- std::tie(FullTy, Ty) = getPointerElementTypes(FullTy);
+ Ty = PTy->getElementType();
AddrSpace = PTy->getAddressSpace();
} else {
AddrSpace = Record[OpNum++];
NewGA = GlobalIFunc::create(Ty, AddrSpace, getDecodedLinkage(Linkage), Name,
nullptr, TheModule);
- assert(NewGA->getValueType() == flattenPointerTypes(FullTy) &&
- "Incorrect fully structured type provided for GlobalIndirectSymbol");
// Local linkage must have default visibility.
// auto-upgrade `hidden` and `protected` for old bitcode.
if (OpNum != Record.size()) {
OpNum += 2;
}
- FullTy = PointerType::get(FullTy, AddrSpace);
- assert(NewGA->getType() == flattenPointerTypes(FullTy) &&
- "Incorrect fully structured type provided for GlobalIndirectSymbol");
- ValueList.push_back(NewGA, FullTy);
+ ValueList.push_back(NewGA);
IndirectSymbolInits.push_back(std::make_pair(NewGA, Val));
return Error::success();
}
}
void BitcodeReader::propagateByValSRetTypes(CallBase *CB,
- ArrayRef<Type *> ArgsFullTys) {
+ ArrayRef<Type *> ArgsTys) {
for (unsigned i = 0; i != CB->arg_size(); ++i) {
for (Attribute::AttrKind Kind : {Attribute::ByVal, Attribute::StructRet,
Attribute::InAlloca}) {
CB->removeParamAttr(i, Kind);
- Type *PtrEltTy = getPointerElementFlatType(ArgsFullTys[i]);
+ Type *PtrEltTy = cast<PointerType>(ArgsTys[i])->getElementType();
Attribute NewAttr;
switch (Kind) {
case Attribute::ByVal:
// Add all the function arguments to the value table.
unsigned ArgNo = 0;
- FunctionType *FullFTy = FunctionTypes[F];
+ FunctionType *FTy = FunctionTypes[F];
for (Argument &I : F->args()) {
- assert(I.getType() == flattenPointerTypes(FullFTy->getParamType(ArgNo)) &&
+ assert(I.getType() == FTy->getParamType(ArgNo++) &&
"Incorrect fully specified type for Function Argument");
- ValueList.push_back(&I, FullFTy->getParamType(ArgNo++));
+ ValueList.push_back(&I);
}
unsigned NextValueNo = ValueList.size();
BasicBlock *CurBB = nullptr;
// Read a record.
Record.clear();
Instruction *I = nullptr;
- Type *FullTy = nullptr;
Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID, Record);
if (!MaybeBitCode)
return MaybeBitCode.takeError();
OpNum+2 != Record.size())
return error("Invalid record");
- FullTy = getFullyStructuredTypeByID(Record[OpNum]);
- Type *ResTy = flattenPointerTypes(FullTy);
+ Type *ResTy = getTypeByID(Record[OpNum]);
int Opc = getDecodedCastOpcode(Record[OpNum + 1]);
if (Opc == -1 || !ResTy)
return error("Invalid record");
if (BitCode == bitc::FUNC_CODE_INST_GEP) {
InBounds = Record[OpNum++];
- FullTy = getFullyStructuredTypeByID(Record[OpNum++]);
- Ty = flattenPointerTypes(FullTy);
+ Ty = getTypeByID(Record[OpNum++]);
} else {
InBounds = BitCode == bitc::FUNC_CODE_INST_INBOUNDS_GEP_OLD;
Ty = nullptr;
}
Value *BasePtr;
- Type *FullBaseTy = nullptr;
- if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr, &FullBaseTy))
+ if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr))
return error("Invalid record");
if (!Ty) {
- std::tie(FullTy, Ty) =
- getPointerElementTypes(FullBaseTy->getScalarType());
- } else if (!cast<PointerType>(FullBaseTy->getScalarType())
- ->isOpaqueOrPointeeTypeMatches(Ty))
+ Ty = cast<PointerType>(BasePtr->getType()->getScalarType())
+ ->getElementType();
+ } else if (!cast<PointerType>(BasePtr->getType()->getScalarType())
+ ->isOpaqueOrPointeeTypeMatches(Ty)) {
return error(
"Explicit gep type does not match pointee type of pointer operand");
+ }
SmallVector<Value*, 16> GEPIdx;
while (OpNum != Record.size()) {
}
I = GetElementPtrInst::Create(Ty, BasePtr, GEPIdx);
- FullTy = GetElementPtrInst::getGEPReturnType(FullTy, I, GEPIdx);
InstructionList.push_back(I);
if (InBounds)
// EXTRACTVAL: [opty, opval, n x indices]
unsigned OpNum = 0;
Value *Agg;
- if (getValueTypePair(Record, OpNum, NextValueNo, Agg, &FullTy))
+ if (getValueTypePair(Record, OpNum, NextValueNo, Agg))
return error("Invalid record");
+ Type *Ty = Agg->getType();
unsigned RecSize = Record.size();
if (OpNum == RecSize)
SmallVector<unsigned, 4> EXTRACTVALIdx;
for (; OpNum != RecSize; ++OpNum) {
- bool IsArray = FullTy->isArrayTy();
- bool IsStruct = FullTy->isStructTy();
+ bool IsArray = Ty->isArrayTy();
+ bool IsStruct = Ty->isStructTy();
uint64_t Index = Record[OpNum];
if (!IsStruct && !IsArray)
return error("EXTRACTVAL: Invalid type");
if ((unsigned)Index != Index)
return error("Invalid value");
- if (IsStruct && Index >= FullTy->getStructNumElements())
+ if (IsStruct && Index >= Ty->getStructNumElements())
return error("EXTRACTVAL: Invalid struct index");
- if (IsArray && Index >= FullTy->getArrayNumElements())
+ if (IsArray && Index >= Ty->getArrayNumElements())
return error("EXTRACTVAL: Invalid array index");
EXTRACTVALIdx.push_back((unsigned)Index);
if (IsStruct)
- FullTy = FullTy->getStructElementType(Index);
+ Ty = Ty->getStructElementType(Index);
else
- FullTy = FullTy->getArrayElementType();
+ Ty = Ty->getArrayElementType();
}
I = ExtractValueInst::Create(Agg, EXTRACTVALIdx);
// INSERTVAL: [opty, opval, opty, opval, n x indices]
unsigned OpNum = 0;
Value *Agg;
- if (getValueTypePair(Record, OpNum, NextValueNo, Agg, &FullTy))
+ if (getValueTypePair(Record, OpNum, NextValueNo, Agg))
return error("Invalid record");
Value *Val;
if (getValueTypePair(Record, OpNum, NextValueNo, Val))
// handles select i1 ... in old bitcode
unsigned OpNum = 0;
Value *TrueVal, *FalseVal, *Cond;
- if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal, &FullTy) ||
+ if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) ||
popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) ||
popValue(Record, OpNum, NextValueNo, Type::getInt1Ty(Context), Cond))
return error("Invalid record");
// handles select i1 or select [N x i1]
unsigned OpNum = 0;
Value *TrueVal, *FalseVal, *Cond;
- if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal, &FullTy) ||
+ if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) ||
popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) ||
getValueTypePair(Record, OpNum, NextValueNo, Cond))
return error("Invalid record");
case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval]
unsigned OpNum = 0;
Value *Vec, *Idx;
- if (getValueTypePair(Record, OpNum, NextValueNo, Vec, &FullTy) ||
+ if (getValueTypePair(Record, OpNum, NextValueNo, Vec) ||
getValueTypePair(Record, OpNum, NextValueNo, Idx))
return error("Invalid record");
if (!Vec->getType()->isVectorTy())
return error("Invalid type for value");
I = ExtractElementInst::Create(Vec, Idx);
- FullTy = cast<VectorType>(FullTy)->getElementType();
InstructionList.push_back(I);
break;
}
case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval]
unsigned OpNum = 0;
Value *Vec, *Elt, *Idx;
- if (getValueTypePair(Record, OpNum, NextValueNo, Vec, &FullTy))
+ if (getValueTypePair(Record, OpNum, NextValueNo, Vec))
return error("Invalid record");
if (!Vec->getType()->isVectorTy())
return error("Invalid type for value");
case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval]
unsigned OpNum = 0;
Value *Vec1, *Vec2, *Mask;
- if (getValueTypePair(Record, OpNum, NextValueNo, Vec1, &FullTy) ||
+ if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) ||
popValue(Record, OpNum, NextValueNo, Vec1->getType(), Vec2))
return error("Invalid record");
return error("Invalid type for value");
I = new ShuffleVectorInst(Vec1, Vec2, Mask);
- FullTy =
- VectorType::get(cast<VectorType>(FullTy)->getElementType(),
- cast<VectorType>(Mask->getType())->getElementCount());
InstructionList.push_back(I);
break;
}
BasicBlock *UnwindBB = getBasicBlock(Record[OpNum++]);
FunctionType *FTy = nullptr;
- FunctionType *FullFTy = nullptr;
if ((CCInfo >> 13) & 1) {
- FullFTy =
- dyn_cast<FunctionType>(getFullyStructuredTypeByID(Record[OpNum++]));
- if (!FullFTy)
+ FTy = dyn_cast<FunctionType>(getTypeByID(Record[OpNum++]));
+ if (!FTy)
return error("Explicit invoke type is not a function type");
- FTy = cast<FunctionType>(flattenPointerTypes(FullFTy));
}
Value *Callee;
- if (getValueTypePair(Record, OpNum, NextValueNo, Callee, &FullTy))
+ if (getValueTypePair(Record, OpNum, NextValueNo, Callee))
return error("Invalid record");
PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType());
if (!CalleeTy)
return error("Callee is not a pointer");
if (!FTy) {
- FullFTy =
- dyn_cast<FunctionType>(cast<PointerType>(FullTy)->getElementType());
- if (!FullFTy)
+ FTy = dyn_cast<FunctionType>(
+ cast<PointerType>(Callee->getType())->getElementType());
+ if (!FTy)
return error("Callee is not of pointer to function type");
- FTy = cast<FunctionType>(flattenPointerTypes(FullFTy));
- } else if (getPointerElementFlatType(FullTy) != FTy)
+ } else if (cast<PointerType>(Callee->getType())->getElementType() != FTy)
return error("Explicit invoke type does not match pointee type of "
"callee operand");
if (Record.size() < FTy->getNumParams() + OpNum)
return error("Insufficient operands to call");
SmallVector<Value*, 16> Ops;
- SmallVector<Type *, 16> ArgsFullTys;
+ SmallVector<Type *, 16> ArgsTys;
for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
Ops.push_back(getValue(Record, OpNum, NextValueNo,
FTy->getParamType(i)));
- ArgsFullTys.push_back(FullFTy->getParamType(i));
+ ArgsTys.push_back(FTy->getParamType(i));
if (!Ops.back())
return error("Invalid record");
}
// Read type/value pairs for varargs params.
while (OpNum != Record.size()) {
Value *Op;
- Type *FullTy;
- if (getValueTypePair(Record, OpNum, NextValueNo, Op, &FullTy))
+ if (getValueTypePair(Record, OpNum, NextValueNo, Op))
return error("Invalid record");
Ops.push_back(Op);
- ArgsFullTys.push_back(FullTy);
+ ArgsTys.push_back(Op->getType());
}
}
I = InvokeInst::Create(FTy, Callee, NormalBB, UnwindBB, Ops,
OperandBundles);
- FullTy = FullFTy->getReturnType();
OperandBundles.clear();
InstructionList.push_back(I);
cast<InvokeInst>(I)->setCallingConv(
static_cast<CallingConv::ID>(CallingConv::MaxID & CCInfo));
cast<InvokeInst>(I)->setAttributes(PAL);
- propagateByValSRetTypes(cast<CallBase>(I), ArgsFullTys);
+ propagateByValSRetTypes(cast<CallBase>(I), ArgsTys);
break;
}
IndirectDests.push_back(getBasicBlock(Record[OpNum++]));
FunctionType *FTy = nullptr;
- FunctionType *FullFTy = nullptr;
if ((CCInfo >> bitc::CALL_EXPLICIT_TYPE) & 1) {
- FullFTy =
- dyn_cast<FunctionType>(getFullyStructuredTypeByID(Record[OpNum++]));
- if (!FullFTy)
+ FTy = dyn_cast<FunctionType>(getTypeByID(Record[OpNum++]));
+ if (!FTy)
return error("Explicit call type is not a function type");
- FTy = cast<FunctionType>(flattenPointerTypes(FullFTy));
}
Value *Callee;
- if (getValueTypePair(Record, OpNum, NextValueNo, Callee, &FullTy))
+ if (getValueTypePair(Record, OpNum, NextValueNo, Callee))
return error("Invalid record");
PointerType *OpTy = dyn_cast<PointerType>(Callee->getType());
if (!OpTy)
return error("Callee is not a pointer type");
if (!FTy) {
- FullFTy =
- dyn_cast<FunctionType>(cast<PointerType>(FullTy)->getElementType());
- if (!FullFTy)
+ FTy = dyn_cast<FunctionType>(
+ cast<PointerType>(Callee->getType())->getElementType());
+ if (!FTy)
return error("Callee is not of pointer to function type");
- FTy = cast<FunctionType>(flattenPointerTypes(FullFTy));
- } else if (getPointerElementFlatType(FullTy) != FTy)
+ } else if (cast<PointerType>(Callee->getType())->getElementType() != FTy)
return error("Explicit call type does not match pointee type of "
"callee operand");
if (Record.size() < FTy->getNumParams() + OpNum)
I = CallBrInst::Create(FTy, Callee, DefaultDest, IndirectDests, Args,
OperandBundles);
- FullTy = FullFTy->getReturnType();
OperandBundles.clear();
InstructionList.push_back(I);
cast<CallBrInst>(I)->setCallingConv(
if (Record.empty())
return error("Invalid record");
// The first record specifies the type.
- FullTy = getFullyStructuredTypeByID(Record[0]);
- Type *Ty = flattenPointerTypes(FullTy);
+ Type *Ty = getTypeByID(Record[0]);
if (!Ty)
return error("Invalid record");
if (Record.size() < 4)
return error("Invalid record");
}
- FullTy = getFullyStructuredTypeByID(Record[Idx++]);
- Type *Ty = flattenPointerTypes(FullTy);
+ Type *Ty = getTypeByID(Record[Idx++]);
if (!Ty)
return error("Invalid record");
if (BitCode == bitc::FUNC_CODE_INST_LANDINGPAD_OLD) {
const uint64_t Rec = Record[3];
const bool InAlloca = Bitfield::get<APV::UsedWithInAlloca>(Rec);
const bool SwiftError = Bitfield::get<APV::SwiftError>(Rec);
- FullTy = getFullyStructuredTypeByID(Record[0]);
- Type *Ty = flattenPointerTypes(FullTy);
+ Type *Ty = getTypeByID(Record[0]);
if (!Bitfield::get<APV::ExplicitType>(Rec)) {
auto *PTy = dyn_cast_or_null<PointerType>(Ty);
if (!PTy)
return error("Old-style alloca with a non-pointer type");
- std::tie(FullTy, Ty) = getPointerElementTypes(FullTy);
+ Ty = PTy->getElementType();
}
Type *OpTy = getTypeByID(Record[1]);
Value *Size = getFnValueByID(Record[2], OpTy);
AI->setUsedWithInAlloca(InAlloca);
AI->setSwiftError(SwiftError);
I = AI;
- FullTy = PointerType::get(FullTy, AS);
InstructionList.push_back(I);
break;
}
case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol]
unsigned OpNum = 0;
Value *Op;
- if (getValueTypePair(Record, OpNum, NextValueNo, Op, &FullTy) ||
+ if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
(OpNum + 2 != Record.size() && OpNum + 3 != Record.size()))
return error("Invalid record");
Type *Ty = nullptr;
if (OpNum + 3 == Record.size()) {
- FullTy = getFullyStructuredTypeByID(Record[OpNum++]);
- Ty = flattenPointerTypes(FullTy);
- } else
- std::tie(FullTy, Ty) = getPointerElementTypes(FullTy);
+ Ty = getTypeByID(Record[OpNum++]);
+ } else {
+ Ty = cast<PointerType>(Op->getType())->getElementType();
+ }
if (Error Err = typeCheckLoadStoreInst(Ty, Op->getType()))
return Err;
// LOADATOMIC: [opty, op, align, vol, ordering, ssid]
unsigned OpNum = 0;
Value *Op;
- if (getValueTypePair(Record, OpNum, NextValueNo, Op, &FullTy) ||
+ if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
(OpNum + 4 != Record.size() && OpNum + 5 != Record.size()))
return error("Invalid record");
Type *Ty = nullptr;
if (OpNum + 5 == Record.size()) {
- FullTy = getFullyStructuredTypeByID(Record[OpNum++]);
- Ty = flattenPointerTypes(FullTy);
- } else
- std::tie(FullTy, Ty) = getPointerElementTypes(FullTy);
+ Ty = getTypeByID(Record[OpNum++]);
+ } else {
+ Ty = cast<PointerType>(Op->getType())->getElementType();
+ }
if (Error Err = typeCheckLoadStoreInst(Ty, Op->getType()))
return Err;
case bitc::FUNC_CODE_INST_STORE_OLD: { // STORE2:[ptrty, ptr, val, align, vol]
unsigned OpNum = 0;
Value *Val, *Ptr;
- Type *FullTy;
- if (getValueTypePair(Record, OpNum, NextValueNo, Ptr, &FullTy) ||
+ if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) ||
(BitCode == bitc::FUNC_CODE_INST_STORE
? getValueTypePair(Record, OpNum, NextValueNo, Val)
: popValue(Record, OpNum, NextValueNo,
- getPointerElementFlatType(FullTy), Val)) ||
+ cast<PointerType>(Ptr->getType())->getElementType(),
+ Val)) ||
OpNum + 2 != Record.size())
return error("Invalid record");
// STOREATOMIC: [ptrty, ptr, val, align, vol, ordering, ssid]
unsigned OpNum = 0;
Value *Val, *Ptr;
- Type *FullTy;
- if (getValueTypePair(Record, OpNum, NextValueNo, Ptr, &FullTy) ||
+ if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) ||
!isa<PointerType>(Ptr->getType()) ||
(BitCode == bitc::FUNC_CODE_INST_STOREATOMIC
? getValueTypePair(Record, OpNum, NextValueNo, Val)
: popValue(Record, OpNum, NextValueNo,
- getPointerElementFlatType(FullTy), Val)) ||
+ cast<PointerType>(Ptr->getType())->getElementType(),
+ Val)) ||
OpNum + 4 != Record.size())
return error("Invalid record");
const size_t NumRecords = Record.size();
unsigned OpNum = 0;
Value *Ptr = nullptr;
- if (getValueTypePair(Record, OpNum, NextValueNo, Ptr, &FullTy))
+ if (getValueTypePair(Record, OpNum, NextValueNo, Ptr))
return error("Invalid record");
if (!isa<PointerType>(Ptr->getType()))
Value *Cmp = nullptr;
if (popValue(Record, OpNum, NextValueNo,
- getPointerElementFlatType(FullTy), Cmp))
+ cast<PointerType>(Ptr->getType())->getPointerElementType(),
+ Cmp))
return error("Invalid record");
- FullTy = cast<PointerType>(FullTy)->getElementType();
-
Value *New = nullptr;
if (popValue(Record, OpNum, NextValueNo, Cmp->getType(), New) ||
NumRecords < OpNum + 3 || NumRecords > OpNum + 5)
I = new AtomicCmpXchgInst(Ptr, Cmp, New, Alignment, SuccessOrdering,
FailureOrdering, SSID);
cast<AtomicCmpXchgInst>(I)->setVolatile(Record[OpNum]);
- FullTy = StructType::get(Context, {FullTy, Type::getInt1Ty(Context)});
if (NumRecords < 8) {
// Before weak cmpxchgs existed, the instruction simply returned the
// expecting the first component of a modern cmpxchg.
CurBB->getInstList().push_back(I);
I = ExtractValueInst::Create(I, 0);
- FullTy = cast<StructType>(FullTy)->getElementType(0);
} else {
cast<AtomicCmpXchgInst>(I)->setWeak(Record[OpNum + 4]);
}
const size_t NumRecords = Record.size();
unsigned OpNum = 0;
Value *Ptr = nullptr;
- if (getValueTypePair(Record, OpNum, NextValueNo, Ptr, &FullTy))
+ if (getValueTypePair(Record, OpNum, NextValueNo, Ptr))
return error("Invalid record");
if (!isa<PointerType>(Ptr->getType()))
return error("Cmpxchg operand is not a pointer type");
Value *Cmp = nullptr;
- if (getValueTypePair(Record, OpNum, NextValueNo, Cmp, &FullTy))
+ if (getValueTypePair(Record, OpNum, NextValueNo, Cmp))
return error("Invalid record");
Value *Val = nullptr;
I = new AtomicCmpXchgInst(Ptr, Cmp, Val, *Alignment, SuccessOrdering,
FailureOrdering, SSID);
- FullTy = StructType::get(Context, {FullTy, Type::getInt1Ty(Context)});
cast<AtomicCmpXchgInst>(I)->setVolatile(IsVol);
cast<AtomicCmpXchgInst>(I)->setWeak(IsWeak);
unsigned OpNum = 0;
Value *Ptr = nullptr;
- if (getValueTypePair(Record, OpNum, NextValueNo, Ptr, &FullTy))
+ if (getValueTypePair(Record, OpNum, NextValueNo, Ptr))
return error("Invalid record");
if (!isa<PointerType>(Ptr->getType()))
Value *Val = nullptr;
if (BitCode == bitc::FUNC_CODE_INST_ATOMICRMW_OLD) {
if (popValue(Record, OpNum, NextValueNo,
- getPointerElementFlatType(FullTy), Val))
+ cast<PointerType>(Ptr->getType())->getPointerElementType(),
+ Val))
return error("Invalid record");
- FullTy = getPointerElementFlatType(FullTy);
} else {
if (getValueTypePair(Record, OpNum, NextValueNo, Val))
return error("Invalid record");
- FullTy = Val->getType();
}
if (!(NumRecords == (OpNum + 4) || NumRecords == (OpNum + 5)))
}
FunctionType *FTy = nullptr;
- FunctionType *FullFTy = nullptr;
if ((CCInfo >> bitc::CALL_EXPLICIT_TYPE) & 1) {
- FullFTy =
- dyn_cast<FunctionType>(getFullyStructuredTypeByID(Record[OpNum++]));
- if (!FullFTy)
+ FTy = dyn_cast<FunctionType>(getTypeByID(Record[OpNum++]));
+ if (!FTy)
return error("Explicit call type is not a function type");
- FTy = cast<FunctionType>(flattenPointerTypes(FullFTy));
}
Value *Callee;
- if (getValueTypePair(Record, OpNum, NextValueNo, Callee, &FullTy))
+ if (getValueTypePair(Record, OpNum, NextValueNo, Callee))
return error("Invalid record");
PointerType *OpTy = dyn_cast<PointerType>(Callee->getType());
if (!OpTy)
return error("Callee is not a pointer type");
if (!FTy) {
- FullFTy =
- dyn_cast<FunctionType>(cast<PointerType>(FullTy)->getElementType());
- if (!FullFTy)
+ FTy = dyn_cast<FunctionType>(
+ cast<PointerType>(Callee->getType())->getElementType());
+ if (!FTy)
return error("Callee is not of pointer to function type");
- FTy = cast<FunctionType>(flattenPointerTypes(FullFTy));
- } else if (getPointerElementFlatType(FullTy) != FTy)
+ } else if (cast<PointerType>(Callee->getType())->getElementType() != FTy)
return error("Explicit call type does not match pointee type of "
"callee operand");
if (Record.size() < FTy->getNumParams() + OpNum)
return error("Insufficient operands to call");
SmallVector<Value*, 16> Args;
- SmallVector<Type*, 16> ArgsFullTys;
+ SmallVector<Type *, 16> ArgsTys;
// Read the fixed params.
for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {
if (FTy->getParamType(i)->isLabelTy())
else
Args.push_back(getValue(Record, OpNum, NextValueNo,
FTy->getParamType(i)));
- ArgsFullTys.push_back(FullFTy->getParamType(i));
+ ArgsTys.push_back(FTy->getParamType(i));
if (!Args.back())
return error("Invalid record");
}
} else {
while (OpNum != Record.size()) {
Value *Op;
- Type *FullTy;
- if (getValueTypePair(Record, OpNum, NextValueNo, Op, &FullTy))
+ if (getValueTypePair(Record, OpNum, NextValueNo, Op))
return error("Invalid record");
Args.push_back(Op);
- ArgsFullTys.push_back(FullTy);
+ ArgsTys.push_back(Op->getType());
}
}
I = CallInst::Create(FTy, Callee, Args, OperandBundles);
- FullTy = FullFTy->getReturnType();
OperandBundles.clear();
InstructionList.push_back(I);
cast<CallInst>(I)->setCallingConv(
TCK = CallInst::TCK_NoTail;
cast<CallInst>(I)->setTailCallKind(TCK);
cast<CallInst>(I)->setAttributes(PAL);
- propagateByValSRetTypes(cast<CallBase>(I), ArgsFullTys);
+ propagateByValSRetTypes(cast<CallBase>(I), ArgsTys);
if (FMF.any()) {
if (!isa<FPMathOperator>(I))
return error("Fast-math-flags specified for call without "
return error("Invalid record");
Type *OpTy = getTypeByID(Record[0]);
Value *Op = getValue(Record, 1, NextValueNo, OpTy);
- FullTy = getFullyStructuredTypeByID(Record[2]);
- Type *ResTy = flattenPointerTypes(FullTy);
+ Type *ResTy = getTypeByID(Record[2]);
if (!OpTy || !Op || !ResTy)
return error("Invalid record");
I = new VAArgInst(Op, ResTy);
case bitc::FUNC_CODE_INST_FREEZE: { // FREEZE: [opty,opval]
unsigned OpNum = 0;
Value *Op = nullptr;
- if (getValueTypePair(Record, OpNum, NextValueNo, Op, &FullTy))
+ if (getValueTypePair(Record, OpNum, NextValueNo, Op))
return error("Invalid record");
if (OpNum != Record.size())
return error("Invalid record");
}
// Non-void values get registered in the value table for future use.
- if (!I->getType()->isVoidTy()) {
- if (!FullTy) {
- FullTy = I->getType();
- assert(
- !FullTy->isPointerTy() && !isa<StructType>(FullTy) &&
- !isa<ArrayType>(FullTy) &&
- (!isa<VectorType>(FullTy) ||
- cast<VectorType>(FullTy)->getElementType()->isFloatingPointTy() ||
- cast<VectorType>(FullTy)->getElementType()->isIntegerTy()) &&
- "Structured types must be assigned with corresponding non-opaque "
- "pointer type");
- }
-
- assert(I->getType() == flattenPointerTypes(FullTy) &&
- "Incorrect fully structured type provided for Instruction");
- ValueList.assignValue(I, NextValueNo++, FullTy);
- }
+ if (!I->getType()->isVoidTy())
+ ValueList.assignValue(I, NextValueNo++);
}
OutOfRecordLoop: