Lines Matching refs:And
85 // The 'most_derived' parameter goes second if the ctor is variadic and
176 // Both Itanium and MSVC ABIs have destructor variants. The variant names
184 // The base and complete destructors are the same as in Itanium, although the
192 // bit 2 is zero, and therefore does not contain a loop.
194 // For virtual destructors, only one entry is reserved in the vftable, and it
200 // destructor, and all of the other variants are emitted on an as-needed basis
223 // and the complete object, so the "this" argument may sometimes point to
399 // For example, this code prints "100" and "1":
415 // Whereas it prints "104" and "104" if you give A a destructor.
591 /// \brief Emits a full member pointer with the fields common to data and
722 // _CxxThrowException is passed an exception object and a ThrowInfo object
800 // argument elsewhere and copy the bytes during the call.
807 // Otherwise, construct the argument into a temporary and copy the bytes
821 // multiple x64 calling conventions and the C++ ABI code shouldn't dictate
893 // In the MS ABI, the runtime handles the copy, and the catch handler is
1135 // If (1) and (2) are true, the vtorDisp for vbase Y is a hidden member of X
1138 // Outside the ctors and dtors, the values of vtorDisps are zero.
1194 // the typical calling convention and have a single 'this' pointer for an
1244 // after 'this' if it's variadic and last if it's not.
1381 // The 'most_derived' parameter goes second if the ctor is variadic and last
1914 // return types, and the caller is required to cast the prototype
1936 // Load the vfptr and then callee from the vftable. The callee should have
2200 // pointers at start-up time and, eventually, at thread-creation time.
2389 // visibility and dll storage class from the guarded variable.
2426 // Set our bit in the guard variable and emit the initializer and add a global
2720 llvm::Instruction::BinaryOps And, Or;
2723 And = llvm::Instruction::Or;
2724 Or = llvm::Instruction::And;
2727 And = llvm::Instruction::And;
2752 Res = Builder.CreateBinOp(And, Res, Cmp);
2767 return Builder.CreateBinOp(And, Res, Cmp0, "memptr.cmp");
2792 // Otherwise, emit a series of compares and combine the results.
2810 // If it's not a function pointer and it's zero initializable, we can easily
2895 // If we weren't given a dynamic vbptr offset, RD should be complete and we'll
2985 // both types and the inheritance models of both records.
3011 // For reinterpret casts, sema ensures that src and dst are both functions
3012 // or data and have the same size, which means the LLVM types should match.
3029 // In the continuation, choose between DstNull and Dst.
3149 // virtual base and the top of the MDC.
3161 // Recompose dst from the null struct and the adjusted fields from src.
3257 // Apply the adjustment and cast back to the original struct type.
3279 // a reference to the TypeInfo for the type and a reference to the
3284 // class array and the size of said array.
3297 // hierarchy such as: is this base is ambiguous and what is its offset in the
3315 /// the generation of ClassHierarchyDescriptors and BaseClassDescriptors.
3317 // implicit depth first pre-order tree connectivity. getFirstChild and
3386 /// calls to the module and information about the most derived class in a
3461 // Serialize the class hierarchy and initialize the CHD Fields.
3516 // adding +1 to Classes.size(). The sections have pointer alignment and are
3639 // - the handler is of type cv T or const T& where T is a pointer type and
3651 // for "int A::*" and separately storing the const qualifier.
3657 // for "const int **" and separately storing the const qualifier.
3689 /// types, and need to be abstracted. They are abstracting by casting the
3709 // Declare and initialize the TypeDescriptor.
3760 // destructor, and the body of the destructor is trivial.
3986 // - the handler is of type cv T or cv T& and T is an unambiguous public
3988 // - the handler is of type cv T or const T& where T is a pointer type and
4035 // - The handler is of type cv T or cv T& and E and T are the same type
4041 // - the handler is of type cv T or const T& where T is a pointer type and
4055 // pointer to member type and E is std::nullptr_t.
4159 // The exception object lives on the stack and it's address is passed to the
