|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
References
gen/lib/Target/AArch64/AArch64GenDAGISel.inc114926 MaybeAlign Align = G->getGlobal()->getPointerAlignment(DL);
include/llvm/Analysis/Loads.h 40 MaybeAlign Alignment,
62 bool isSafeToLoadUnconditionally(Value *V, MaybeAlign Alignment, APInt &Size,
86 bool isSafeToLoadUnconditionally(Value *V, Type *Ty, MaybeAlign Alignment,
include/llvm/Analysis/TargetTransformInfo.h 578 bool isLegalMaskedStore(Type *DataType, MaybeAlign Alignment) const;
580 bool isLegalMaskedLoad(Type *DataType, MaybeAlign Alignment) const;
933 int getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
1213 virtual bool isLegalMaskedStore(Type *DataType, MaybeAlign Alignment) = 0;
1214 virtual bool isLegalMaskedLoad(Type *DataType, MaybeAlign Alignment) = 0;
1309 virtual int getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
1500 bool isLegalMaskedStore(Type *DataType, MaybeAlign Alignment) override {
1503 bool isLegalMaskedLoad(Type *DataType, MaybeAlign Alignment) override {
1715 int getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
include/llvm/Analysis/TargetTransformInfoImpl.h 246 bool isLegalMaskedStore(Type *DataType, MaybeAlign Alignment) { return false; }
248 bool isLegalMaskedLoad(Type *DataType, MaybeAlign Alignment) { return false; }
450 unsigned getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
include/llvm/CodeGen/BasicTTIImpl.h 872 unsigned getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
include/llvm/CodeGen/GlobalISel/GISelKnownBits.h 69 MaybeAlign Alignment);
72 static MaybeAlign inferPtrAlignment(const MachineInstr &MI);
include/llvm/CodeGen/TargetCallingConv.h 129 MaybeAlign A = decodeMaybeAlign(ByValAlign);
138 MaybeAlign A = decodeMaybeAlign(OrigAlign);
include/llvm/CodeGen/TargetLowering.h 843 MaybeAlign align = Align::None(); // alignment
include/llvm/IR/Attributes.h 154 MaybeAlign getAlignment() const;
158 MaybeAlign getStackAlignment() const;
288 MaybeAlign getAlignment() const;
289 MaybeAlign getStackAlignment() const;
607 MaybeAlign getRetAlignment() const;
610 MaybeAlign getParamAlignment(unsigned ArgNo) const;
616 MaybeAlign getStackAlignment(unsigned Index) const;
709 MaybeAlign Alignment;
710 MaybeAlign StackAlignment;
777 MaybeAlign getAlignment() const { return Alignment; }
780 MaybeAlign getStackAlignment() const { return StackAlignment; }
799 AttrBuilder &addAlignmentAttr(MaybeAlign Align);
811 AttrBuilder &addStackAlignmentAttr(MaybeAlign Align);
include/llvm/IR/DataLayout.h 124 MaybeAlign StackNaturalAlign;
127 MaybeAlign FunctionPtrAlign;
278 MaybeAlign getFunctionPtrAlign() const { return FunctionPtrAlign; }
508 inline Align getValueOrABITypeAlignment(MaybeAlign Alignment,
include/llvm/IR/Function.h 346 if (const auto MA =
439 if (const auto MA = AttributeSets.getParamAlignment(ArgNo))
include/llvm/IR/GlobalObject.h 76 MaybeAlign Align = decodeMaybeAlign(AlignmentData);
83 void setAlignment(MaybeAlign Align);
include/llvm/IR/InstrTypes.h 1576 if (const auto MA = Attrs.getRetAlignment())
1583 if (const auto MA = Attrs.getParamAlignment(ArgNo))
include/llvm/IR/Instructions.h 81 AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, MaybeAlign Align,
83 AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, MaybeAlign Align,
113 if (const auto MA = decodeMaybeAlign(getSubclassDataFromInstruction() & 31))
117 void setAlignment(MaybeAlign Align);
187 MaybeAlign Align, Instruction *InsertBefore = nullptr);
189 MaybeAlign Align, BasicBlock *InsertAtEnd);
191 MaybeAlign Align, AtomicOrdering Order,
195 MaybeAlign Align, AtomicOrdering Order, SyncScope::ID SSID,
214 LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile, MaybeAlign Align,
218 LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile, MaybeAlign Align,
222 LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile, MaybeAlign Align,
227 LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile, MaybeAlign Align,
243 if (const auto MA =
249 void setAlignment(MaybeAlign Align);
340 StoreInst(Value *Val, Value *Ptr, bool isVolatile, MaybeAlign Align,
342 StoreInst(Value *Val, Value *Ptr, bool isVolatile, MaybeAlign Align,
344 StoreInst(Value *Val, Value *Ptr, bool isVolatile, MaybeAlign Align,
347 StoreInst(Value *Val, Value *Ptr, bool isVolatile, MaybeAlign Align,
369 if (const auto MA =
375 void setAlignment(MaybeAlign Align);
5284 inline MaybeAlign getLoadStoreAlignment(Value *I) {
include/llvm/IR/Value.h 635 MaybeAlign getPointerAlignment(const DataLayout &DL) const;
include/llvm/LTO/LTO.h 312 MaybeAlign Align;
include/llvm/Support/Alignment.h 53 friend unsigned encode(struct MaybeAlign A);
54 friend struct MaybeAlign decodeMaybeAlign(unsigned Value);
126 MaybeAlign(const MaybeAlign &Other) = default;
127 MaybeAlign &operator=(const MaybeAlign &Other) = default;
127 MaybeAlign &operator=(const MaybeAlign &Other) = default;
128 MaybeAlign(MaybeAlign &&Other) = default;
129 MaybeAlign &operator=(MaybeAlign &&Other) = default;
129 MaybeAlign &operator=(MaybeAlign &&Other) = default;
152 inline bool isAligned(MaybeAlign Lhs, uint64_t SizeInBytes) {
179 inline uint64_t alignTo(uint64_t Size, MaybeAlign A) {
208 inline unsigned Log2(MaybeAlign A) {
225 inline MaybeAlign commonAlignment(MaybeAlign A, MaybeAlign B) {
225 inline MaybeAlign commonAlignment(MaybeAlign A, MaybeAlign B) {
225 inline MaybeAlign commonAlignment(MaybeAlign A, MaybeAlign B) {
231 inline MaybeAlign commonAlignment(MaybeAlign A, uint64_t Offset) {
231 inline MaybeAlign commonAlignment(MaybeAlign A, uint64_t Offset) {
236 inline unsigned encode(MaybeAlign A) { return A ? A->ShiftValue + 1 : 0; }
239 inline MaybeAlign decodeMaybeAlign(unsigned Value) {
278 inline bool operator==(MaybeAlign Lhs, uint64_t Rhs) {
281 inline bool operator!=(MaybeAlign Lhs, uint64_t Rhs) {
284 inline bool operator<=(MaybeAlign Lhs, uint64_t Rhs) {
289 inline bool operator>=(MaybeAlign Lhs, uint64_t Rhs) {
294 inline bool operator<(MaybeAlign Lhs, uint64_t Rhs) {
299 inline bool operator>(MaybeAlign Lhs, uint64_t Rhs) {
326 inline bool operator==(Align Lhs, MaybeAlign Rhs) {
330 inline bool operator!=(Align Lhs, MaybeAlign Rhs) {
334 inline bool operator<=(Align Lhs, MaybeAlign Rhs) {
338 inline bool operator>=(Align Lhs, MaybeAlign Rhs) {
342 inline bool operator<(Align Lhs, MaybeAlign Rhs) {
346 inline bool operator>(Align Lhs, MaybeAlign Rhs) {
352 inline bool operator==(MaybeAlign Lhs, Align Rhs) {
356 inline bool operator!=(MaybeAlign Lhs, Align Rhs) {
360 inline bool operator<=(MaybeAlign Lhs, Align Rhs) {
364 inline bool operator>=(MaybeAlign Lhs, Align Rhs) {
368 inline bool operator<(MaybeAlign Lhs, Align Rhs) {
372 inline bool operator>(MaybeAlign Lhs, Align Rhs) {
384 inline MaybeAlign operator/(MaybeAlign Lhs, uint64_t Divisor) {
384 inline MaybeAlign operator/(MaybeAlign Lhs, uint64_t Divisor) {
390 inline Align max(MaybeAlign Lhs, Align Rhs) {
394 inline Align max(Align Lhs, MaybeAlign Rhs) {
include/llvm/Transforms/Scalar/GVNExpression.h 326 MaybeAlign Alignment;
352 MaybeAlign getAlignment() const { return Alignment; }
353 void setAlignment(MaybeAlign Align) { Alignment = Align; }
lib/Analysis/Loads.cpp 30 static MaybeAlign getBaseAlign(const Value *Base, const DataLayout &DL) {
31 if (const MaybeAlign PA = Base->getPointerAlignment(DL))
41 if (MaybeAlign BA = getBaseAlign(Base, DL)) {
139 MaybeAlign MA,
262 bool llvm::isSafeToLoadUnconditionally(Value *V, MaybeAlign MA, APInt &Size,
304 MaybeAlign MaybeAccessedAlign;
341 bool llvm::isSafeToLoadUnconditionally(Value *V, Type *Ty, MaybeAlign Alignment,
lib/Analysis/TargetTransformInfo.cpp 292 MaybeAlign Alignment) const {
297 MaybeAlign Alignment) const {
642 MaybeAlign Alignment,
lib/Analysis/ValueTracking.cpp 1724 const MaybeAlign Align = V->getPointerAlignment(Q.DL);
lib/Analysis/VectorUtils.cpp 839 MaybeAlign Alignment = MaybeAlign(getLoadStoreAlignment(&I));
lib/AsmParser/LLParser.cpp 1125 MaybeAlign Alignment;
1232 MaybeAlign Alignment;
1607 MaybeAlign Alignment;
1724 MaybeAlign Alignment;
2075 bool LLParser::ParseOptionalAlignment(MaybeAlign &Alignment) {
2124 bool LLParser::ParseOptionalCommaAlign(MaybeAlign &Alignment,
5379 MaybeAlign Alignment;
6874 MaybeAlign Alignment;
6935 MaybeAlign Alignment;
6984 MaybeAlign Alignment;
lib/AsmParser/LLParser.h 284 bool ParseOptionalAlignment(MaybeAlign &Alignment);
291 bool ParseOptionalCommaAlign(MaybeAlign &Alignment, bool &AteExtraComma);
lib/Bitcode/Reader/BitcodeReader.cpp 725 Error parseAlignmentValue(uint64_t Exponent, MaybeAlign &Alignment);
1547 MaybeAlign &Alignment) {
3115 MaybeAlign Alignment;
3246 MaybeAlign Alignment;
4753 MaybeAlign Align;
4792 MaybeAlign Align;
4829 MaybeAlign Align;
4851 MaybeAlign Align;
4884 MaybeAlign Align;
lib/CodeGen/AsmPrinter/AsmPrinter.cpp 172 const MaybeAlign GVAlign(GV->getAlignment());
lib/CodeGen/GlobalISel/GISelKnownBits.cpp 43 MaybeAlign GISelKnownBits::inferPtrAlignment(const MachineInstr &MI) {
59 MaybeAlign Alignment) {
lib/CodeGen/GlobalISel/IRTranslator.cpp 1656 MaybeAlign Align = Info.align;
lib/CodeGen/SelectionDAG/SelectionDAG.cpp 1903 const MaybeAlign MA(Node->getConstantOperandVal(3));
lib/IR/AttributeImpl.h 211 MaybeAlign getAlignment() const;
212 MaybeAlign getStackAlignment() const;
lib/IR/Attributes.cpp 244 MaybeAlign Attribute::getAlignment() const {
250 MaybeAlign Attribute::getStackAlignment() const {
670 MaybeAlign AttributeSet::getAlignment() const {
674 MaybeAlign AttributeSet::getStackAlignment() const {
838 MaybeAlign AttributeSetNode::getAlignment() const {
845 MaybeAlign AttributeSetNode::getStackAlignment() const {
1166 const MaybeAlign OldAlign = getAttributes(Index).getAlignment();
1167 const MaybeAlign NewAlign = B.getAlignment();
1351 MaybeAlign AttributeList::getRetAlignment() const {
1355 MaybeAlign AttributeList::getParamAlignment(unsigned ArgNo) const {
1363 MaybeAlign AttributeList::getStackAlignment(unsigned Index) const {
1520 AttrBuilder &AttrBuilder::addAlignmentAttr(MaybeAlign Align) {
1531 AttrBuilder &AttrBuilder::addStackAlignmentAttr(MaybeAlign Align) {
lib/IR/ConstantFold.cpp 1148 MaybeAlign GVAlign;
lib/IR/Globals.cpp 120 void GlobalObject::setAlignment(MaybeAlign Align) {
lib/IR/Instructions.cpp 1228 MaybeAlign Align, const Twine &Name,
1239 MaybeAlign Align, const Twine &Name,
1249 void AllocaInst::setAlignment(MaybeAlign Align) {
1307 MaybeAlign Align, Instruction *InsertBef)
1312 MaybeAlign Align, BasicBlock *InsertAE)
1317 MaybeAlign Align, AtomicOrdering Order, SyncScope::ID SSID,
1329 MaybeAlign Align, AtomicOrdering Order, SyncScope::ID SSID,
1340 void LoadInst::setAlignment(MaybeAlign Align) {
1381 StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, MaybeAlign Align,
1386 StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, MaybeAlign Align,
1391 StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, MaybeAlign Align,
1405 StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, MaybeAlign Align,
1419 void StoreInst::setAlignment(MaybeAlign Align) {
lib/IR/Value.cpp 674 MaybeAlign Value::getPointerAlignment(const DataLayout &DL) const {
678 const MaybeAlign FunctionPtrAlign = DL.getFunctionPtrAlign();
687 const MaybeAlign Alignment(GO->getAlignment());
704 const MaybeAlign Alignment(A->getParamAlignment());
713 const MaybeAlign Alignment(AI->getAlignment());
721 const MaybeAlign Alignment(Call->getRetAlignment());
lib/Linker/LinkModules.cpp 354 MaybeAlign Align(
lib/Target/AArch64/AArch64TargetTransformInfo.cpp 635 MaybeAlign Alignment, unsigned AddressSpace,
lib/Target/AArch64/AArch64TargetTransformInfo.h 137 int getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
150 bool isLegalMaskedLoad(Type *DataType, MaybeAlign Alignment) {
lib/Target/AMDGPU/SIISelLowering.cpp 2823 MaybeAlign Alignment;
lib/Target/ARM/ARMTargetTransformInfo.cpp 494 bool ARMTTIImpl::isLegalMaskedLoad(Type *DataTy, MaybeAlign Alignment) {
739 MaybeAlign Alignment, unsigned AddressSpace,
lib/Target/ARM/ARMTargetTransformInfo.h 156 bool isLegalMaskedLoad(Type *DataTy, MaybeAlign Alignment);
158 bool isLegalMaskedStore(Type *DataTy, MaybeAlign Alignment) {
192 int getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
lib/Target/Hexagon/HexagonTargetTransformInfo.cpp 155 MaybeAlign Alignment,
lib/Target/Hexagon/HexagonTargetTransformInfo.h 115 unsigned getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
lib/Target/Mips/MipsSubtarget.cpp 72 MaybeAlign StackAlignOverride)
lib/Target/Mips/MipsSubtarget.h 200 MaybeAlign StackAlignOverride;
233 const MipsTargetMachine &TM, MaybeAlign StackAlignOverride);
lib/Target/PowerPC/PPCTargetTransformInfo.cpp 837 MaybeAlign Alignment, unsigned AddressSpace,
lib/Target/PowerPC/PPCTargetTransformInfo.h 100 int getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
lib/Target/SystemZ/SystemZTargetTransformInfo.cpp 998 MaybeAlign Alignment, unsigned AddressSpace,
lib/Target/SystemZ/SystemZTargetTransformInfo.h 90 int getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
lib/Target/X86/X86FrameLowering.cpp 38 MaybeAlign StackAlignOverride)
lib/Target/X86/X86FrameLowering.h 28 X86FrameLowering(const X86Subtarget &STI, MaybeAlign StackAlignOverride);
lib/Target/X86/X86Subtarget.cpp 324 MaybeAlign StackAlignOverride,
lib/Target/X86/X86Subtarget.h 465 MaybeAlign StackAlignOverride;
502 const X86TargetMachine &TM, MaybeAlign StackAlignOverride,
lib/Target/X86/X86TargetTransformInfo.cpp 2408 MaybeAlign Alignment, unsigned AddressSpace,
3262 bool X86TTIImpl::isLegalMaskedLoad(Type *DataTy, MaybeAlign Alignment) {
3285 bool X86TTIImpl::isLegalMaskedStore(Type *DataType, MaybeAlign Alignment) {
lib/Target/X86/X86TargetTransformInfo.h 137 int getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
189 bool isLegalMaskedLoad(Type *DataType, MaybeAlign Alignment);
190 bool isLegalMaskedStore(Type *DataType, MaybeAlign Alignment);
lib/Transforms/IPO/Attributor.cpp 2760 const MaybeAlign PA = V.getPointerAlignment(DL);
lib/Transforms/IPO/LowerTypeTests.cpp 830 MaybeAlign Alignment(GV->getAlignment());
lib/Transforms/IPO/MergeFunctions.cpp 819 MaybeAlign MaxAlignment(std::max(G->getAlignment(), NewF->getAlignment()));
lib/Transforms/IPO/WholeProgramDevirt.cpp 1496 MaybeAlign Alignment(B.GV->getAlignment());
lib/Transforms/InstCombine/InstCombineCalls.cpp 1088 MaybeAlign Alignment(
lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp 385 const MaybeAlign MaxAlign(
1023 const MaybeAlign Alignment(LI.getAlignment());
1361 const MaybeAlign StoreAlign = MaybeAlign(SI.getAlignment());
lib/Transforms/InstCombine/InstCombinePHI.cpp 545 MaybeAlign LoadAlignment(FirstLI->getAlignment());
lib/Transforms/Scalar/SROA.cpp 1202 MaybeAlign MaxAlign;
1275 const MaybeAlign Align = MaybeAlign(SomeLoad->getAlignment());
lib/Transforms/Vectorize/LoopVectorizationLegality.cpp 744 const MaybeAlign Alignment = getLoadStoreAlignment(ST);
761 const MaybeAlign Alignment = getLoadStoreAlignment(LD);
lib/Transforms/Vectorize/LoopVectorize.cpp 1194 bool isLegalMaskedStore(Type *DataType, Value *Ptr, MaybeAlign Alignment) {
1201 bool isLegalMaskedLoad(Type *DataType, Value *Ptr, MaybeAlign Alignment) {
4565 const MaybeAlign Alignment = getLoadStoreAlignment(I);
4611 const MaybeAlign Alignment = getLoadStoreAlignment(I);
5747 const MaybeAlign Alignment = getLoadStoreAlignment(I);
5780 const MaybeAlign Alignment = getLoadStoreAlignment(I);
5798 const MaybeAlign Alignment = getLoadStoreAlignment(I);
5820 const MaybeAlign Alignment = getLoadStoreAlignment(I);
5873 const MaybeAlign Alignment = getLoadStoreAlignment(I);
lib/Transforms/Vectorize/SLPVectorizer.cpp 3165 MaybeAlign alignment(cast<LoadInst>(VL0)->getAlignment());
3183 MaybeAlign alignment(cast<StoreInst>(VL0)->getAlignment());
4031 MaybeAlign Alignment = MaybeAlign(LI->getAlignment());
unittests/IR/ConstantsTest.cpp 480 MaybeAlign FunctionAlign = llvm::None) {
unittests/Support/AlignmentTest.cpp 118 MaybeAlign A(T.alignment);
173 MaybeAlign Actual(Value);
174 MaybeAlign Expected = decodeMaybeAlign(encode(Actual));
178 MaybeAlign Actual(0);
179 MaybeAlign Expected = decodeMaybeAlign(encode(Actual));
199 MaybeAlign A(T.alignment);
259 const MaybeAlign MA(ValidAlignments[I - 1]);
260 const MaybeAlign MB(ValidAlignments[I]);
usr/include/c++/7.4.0/bits/algorithmfwd.h 369 const _Tp&
370 max(const _Tp&, const _Tp&);
370 max(const _Tp&, const _Tp&);
382 const _Tp&
383 min(const _Tp&, const _Tp&);
383 min(const _Tp&, const _Tp&);
usr/include/c++/7.4.0/bits/move.h 72 constexpr _Tp&&
73 forward(typename std::remove_reference<_Tp>::type& __t) noexcept
83 constexpr _Tp&&
84 forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
usr/include/c++/7.4.0/bits/unique_ptr.h 824 make_unique(_Args&&... __args)
825 { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
usr/include/c++/7.4.0/type_traits 1629 { typedef _Tp type; };
utils/unittest/googletest/include/gtest/gtest-printers.h 140 static void PrintValue(const T& value, ::std::ostream* os) {
205 ::std::basic_ostream<Char, CharTraits>& os, const T& x) {
206 TypeWithoutFormatter<T,
207 (internal::IsAProtocolMessage<T>::value ? kProtobuf :
208 internal::ImplicitlyConvertible<const T&, internal::BiggestInt>::value ?
223 void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) {
276 static ::std::string Format(const ToPrint& value) {
351 const T1& value, const T2& /* other_operand */) {
351 const T1& value, const T2& /* other_operand */) {
352 return FormatForComparison<T1, T2>::Format(value);
352 return FormatForComparison<T1, T2>::Format(value);
366 void UniversalPrint(const T& value, ::std::ostream* os);
373 const C& container, ::std::ostream* os) {
439 const T& value, ::std::ostream* os) {
455 void PrintTo(const T& value, ::std::ostream* os) {
478 DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os);
699 static void Print(const T& value, ::std::ostream* os) {
784 static void Print(const T& value, ::std::ostream* os) {
856 typedef T T1;
983 internal::UniversalTersePrinter<T>::Print(value, &ss);
utils/unittest/googletest/include/gtest/gtest.h 273 const T& success,
275 !internal::ImplicitlyConvertible<T, AssertionResult>::value>::type*
1377 const T1& lhs, const T2& rhs) {
1377 const T1& lhs, const T2& rhs) {
1389 const T1& lhs,
1390 const T2& rhs) {
1419 const T1& lhs,
1420 const T2& rhs) {
1487 const T1& val1, const T2& val2,
1487 const T1& val1, const T2& val2,
utils/unittest/googletest/include/gtest/internal/custom/raw-ostream.h 29 static const T& printable(const T& V) { return V; }
29 static const T& printable(const T& V) { return V; }
35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
37 return StreamSwitch<T>::printable(V);
utils/unittest/googletest/include/gtest/internal/gtest-internal.h 94 ::std::string PrintToString(const T& value);
830 struct AddReference { typedef T& type; }; // NOLINT
863 static typename AddReference<From>::type MakeFrom();