/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/CodeGen/CGExprComplex.cpp
Line | Count | Source (jump to first uncovered line) |
1 | | //===--- CGExprComplex.cpp - Emit LLVM Code for Complex Exprs -------------===// |
2 | | // |
3 | | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | | // See https://llvm.org/LICENSE.txt for license information. |
5 | | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | | // |
7 | | //===----------------------------------------------------------------------===// |
8 | | // |
9 | | // This contains code to emit Expr nodes with complex types as LLVM code. |
10 | | // |
11 | | //===----------------------------------------------------------------------===// |
12 | | |
13 | | #include "CGOpenMPRuntime.h" |
14 | | #include "CodeGenFunction.h" |
15 | | #include "CodeGenModule.h" |
16 | | #include "ConstantEmitter.h" |
17 | | #include "clang/AST/StmtVisitor.h" |
18 | | #include "llvm/ADT/STLExtras.h" |
19 | | #include "llvm/IR/Constants.h" |
20 | | #include "llvm/IR/Instructions.h" |
21 | | #include "llvm/IR/MDBuilder.h" |
22 | | #include "llvm/IR/Metadata.h" |
23 | | #include <algorithm> |
24 | | using namespace clang; |
25 | | using namespace CodeGen; |
26 | | |
27 | | //===----------------------------------------------------------------------===// |
28 | | // Complex Expression Emitter |
29 | | //===----------------------------------------------------------------------===// |
30 | | |
31 | | typedef CodeGenFunction::ComplexPairTy ComplexPairTy; |
32 | | |
33 | | /// Return the complex type that we are meant to emit. |
34 | 2.02k | static const ComplexType *getComplexType(QualType type) { |
35 | 2.02k | type = type.getCanonicalType(); |
36 | 2.02k | if (const ComplexType *comp = dyn_cast<ComplexType>(type)) { |
37 | 2.02k | return comp; |
38 | 2.02k | } else { |
39 | 2 | return cast<ComplexType>(cast<AtomicType>(type)->getValueType()); |
40 | 2 | } |
41 | 2.02k | } |
42 | | |
43 | | namespace { |
44 | | class ComplexExprEmitter |
45 | | : public StmtVisitor<ComplexExprEmitter, ComplexPairTy> { |
46 | | CodeGenFunction &CGF; |
47 | | CGBuilderTy &Builder; |
48 | | bool IgnoreReal; |
49 | | bool IgnoreImag; |
50 | | public: |
51 | | ComplexExprEmitter(CodeGenFunction &cgf, bool ir=false, bool ii=false) |
52 | 3.61k | : CGF(cgf), Builder(CGF.Builder), IgnoreReal(ir), IgnoreImag(ii) { |
53 | 3.61k | } |
54 | | |
55 | | |
56 | | //===--------------------------------------------------------------------===// |
57 | | // Utilities |
58 | | //===--------------------------------------------------------------------===// |
59 | | |
60 | 961 | bool TestAndClearIgnoreReal() { |
61 | 961 | bool I = IgnoreReal; |
62 | 961 | IgnoreReal = false; |
63 | 961 | return I; |
64 | 961 | } |
65 | 961 | bool TestAndClearIgnoreImag() { |
66 | 961 | bool I = IgnoreImag; |
67 | 961 | IgnoreImag = false; |
68 | 961 | return I; |
69 | 961 | } |
70 | | |
71 | | /// EmitLoadOfLValue - Given an expression with complex type that represents a |
72 | | /// value l-value, this method emits the address of the l-value, then loads |
73 | | /// and returns the result. |
74 | 1.23k | ComplexPairTy EmitLoadOfLValue(const Expr *E) { |
75 | 1.23k | return EmitLoadOfLValue(CGF.EmitLValue(E), E->getExprLoc()); |
76 | 1.23k | } |
77 | | |
78 | | ComplexPairTy EmitLoadOfLValue(LValue LV, SourceLocation Loc); |
79 | | |
80 | | /// EmitStoreOfComplex - Store the specified real/imag parts into the |
81 | | /// specified value pointer. |
82 | | void EmitStoreOfComplex(ComplexPairTy Val, LValue LV, bool isInit); |
83 | | |
84 | | /// Emit a cast from complex value Val to DestType. |
85 | | ComplexPairTy EmitComplexToComplexCast(ComplexPairTy Val, QualType SrcType, |
86 | | QualType DestType, SourceLocation Loc); |
87 | | /// Emit a cast from scalar value Val to DestType. |
88 | | ComplexPairTy EmitScalarToComplexCast(llvm::Value *Val, QualType SrcType, |
89 | | QualType DestType, SourceLocation Loc); |
90 | | |
91 | | //===--------------------------------------------------------------------===// |
92 | | // Visitor Methods |
93 | | //===--------------------------------------------------------------------===// |
94 | | |
95 | 4.84k | ComplexPairTy Visit(Expr *E) { |
96 | 4.84k | ApplyDebugLocation DL(CGF, E); |
97 | 4.84k | return StmtVisitor<ComplexExprEmitter, ComplexPairTy>::Visit(E); |
98 | 4.84k | } |
99 | | |
100 | 0 | ComplexPairTy VisitStmt(Stmt *S) { |
101 | 0 | S->dump(llvm::errs(), CGF.getContext()); |
102 | 0 | llvm_unreachable("Stmt can't have complex result type!"); |
103 | 0 | } |
104 | | ComplexPairTy VisitExpr(Expr *S); |
105 | 0 | ComplexPairTy VisitConstantExpr(ConstantExpr *E) { |
106 | 0 | if (llvm::Constant *Result = ConstantEmitter(CGF).tryEmitConstantExpr(E)) |
107 | 0 | return ComplexPairTy(Result->getAggregateElement(0U), |
108 | 0 | Result->getAggregateElement(1U)); |
109 | 0 | return Visit(E->getSubExpr()); |
110 | 0 | } |
111 | 76 | ComplexPairTy VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr());} |
112 | 0 | ComplexPairTy VisitGenericSelectionExpr(GenericSelectionExpr *GE) { |
113 | 0 | return Visit(GE->getResultExpr()); |
114 | 0 | } |
115 | | ComplexPairTy VisitImaginaryLiteral(const ImaginaryLiteral *IL); |
116 | | ComplexPairTy |
117 | 0 | VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE) { |
118 | 0 | return Visit(PE->getReplacement()); |
119 | 0 | } |
120 | 6 | ComplexPairTy VisitCoawaitExpr(CoawaitExpr *S) { |
121 | 6 | return CGF.EmitCoawaitExpr(*S).getComplexVal(); |
122 | 6 | } |
123 | 0 | ComplexPairTy VisitCoyieldExpr(CoyieldExpr *S) { |
124 | 0 | return CGF.EmitCoyieldExpr(*S).getComplexVal(); |
125 | 0 | } |
126 | 0 | ComplexPairTy VisitUnaryCoawait(const UnaryOperator *E) { |
127 | 0 | return Visit(E->getSubExpr()); |
128 | 0 | } |
129 | | |
130 | | ComplexPairTy emitConstant(const CodeGenFunction::ConstantEmission &Constant, |
131 | 9 | Expr *E) { |
132 | 9 | assert(Constant && "not a constant"); |
133 | 9 | if (Constant.isReference()) |
134 | 1 | return EmitLoadOfLValue(Constant.getReferenceLValue(CGF, E), |
135 | 1 | E->getExprLoc()); |
136 | | |
137 | 8 | llvm::Constant *pair = Constant.getValue(); |
138 | 8 | return ComplexPairTy(pair->getAggregateElement(0U), |
139 | 8 | pair->getAggregateElement(1U)); |
140 | 9 | } |
141 | | |
142 | | // l-values. |
143 | 1.20k | ComplexPairTy VisitDeclRefExpr(DeclRefExpr *E) { |
144 | 1.20k | if (CodeGenFunction::ConstantEmission Constant = CGF.tryEmitAsConstant(E)) |
145 | 4 | return emitConstant(Constant, E); |
146 | 1.20k | return EmitLoadOfLValue(E); |
147 | 1.20k | } |
148 | 12 | ComplexPairTy VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { |
149 | 12 | return EmitLoadOfLValue(E); |
150 | 12 | } |
151 | 17 | ComplexPairTy VisitObjCMessageExpr(ObjCMessageExpr *E) { |
152 | 17 | return CGF.EmitObjCMessageExpr(E).getComplexVal(); |
153 | 17 | } |
154 | 4 | ComplexPairTy VisitArraySubscriptExpr(Expr *E) { return EmitLoadOfLValue(E); } |
155 | 9 | ComplexPairTy VisitMemberExpr(MemberExpr *ME) { |
156 | 9 | if (CodeGenFunction::ConstantEmission Constant = |
157 | 9 | CGF.tryEmitAsConstant(ME)) { |
158 | 5 | CGF.EmitIgnoredExpr(ME->getBase()); |
159 | 5 | return emitConstant(Constant, ME); |
160 | 5 | } |
161 | 4 | return EmitLoadOfLValue(ME); |
162 | 9 | } |
163 | 91 | ComplexPairTy VisitOpaqueValueExpr(OpaqueValueExpr *E) { |
164 | 91 | if (E->isGLValue()) |
165 | 3 | return EmitLoadOfLValue(CGF.getOrCreateOpaqueLValueMapping(E), |
166 | 3 | E->getExprLoc()); |
167 | 88 | return CGF.getOrCreateOpaqueRValueMapping(E).getComplexVal(); |
168 | 91 | } |
169 | | |
170 | 15 | ComplexPairTy VisitPseudoObjectExpr(PseudoObjectExpr *E) { |
171 | 15 | return CGF.EmitPseudoObjectRValue(E).getComplexVal(); |
172 | 15 | } |
173 | | |
174 | | // FIXME: CompoundLiteralExpr |
175 | | |
176 | | ComplexPairTy EmitCast(CastKind CK, Expr *Op, QualType DestTy); |
177 | 2.07k | ComplexPairTy VisitImplicitCastExpr(ImplicitCastExpr *E) { |
178 | | // Unlike for scalars, we don't have to worry about function->ptr demotion |
179 | | // here. |
180 | 2.07k | return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType()); |
181 | 2.07k | } |
182 | 16 | ComplexPairTy VisitCastExpr(CastExpr *E) { |
183 | 16 | if (const auto *ECE = dyn_cast<ExplicitCastExpr>(E)) |
184 | 16 | CGF.CGM.EmitExplicitCastExprType(ECE, &CGF); |
185 | 16 | return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType()); |
186 | 16 | } |
187 | | ComplexPairTy VisitCallExpr(const CallExpr *E); |
188 | | ComplexPairTy VisitStmtExpr(const StmtExpr *E); |
189 | | |
190 | | // Operators. |
191 | | ComplexPairTy VisitPrePostIncDec(const UnaryOperator *E, |
192 | 8 | bool isInc, bool isPre) { |
193 | 8 | LValue LV = CGF.EmitLValue(E->getSubExpr()); |
194 | 8 | return CGF.EmitComplexPrePostIncDec(E, LV, isInc, isPre); |
195 | 8 | } |
196 | 2 | ComplexPairTy VisitUnaryPostDec(const UnaryOperator *E) { |
197 | 2 | return VisitPrePostIncDec(E, false, false); |
198 | 2 | } |
199 | 2 | ComplexPairTy VisitUnaryPostInc(const UnaryOperator *E) { |
200 | 2 | return VisitPrePostIncDec(E, true, false); |
201 | 2 | } |
202 | 2 | ComplexPairTy VisitUnaryPreDec(const UnaryOperator *E) { |
203 | 2 | return VisitPrePostIncDec(E, false, true); |
204 | 2 | } |
205 | 2 | ComplexPairTy VisitUnaryPreInc(const UnaryOperator *E) { |
206 | 2 | return VisitPrePostIncDec(E, true, true); |
207 | 2 | } |
208 | 8 | ComplexPairTy VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); } |
209 | 5 | ComplexPairTy VisitUnaryPlus (const UnaryOperator *E) { |
210 | 5 | TestAndClearIgnoreReal(); |
211 | 5 | TestAndClearIgnoreImag(); |
212 | 5 | return Visit(E->getSubExpr()); |
213 | 5 | } |
214 | | ComplexPairTy VisitUnaryMinus (const UnaryOperator *E); |
215 | | ComplexPairTy VisitUnaryNot (const UnaryOperator *E); |
216 | | // LNot,Real,Imag never return complex. |
217 | 18 | ComplexPairTy VisitUnaryExtension(const UnaryOperator *E) { |
218 | 18 | return Visit(E->getSubExpr()); |
219 | 18 | } |
220 | 9 | ComplexPairTy VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { |
221 | 9 | CodeGenFunction::CXXDefaultArgExprScope Scope(CGF, DAE); |
222 | 9 | return Visit(DAE->getExpr()); |
223 | 9 | } |
224 | 0 | ComplexPairTy VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) { |
225 | 0 | CodeGenFunction::CXXDefaultInitExprScope Scope(CGF, DIE); |
226 | 0 | return Visit(DIE->getExpr()); |
227 | 0 | } |
228 | 5 | ComplexPairTy VisitExprWithCleanups(ExprWithCleanups *E) { |
229 | 5 | CodeGenFunction::RunCleanupsScope Scope(CGF); |
230 | 5 | ComplexPairTy Vals = Visit(E->getSubExpr()); |
231 | | // Defend against dominance problems caused by jumps out of expression |
232 | | // evaluation through the shared cleanup block. |
233 | 5 | Scope.ForceCleanup({&Vals.first, &Vals.second}); |
234 | 5 | return Vals; |
235 | 5 | } |
236 | 2 | ComplexPairTy VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { |
237 | 2 | assert(E->getType()->isAnyComplexType() && "Expected complex type!"); |
238 | 0 | QualType Elem = E->getType()->castAs<ComplexType>()->getElementType(); |
239 | 2 | llvm::Constant *Null = llvm::Constant::getNullValue(CGF.ConvertType(Elem)); |
240 | 2 | return ComplexPairTy(Null, Null); |
241 | 2 | } |
242 | 1 | ComplexPairTy VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { |
243 | 1 | assert(E->getType()->isAnyComplexType() && "Expected complex type!"); |
244 | 0 | QualType Elem = E->getType()->castAs<ComplexType>()->getElementType(); |
245 | 1 | llvm::Constant *Null = |
246 | 1 | llvm::Constant::getNullValue(CGF.ConvertType(Elem)); |
247 | 1 | return ComplexPairTy(Null, Null); |
248 | 1 | } |
249 | | |
250 | | struct BinOpInfo { |
251 | | ComplexPairTy LHS; |
252 | | ComplexPairTy RHS; |
253 | | QualType Ty; // Computation Type. |
254 | | }; |
255 | | |
256 | | BinOpInfo EmitBinOps(const BinaryOperator *E); |
257 | | LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E, |
258 | | ComplexPairTy (ComplexExprEmitter::*Func) |
259 | | (const BinOpInfo &), |
260 | | RValue &Val); |
261 | | ComplexPairTy EmitCompoundAssign(const CompoundAssignOperator *E, |
262 | | ComplexPairTy (ComplexExprEmitter::*Func) |
263 | | (const BinOpInfo &)); |
264 | | |
265 | | ComplexPairTy EmitBinAdd(const BinOpInfo &Op); |
266 | | ComplexPairTy EmitBinSub(const BinOpInfo &Op); |
267 | | ComplexPairTy EmitBinMul(const BinOpInfo &Op); |
268 | | ComplexPairTy EmitBinDiv(const BinOpInfo &Op); |
269 | | |
270 | | ComplexPairTy EmitComplexBinOpLibCall(StringRef LibCallName, |
271 | | const BinOpInfo &Op); |
272 | | |
273 | 254 | ComplexPairTy VisitBinAdd(const BinaryOperator *E) { |
274 | 254 | return EmitBinAdd(EmitBinOps(E)); |
275 | 254 | } |
276 | 119 | ComplexPairTy VisitBinSub(const BinaryOperator *E) { |
277 | 119 | return EmitBinSub(EmitBinOps(E)); |
278 | 119 | } |
279 | 133 | ComplexPairTy VisitBinMul(const BinaryOperator *E) { |
280 | 133 | return EmitBinMul(EmitBinOps(E)); |
281 | 133 | } |
282 | 116 | ComplexPairTy VisitBinDiv(const BinaryOperator *E) { |
283 | 116 | return EmitBinDiv(EmitBinOps(E)); |
284 | 116 | } |
285 | | |
286 | 0 | ComplexPairTy VisitCXXRewrittenBinaryOperator(CXXRewrittenBinaryOperator *E) { |
287 | 0 | return Visit(E->getSemanticForm()); |
288 | 0 | } |
289 | | |
290 | | // Compound assignments. |
291 | 9 | ComplexPairTy VisitBinAddAssign(const CompoundAssignOperator *E) { |
292 | 9 | return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinAdd); |
293 | 9 | } |
294 | 0 | ComplexPairTy VisitBinSubAssign(const CompoundAssignOperator *E) { |
295 | 0 | return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinSub); |
296 | 0 | } |
297 | 1 | ComplexPairTy VisitBinMulAssign(const CompoundAssignOperator *E) { |
298 | 1 | return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinMul); |
299 | 1 | } |
300 | 5 | ComplexPairTy VisitBinDivAssign(const CompoundAssignOperator *E) { |
301 | 5 | return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinDiv); |
302 | 5 | } |
303 | | |
304 | | // GCC rejects rem/and/or/xor for integer complex. |
305 | | // Logical and/or always return int, never complex. |
306 | | |
307 | | // No comparisons produce a complex result. |
308 | | |
309 | | LValue EmitBinAssignLValue(const BinaryOperator *E, |
310 | | ComplexPairTy &Val); |
311 | | ComplexPairTy VisitBinAssign (const BinaryOperator *E); |
312 | | ComplexPairTy VisitBinComma (const BinaryOperator *E); |
313 | | |
314 | | |
315 | | ComplexPairTy |
316 | | VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO); |
317 | | ComplexPairTy VisitChooseExpr(ChooseExpr *CE); |
318 | | |
319 | | ComplexPairTy VisitInitListExpr(InitListExpr *E); |
320 | | |
321 | 1 | ComplexPairTy VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { |
322 | 1 | return EmitLoadOfLValue(E); |
323 | 1 | } |
324 | | |
325 | | ComplexPairTy VisitVAArgExpr(VAArgExpr *E); |
326 | | |
327 | 4 | ComplexPairTy VisitAtomicExpr(AtomicExpr *E) { |
328 | 4 | return CGF.EmitAtomicExpr(E).getComplexVal(); |
329 | 4 | } |
330 | | }; |
331 | | } // end anonymous namespace. |
332 | | |
333 | | //===----------------------------------------------------------------------===// |
334 | | // Utilities |
335 | | //===----------------------------------------------------------------------===// |
336 | | |
337 | | Address CodeGenFunction::emitAddrOfRealComponent(Address addr, |
338 | 3.91k | QualType complexType) { |
339 | 3.91k | return Builder.CreateStructGEP(addr, 0, addr.getName() + ".realp"); |
340 | 3.91k | } |
341 | | |
342 | | Address CodeGenFunction::emitAddrOfImagComponent(Address addr, |
343 | 3.89k | QualType complexType) { |
344 | 3.89k | return Builder.CreateStructGEP(addr, 1, addr.getName() + ".imagp"); |
345 | 3.89k | } |
346 | | |
347 | | /// EmitLoadOfLValue - Given an RValue reference for a complex, emit code to |
348 | | /// load the real and imaginary pieces, returning them as Real/Imag. |
349 | | ComplexPairTy ComplexExprEmitter::EmitLoadOfLValue(LValue lvalue, |
350 | 1.95k | SourceLocation loc) { |
351 | 1.95k | assert(lvalue.isSimple() && "non-simple complex l-value?"); |
352 | 1.95k | if (lvalue.getType()->isAtomicType()) |
353 | 4 | return CGF.EmitAtomicLoad(lvalue, loc).getComplexVal(); |
354 | | |
355 | 1.94k | Address SrcPtr = lvalue.getAddress(CGF); |
356 | 1.94k | bool isVolatile = lvalue.isVolatileQualified(); |
357 | | |
358 | 1.94k | llvm::Value *Real = nullptr, *Imag = nullptr; |
359 | | |
360 | 1.94k | if (!IgnoreReal || isVolatile9 ) { |
361 | 1.94k | Address RealP = CGF.emitAddrOfRealComponent(SrcPtr, lvalue.getType()); |
362 | 1.94k | Real = Builder.CreateLoad(RealP, isVolatile, SrcPtr.getName() + ".real"); |
363 | 1.94k | } |
364 | | |
365 | 1.94k | if (!IgnoreImag || isVolatile45 ) { |
366 | 1.91k | Address ImagP = CGF.emitAddrOfImagComponent(SrcPtr, lvalue.getType()); |
367 | 1.91k | Imag = Builder.CreateLoad(ImagP, isVolatile, SrcPtr.getName() + ".imag"); |
368 | 1.91k | } |
369 | | |
370 | 1.94k | return ComplexPairTy(Real, Imag); |
371 | 1.95k | } |
372 | | |
373 | | /// EmitStoreOfComplex - Store the specified real/imag parts into the |
374 | | /// specified value pointer. |
375 | | void ComplexExprEmitter::EmitStoreOfComplex(ComplexPairTy Val, LValue lvalue, |
376 | 1.90k | bool isInit) { |
377 | 1.90k | if (lvalue.getType()->isAtomicType() || |
378 | 1.90k | (1.90k !isInit1.90k && CGF.LValueIsSuitableForInlineAtomic(lvalue)367 )) |
379 | 6 | return CGF.EmitAtomicStore(RValue::getComplex(Val), lvalue, isInit); |
380 | | |
381 | 1.90k | Address Ptr = lvalue.getAddress(CGF); |
382 | 1.90k | Address RealPtr = CGF.emitAddrOfRealComponent(Ptr, lvalue.getType()); |
383 | 1.90k | Address ImagPtr = CGF.emitAddrOfImagComponent(Ptr, lvalue.getType()); |
384 | | |
385 | 1.90k | Builder.CreateStore(Val.first, RealPtr, lvalue.isVolatileQualified()); |
386 | 1.90k | Builder.CreateStore(Val.second, ImagPtr, lvalue.isVolatileQualified()); |
387 | 1.90k | } |
388 | | |
389 | | |
390 | | |
391 | | //===----------------------------------------------------------------------===// |
392 | | // Visitor Methods |
393 | | //===----------------------------------------------------------------------===// |
394 | | |
395 | 0 | ComplexPairTy ComplexExprEmitter::VisitExpr(Expr *E) { |
396 | 0 | CGF.ErrorUnsupported(E, "complex expression"); |
397 | 0 | llvm::Type *EltTy = |
398 | 0 | CGF.ConvertType(getComplexType(E->getType())->getElementType()); |
399 | 0 | llvm::Value *U = llvm::UndefValue::get(EltTy); |
400 | 0 | return ComplexPairTy(U, U); |
401 | 0 | } |
402 | | |
403 | | ComplexPairTy ComplexExprEmitter:: |
404 | 88 | VisitImaginaryLiteral(const ImaginaryLiteral *IL) { |
405 | 88 | llvm::Value *Imag = CGF.EmitScalarExpr(IL->getSubExpr()); |
406 | 88 | return ComplexPairTy(llvm::Constant::getNullValue(Imag->getType()), Imag); |
407 | 88 | } |
408 | | |
409 | | |
410 | 296 | ComplexPairTy ComplexExprEmitter::VisitCallExpr(const CallExpr *E) { |
411 | 296 | if (E->getCallReturnType(CGF.getContext())->isReferenceType()) |
412 | 2 | return EmitLoadOfLValue(E); |
413 | | |
414 | 294 | return CGF.EmitCallExpr(E).getComplexVal(); |
415 | 296 | } |
416 | | |
417 | 0 | ComplexPairTy ComplexExprEmitter::VisitStmtExpr(const StmtExpr *E) { |
418 | 0 | CodeGenFunction::StmtExprEvaluation eval(CGF); |
419 | 0 | Address RetAlloca = CGF.EmitCompoundStmt(*E->getSubStmt(), true); |
420 | 0 | assert(RetAlloca.isValid() && "Expected complex return value"); |
421 | 0 | return EmitLoadOfLValue(CGF.MakeAddrLValue(RetAlloca, E->getType()), |
422 | 0 | E->getExprLoc()); |
423 | 0 | } |
424 | | |
425 | | /// Emit a cast from complex value Val to DestType. |
426 | | ComplexPairTy ComplexExprEmitter::EmitComplexToComplexCast(ComplexPairTy Val, |
427 | | QualType SrcType, |
428 | | QualType DestType, |
429 | 322 | SourceLocation Loc) { |
430 | | // Get the src/dest element type. |
431 | 322 | SrcType = SrcType->castAs<ComplexType>()->getElementType(); |
432 | 322 | DestType = DestType->castAs<ComplexType>()->getElementType(); |
433 | | |
434 | | // C99 6.3.1.6: When a value of complex type is converted to another |
435 | | // complex type, both the real and imaginary parts follow the conversion |
436 | | // rules for the corresponding real types. |
437 | 322 | if (Val.first) |
438 | 321 | Val.first = CGF.EmitScalarConversion(Val.first, SrcType, DestType, Loc); |
439 | 322 | if (Val.second) |
440 | 321 | Val.second = CGF.EmitScalarConversion(Val.second, SrcType, DestType, Loc); |
441 | 322 | return Val; |
442 | 322 | } |
443 | | |
444 | | ComplexPairTy ComplexExprEmitter::EmitScalarToComplexCast(llvm::Value *Val, |
445 | | QualType SrcType, |
446 | | QualType DestType, |
447 | 646 | SourceLocation Loc) { |
448 | | // Convert the input element to the element type of the complex. |
449 | 646 | DestType = DestType->castAs<ComplexType>()->getElementType(); |
450 | 646 | Val = CGF.EmitScalarConversion(Val, SrcType, DestType, Loc); |
451 | | |
452 | | // Return (realval, 0). |
453 | 646 | return ComplexPairTy(Val, llvm::Constant::getNullValue(Val->getType())); |
454 | 646 | } |
455 | | |
456 | | ComplexPairTy ComplexExprEmitter::EmitCast(CastKind CK, Expr *Op, |
457 | 2.08k | QualType DestTy) { |
458 | 2.08k | switch (CK) { |
459 | 0 | case CK_Dependent: llvm_unreachable("dependent cast kind in IR gen!"); |
460 | | |
461 | | // Atomic to non-atomic casts may be more than a no-op for some platforms and |
462 | | // for some types. |
463 | 2 | case CK_AtomicToNonAtomic: |
464 | 6 | case CK_NonAtomicToAtomic: |
465 | 6 | case CK_NoOp: |
466 | 1.26k | case CK_LValueToRValue: |
467 | 1.26k | case CK_UserDefinedConversion: |
468 | 1.26k | return Visit(Op); |
469 | | |
470 | 9 | case CK_LValueBitCast: { |
471 | 9 | LValue origLV = CGF.EmitLValue(Op); |
472 | 9 | Address V = origLV.getAddress(CGF); |
473 | 9 | V = Builder.CreateElementBitCast(V, CGF.ConvertType(DestTy)); |
474 | 9 | return EmitLoadOfLValue(CGF.MakeAddrLValue(V, DestTy), Op->getExprLoc()); |
475 | 1.26k | } |
476 | | |
477 | 1 | case CK_LValueToRValueBitCast: { |
478 | 1 | LValue SourceLVal = CGF.EmitLValue(Op); |
479 | 1 | Address Addr = Builder.CreateElementBitCast(SourceLVal.getAddress(CGF), |
480 | 1 | CGF.ConvertTypeForMem(DestTy)); |
481 | 1 | LValue DestLV = CGF.MakeAddrLValue(Addr, DestTy); |
482 | 1 | DestLV.setTBAAInfo(TBAAAccessInfo::getMayAliasInfo()); |
483 | 1 | return EmitLoadOfLValue(DestLV, Op->getExprLoc()); |
484 | 1.26k | } |
485 | | |
486 | 0 | case CK_BitCast: |
487 | 0 | case CK_BaseToDerived: |
488 | 0 | case CK_DerivedToBase: |
489 | 0 | case CK_UncheckedDerivedToBase: |
490 | 0 | case CK_Dynamic: |
491 | 0 | case CK_ToUnion: |
492 | 0 | case CK_ArrayToPointerDecay: |
493 | 0 | case CK_FunctionToPointerDecay: |
494 | 0 | case CK_NullToPointer: |
495 | 0 | case CK_NullToMemberPointer: |
496 | 0 | case CK_BaseToDerivedMemberPointer: |
497 | 0 | case CK_DerivedToBaseMemberPointer: |
498 | 0 | case CK_MemberPointerToBoolean: |
499 | 0 | case CK_ReinterpretMemberPointer: |
500 | 0 | case CK_ConstructorConversion: |
501 | 0 | case CK_IntegralToPointer: |
502 | 0 | case CK_PointerToIntegral: |
503 | 0 | case CK_PointerToBoolean: |
504 | 0 | case CK_ToVoid: |
505 | 0 | case CK_VectorSplat: |
506 | 0 | case CK_IntegralCast: |
507 | 0 | case CK_BooleanToSignedIntegral: |
508 | 0 | case CK_IntegralToBoolean: |
509 | 0 | case CK_IntegralToFloating: |
510 | 0 | case CK_FloatingToIntegral: |
511 | 0 | case CK_FloatingToBoolean: |
512 | 0 | case CK_FloatingCast: |
513 | 0 | case CK_CPointerToObjCPointerCast: |
514 | 0 | case CK_BlockPointerToObjCPointerCast: |
515 | 0 | case CK_AnyPointerToBlockPointerCast: |
516 | 0 | case CK_ObjCObjectLValueCast: |
517 | 0 | case CK_FloatingComplexToReal: |
518 | 0 | case CK_FloatingComplexToBoolean: |
519 | 0 | case CK_IntegralComplexToReal: |
520 | 0 | case CK_IntegralComplexToBoolean: |
521 | 0 | case CK_ARCProduceObject: |
522 | 0 | case CK_ARCConsumeObject: |
523 | 0 | case CK_ARCReclaimReturnedObject: |
524 | 0 | case CK_ARCExtendBlockObject: |
525 | 0 | case CK_CopyAndAutoreleaseBlockObject: |
526 | 0 | case CK_BuiltinFnToFnPtr: |
527 | 0 | case CK_ZeroToOCLOpaqueType: |
528 | 0 | case CK_AddressSpaceConversion: |
529 | 0 | case CK_IntToOCLSampler: |
530 | 0 | case CK_FloatingToFixedPoint: |
531 | 0 | case CK_FixedPointToFloating: |
532 | 0 | case CK_FixedPointCast: |
533 | 0 | case CK_FixedPointToBoolean: |
534 | 0 | case CK_FixedPointToIntegral: |
535 | 0 | case CK_IntegralToFixedPoint: |
536 | 0 | case CK_MatrixCast: |
537 | 0 | llvm_unreachable("invalid cast kind for complex value"); |
538 | |
|
539 | 540 | case CK_FloatingRealToComplex: |
540 | 645 | case CK_IntegralRealToComplex: { |
541 | 645 | CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Op); |
542 | 645 | return EmitScalarToComplexCast(CGF.EmitScalarExpr(Op), Op->getType(), |
543 | 645 | DestTy, Op->getExprLoc()); |
544 | 540 | } |
545 | | |
546 | 51 | case CK_FloatingComplexCast: |
547 | 79 | case CK_FloatingComplexToIntegralComplex: |
548 | 147 | case CK_IntegralComplexCast: |
549 | 164 | case CK_IntegralComplexToFloatingComplex: { |
550 | 164 | CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Op); |
551 | 164 | return EmitComplexToComplexCast(Visit(Op), Op->getType(), DestTy, |
552 | 164 | Op->getExprLoc()); |
553 | 147 | } |
554 | 2.08k | } |
555 | | |
556 | 0 | llvm_unreachable("unknown cast resulting in complex value"); |
557 | 0 | } |
558 | | |
559 | 3 | ComplexPairTy ComplexExprEmitter::VisitUnaryMinus(const UnaryOperator *E) { |
560 | 3 | TestAndClearIgnoreReal(); |
561 | 3 | TestAndClearIgnoreImag(); |
562 | 3 | ComplexPairTy Op = Visit(E->getSubExpr()); |
563 | | |
564 | 3 | llvm::Value *ResR, *ResI; |
565 | 3 | if (Op.first->getType()->isFloatingPointTy()) { |
566 | 2 | ResR = Builder.CreateFNeg(Op.first, "neg.r"); |
567 | 2 | ResI = Builder.CreateFNeg(Op.second, "neg.i"); |
568 | 2 | } else { |
569 | 1 | ResR = Builder.CreateNeg(Op.first, "neg.r"); |
570 | 1 | ResI = Builder.CreateNeg(Op.second, "neg.i"); |
571 | 1 | } |
572 | 3 | return ComplexPairTy(ResR, ResI); |
573 | 3 | } |
574 | | |
575 | 3 | ComplexPairTy ComplexExprEmitter::VisitUnaryNot(const UnaryOperator *E) { |
576 | 3 | TestAndClearIgnoreReal(); |
577 | 3 | TestAndClearIgnoreImag(); |
578 | | // ~(a+ib) = a + i*-b |
579 | 3 | ComplexPairTy Op = Visit(E->getSubExpr()); |
580 | 3 | llvm::Value *ResI; |
581 | 3 | if (Op.second->getType()->isFloatingPointTy()) |
582 | 2 | ResI = Builder.CreateFNeg(Op.second, "conj.i"); |
583 | 1 | else |
584 | 1 | ResI = Builder.CreateNeg(Op.second, "conj.i"); |
585 | | |
586 | 3 | return ComplexPairTy(Op.first, ResI); |
587 | 3 | } |
588 | | |
589 | 273 | ComplexPairTy ComplexExprEmitter::EmitBinAdd(const BinOpInfo &Op) { |
590 | 273 | llvm::Value *ResR, *ResI; |
591 | | |
592 | 273 | if (Op.LHS.first->getType()->isFloatingPointTy()) { |
593 | 187 | ResR = Builder.CreateFAdd(Op.LHS.first, Op.RHS.first, "add.r"); |
594 | 187 | if (Op.LHS.second && Op.RHS.second120 ) |
595 | 87 | ResI = Builder.CreateFAdd(Op.LHS.second, Op.RHS.second, "add.i"); |
596 | 100 | else |
597 | 100 | ResI = Op.LHS.second ? Op.LHS.second33 : Op.RHS.second67 ; |
598 | 187 | assert(ResI && "Only one operand may be real!"); |
599 | 187 | } else { |
600 | 86 | ResR = Builder.CreateAdd(Op.LHS.first, Op.RHS.first, "add.r"); |
601 | 86 | assert(Op.LHS.second && Op.RHS.second && |
602 | 86 | "Both operands of integer complex operators must be complex!"); |
603 | 0 | ResI = Builder.CreateAdd(Op.LHS.second, Op.RHS.second, "add.i"); |
604 | 86 | } |
605 | 0 | return ComplexPairTy(ResR, ResI); |
606 | 273 | } |
607 | | |
608 | 119 | ComplexPairTy ComplexExprEmitter::EmitBinSub(const BinOpInfo &Op) { |
609 | 119 | llvm::Value *ResR, *ResI; |
610 | 119 | if (Op.LHS.first->getType()->isFloatingPointTy()) { |
611 | 106 | ResR = Builder.CreateFSub(Op.LHS.first, Op.RHS.first, "sub.r"); |
612 | 106 | if (Op.LHS.second && Op.RHS.second71 ) |
613 | 42 | ResI = Builder.CreateFSub(Op.LHS.second, Op.RHS.second, "sub.i"); |
614 | 64 | else |
615 | 64 | ResI = Op.LHS.second ? Op.LHS.second29 |
616 | 64 | : Builder.CreateFNeg(Op.RHS.second, "sub.i")35 ; |
617 | 106 | assert(ResI && "Only one operand may be real!"); |
618 | 106 | } else { |
619 | 13 | ResR = Builder.CreateSub(Op.LHS.first, Op.RHS.first, "sub.r"); |
620 | 13 | assert(Op.LHS.second && Op.RHS.second && |
621 | 13 | "Both operands of integer complex operators must be complex!"); |
622 | 0 | ResI = Builder.CreateSub(Op.LHS.second, Op.RHS.second, "sub.i"); |
623 | 13 | } |
624 | 0 | return ComplexPairTy(ResR, ResI); |
625 | 119 | } |
626 | | |
627 | | /// Emit a libcall for a binary operation on complex types. |
628 | | ComplexPairTy ComplexExprEmitter::EmitComplexBinOpLibCall(StringRef LibCallName, |
629 | 196 | const BinOpInfo &Op) { |
630 | 196 | CallArgList Args; |
631 | 196 | Args.add(RValue::get(Op.LHS.first), |
632 | 196 | Op.Ty->castAs<ComplexType>()->getElementType()); |
633 | 196 | Args.add(RValue::get(Op.LHS.second), |
634 | 196 | Op.Ty->castAs<ComplexType>()->getElementType()); |
635 | 196 | Args.add(RValue::get(Op.RHS.first), |
636 | 196 | Op.Ty->castAs<ComplexType>()->getElementType()); |
637 | 196 | Args.add(RValue::get(Op.RHS.second), |
638 | 196 | Op.Ty->castAs<ComplexType>()->getElementType()); |
639 | | |
640 | | // We *must* use the full CG function call building logic here because the |
641 | | // complex type has special ABI handling. We also should not forget about |
642 | | // special calling convention which may be used for compiler builtins. |
643 | | |
644 | | // We create a function qualified type to state that this call does not have |
645 | | // any exceptions. |
646 | 196 | FunctionProtoType::ExtProtoInfo EPI; |
647 | 196 | EPI = EPI.withExceptionSpec( |
648 | 196 | FunctionProtoType::ExceptionSpecInfo(EST_BasicNoexcept)); |
649 | 196 | SmallVector<QualType, 4> ArgsQTys( |
650 | 196 | 4, Op.Ty->castAs<ComplexType>()->getElementType()); |
651 | 196 | QualType FQTy = CGF.getContext().getFunctionType(Op.Ty, ArgsQTys, EPI); |
652 | 196 | const CGFunctionInfo &FuncInfo = CGF.CGM.getTypes().arrangeFreeFunctionCall( |
653 | 196 | Args, cast<FunctionType>(FQTy.getTypePtr()), false); |
654 | | |
655 | 196 | llvm::FunctionType *FTy = CGF.CGM.getTypes().GetFunctionType(FuncInfo); |
656 | 196 | llvm::FunctionCallee Func = CGF.CGM.CreateRuntimeFunction( |
657 | 196 | FTy, LibCallName, llvm::AttributeList(), true); |
658 | 196 | CGCallee Callee = CGCallee::forDirect(Func, FQTy->getAs<FunctionProtoType>()); |
659 | | |
660 | 196 | llvm::CallBase *Call; |
661 | 196 | RValue Res = CGF.EmitCall(FuncInfo, Callee, ReturnValueSlot(), Args, &Call); |
662 | 196 | Call->setCallingConv(CGF.CGM.getRuntimeCC()); |
663 | 196 | return Res.getComplexVal(); |
664 | 196 | } |
665 | | |
666 | | /// Lookup the libcall name for a given floating point type complex |
667 | | /// multiply. |
668 | 125 | static StringRef getComplexMultiplyLibCallName(llvm::Type *Ty) { |
669 | 125 | switch (Ty->getTypeID()) { |
670 | 0 | default: |
671 | 0 | llvm_unreachable("Unsupported floating point type!"); |
672 | 2 | case llvm::Type::HalfTyID: |
673 | 2 | return "__mulhc3"; |
674 | 39 | case llvm::Type::FloatTyID: |
675 | 39 | return "__mulsc3"; |
676 | 72 | case llvm::Type::DoubleTyID: |
677 | 72 | return "__muldc3"; |
678 | 1 | case llvm::Type::PPC_FP128TyID: |
679 | 1 | return "__multc3"; |
680 | 8 | case llvm::Type::X86_FP80TyID: |
681 | 8 | return "__mulxc3"; |
682 | 3 | case llvm::Type::FP128TyID: |
683 | 3 | return "__multc3"; |
684 | 125 | } |
685 | 125 | } |
686 | | |
687 | | // See C11 Annex G.5.1 for the semantics of multiplicative operators on complex |
688 | | // typed values. |
689 | 192 | ComplexPairTy ComplexExprEmitter::EmitBinMul(const BinOpInfo &Op) { |
690 | 192 | using llvm::Value; |
691 | 192 | Value *ResR, *ResI; |
692 | 192 | llvm::MDBuilder MDHelper(CGF.getLLVMContext()); |
693 | | |
694 | 192 | if (Op.LHS.first->getType()->isFloatingPointTy()) { |
695 | | // The general formulation is: |
696 | | // (a + ib) * (c + id) = (a * c - b * d) + i(a * d + b * c) |
697 | | // |
698 | | // But we can fold away components which would be zero due to a real |
699 | | // operand according to C11 Annex G.5.1p2. |
700 | | // FIXME: C11 also provides for imaginary types which would allow folding |
701 | | // still more of this within the type system. |
702 | | |
703 | 191 | if (Op.LHS.second && Op.RHS.second154 ) { |
704 | | // If both operands are complex, emit the core math directly, and then |
705 | | // test for NaNs. If we find NaNs in the result, we delegate to a libcall |
706 | | // to carefully re-compute the correct infinity representation if |
707 | | // possible. The expectation is that the presence of NaNs here is |
708 | | // *extremely* rare, and so the cost of the libcall is almost irrelevant. |
709 | | // This is good, because the libcall re-computes the core multiplication |
710 | | // exactly the same as we do here and re-tests for NaNs in order to be |
711 | | // a generic complex*complex libcall. |
712 | | |
713 | | // First compute the four products. |
714 | 125 | Value *AC = Builder.CreateFMul(Op.LHS.first, Op.RHS.first, "mul_ac"); |
715 | 125 | Value *BD = Builder.CreateFMul(Op.LHS.second, Op.RHS.second, "mul_bd"); |
716 | 125 | Value *AD = Builder.CreateFMul(Op.LHS.first, Op.RHS.second, "mul_ad"); |
717 | 125 | Value *BC = Builder.CreateFMul(Op.LHS.second, Op.RHS.first, "mul_bc"); |
718 | | |
719 | | // The real part is the difference of the first two, the imaginary part is |
720 | | // the sum of the second. |
721 | 125 | ResR = Builder.CreateFSub(AC, BD, "mul_r"); |
722 | 125 | ResI = Builder.CreateFAdd(AD, BC, "mul_i"); |
723 | | |
724 | | // Emit the test for the real part becoming NaN and create a branch to |
725 | | // handle it. We test for NaN by comparing the number to itself. |
726 | 125 | Value *IsRNaN = Builder.CreateFCmpUNO(ResR, ResR, "isnan_cmp"); |
727 | 125 | llvm::BasicBlock *ContBB = CGF.createBasicBlock("complex_mul_cont"); |
728 | 125 | llvm::BasicBlock *INaNBB = CGF.createBasicBlock("complex_mul_imag_nan"); |
729 | 125 | llvm::Instruction *Branch = Builder.CreateCondBr(IsRNaN, INaNBB, ContBB); |
730 | 125 | llvm::BasicBlock *OrigBB = Branch->getParent(); |
731 | | |
732 | | // Give hint that we very much don't expect to see NaNs. |
733 | | // Value chosen to match UR_NONTAKEN_WEIGHT, see BranchProbabilityInfo.cpp |
734 | 125 | llvm::MDNode *BrWeight = MDHelper.createBranchWeights(1, (1U << 20) - 1); |
735 | 125 | Branch->setMetadata(llvm::LLVMContext::MD_prof, BrWeight); |
736 | | |
737 | | // Now test the imaginary part and create its branch. |
738 | 125 | CGF.EmitBlock(INaNBB); |
739 | 125 | Value *IsINaN = Builder.CreateFCmpUNO(ResI, ResI, "isnan_cmp"); |
740 | 125 | llvm::BasicBlock *LibCallBB = CGF.createBasicBlock("complex_mul_libcall"); |
741 | 125 | Branch = Builder.CreateCondBr(IsINaN, LibCallBB, ContBB); |
742 | 125 | Branch->setMetadata(llvm::LLVMContext::MD_prof, BrWeight); |
743 | | |
744 | | // Now emit the libcall on this slowest of the slow paths. |
745 | 125 | CGF.EmitBlock(LibCallBB); |
746 | 125 | Value *LibCallR, *LibCallI; |
747 | 125 | std::tie(LibCallR, LibCallI) = EmitComplexBinOpLibCall( |
748 | 125 | getComplexMultiplyLibCallName(Op.LHS.first->getType()), Op); |
749 | 125 | Builder.CreateBr(ContBB); |
750 | | |
751 | | // Finally continue execution by phi-ing together the different |
752 | | // computation paths. |
753 | 125 | CGF.EmitBlock(ContBB); |
754 | 125 | llvm::PHINode *RealPHI = Builder.CreatePHI(ResR->getType(), 3, "real_mul_phi"); |
755 | 125 | RealPHI->addIncoming(ResR, OrigBB); |
756 | 125 | RealPHI->addIncoming(ResR, INaNBB); |
757 | 125 | RealPHI->addIncoming(LibCallR, LibCallBB); |
758 | 125 | llvm::PHINode *ImagPHI = Builder.CreatePHI(ResI->getType(), 3, "imag_mul_phi"); |
759 | 125 | ImagPHI->addIncoming(ResI, OrigBB); |
760 | 125 | ImagPHI->addIncoming(ResI, INaNBB); |
761 | 125 | ImagPHI->addIncoming(LibCallI, LibCallBB); |
762 | 125 | return ComplexPairTy(RealPHI, ImagPHI); |
763 | 125 | } |
764 | 66 | assert((Op.LHS.second || Op.RHS.second) && |
765 | 66 | "At least one operand must be complex!"); |
766 | | |
767 | | // If either of the operands is a real rather than a complex, the |
768 | | // imaginary component is ignored when computing the real component of the |
769 | | // result. |
770 | 0 | ResR = Builder.CreateFMul(Op.LHS.first, Op.RHS.first, "mul.rl"); |
771 | | |
772 | 66 | ResI = Op.LHS.second |
773 | 66 | ? Builder.CreateFMul(Op.LHS.second, Op.RHS.first, "mul.il")29 |
774 | 66 | : Builder.CreateFMul(Op.LHS.first, Op.RHS.second, "mul.ir")37 ; |
775 | 66 | } else { |
776 | 1 | assert(Op.LHS.second && Op.RHS.second && |
777 | 1 | "Both operands of integer complex operators must be complex!"); |
778 | 0 | Value *ResRl = Builder.CreateMul(Op.LHS.first, Op.RHS.first, "mul.rl"); |
779 | 1 | Value *ResRr = Builder.CreateMul(Op.LHS.second, Op.RHS.second, "mul.rr"); |
780 | 1 | ResR = Builder.CreateSub(ResRl, ResRr, "mul.r"); |
781 | | |
782 | 1 | Value *ResIl = Builder.CreateMul(Op.LHS.second, Op.RHS.first, "mul.il"); |
783 | 1 | Value *ResIr = Builder.CreateMul(Op.LHS.first, Op.RHS.second, "mul.ir"); |
784 | 1 | ResI = Builder.CreateAdd(ResIl, ResIr, "mul.i"); |
785 | 1 | } |
786 | 67 | return ComplexPairTy(ResR, ResI); |
787 | 192 | } |
788 | | |
789 | | // See C11 Annex G.5.1 for the semantics of multiplicative operators on complex |
790 | | // typed values. |
791 | 121 | ComplexPairTy ComplexExprEmitter::EmitBinDiv(const BinOpInfo &Op) { |
792 | 121 | llvm::Value *LHSr = Op.LHS.first, *LHSi = Op.LHS.second; |
793 | 121 | llvm::Value *RHSr = Op.RHS.first, *RHSi = Op.RHS.second; |
794 | | |
795 | 121 | llvm::Value *DSTr, *DSTi; |
796 | 121 | if (LHSr->getType()->isFloatingPointTy()) { |
797 | | // If we have a complex operand on the RHS and FastMath is not allowed, we |
798 | | // delegate to a libcall to handle all of the complexities and minimize |
799 | | // underflow/overflow cases. When FastMath is allowed we construct the |
800 | | // divide inline using the same algorithm as for integer operands. |
801 | | // |
802 | | // FIXME: We would be able to avoid the libcall in many places if we |
803 | | // supported imaginary types in addition to complex types. |
804 | 108 | if (RHSi && !CGF.getLangOpts().FastMath77 ) { |
805 | 71 | BinOpInfo LibCallOp = Op; |
806 | | // If LHS was a real, supply a null imaginary part. |
807 | 71 | if (!LHSi) |
808 | 26 | LibCallOp.LHS.second = llvm::Constant::getNullValue(LHSr->getType()); |
809 | | |
810 | 71 | switch (LHSr->getType()->getTypeID()) { |
811 | 0 | default: |
812 | 0 | llvm_unreachable("Unsupported floating point type!"); |
813 | 4 | case llvm::Type::HalfTyID: |
814 | 4 | return EmitComplexBinOpLibCall("__divhc3", LibCallOp); |
815 | 30 | case llvm::Type::FloatTyID: |
816 | 30 | return EmitComplexBinOpLibCall("__divsc3", LibCallOp); |
817 | 28 | case llvm::Type::DoubleTyID: |
818 | 28 | return EmitComplexBinOpLibCall("__divdc3", LibCallOp); |
819 | 2 | case llvm::Type::PPC_FP128TyID: |
820 | 2 | return EmitComplexBinOpLibCall("__divtc3", LibCallOp); |
821 | 6 | case llvm::Type::X86_FP80TyID: |
822 | 6 | return EmitComplexBinOpLibCall("__divxc3", LibCallOp); |
823 | 1 | case llvm::Type::FP128TyID: |
824 | 1 | return EmitComplexBinOpLibCall("__divtc3", LibCallOp); |
825 | 71 | } |
826 | 71 | } else if (37 RHSi37 ) { |
827 | 6 | if (!LHSi) |
828 | 3 | LHSi = llvm::Constant::getNullValue(RHSi->getType()); |
829 | | |
830 | | // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd)) |
831 | 6 | llvm::Value *AC = Builder.CreateFMul(LHSr, RHSr); // a*c |
832 | 6 | llvm::Value *BD = Builder.CreateFMul(LHSi, RHSi); // b*d |
833 | 6 | llvm::Value *ACpBD = Builder.CreateFAdd(AC, BD); // ac+bd |
834 | | |
835 | 6 | llvm::Value *CC = Builder.CreateFMul(RHSr, RHSr); // c*c |
836 | 6 | llvm::Value *DD = Builder.CreateFMul(RHSi, RHSi); // d*d |
837 | 6 | llvm::Value *CCpDD = Builder.CreateFAdd(CC, DD); // cc+dd |
838 | | |
839 | 6 | llvm::Value *BC = Builder.CreateFMul(LHSi, RHSr); // b*c |
840 | 6 | llvm::Value *AD = Builder.CreateFMul(LHSr, RHSi); // a*d |
841 | 6 | llvm::Value *BCmAD = Builder.CreateFSub(BC, AD); // bc-ad |
842 | | |
843 | 6 | DSTr = Builder.CreateFDiv(ACpBD, CCpDD); |
844 | 6 | DSTi = Builder.CreateFDiv(BCmAD, CCpDD); |
845 | 31 | } else { |
846 | 31 | assert(LHSi && "Can have at most one non-complex operand!"); |
847 | | |
848 | 0 | DSTr = Builder.CreateFDiv(LHSr, RHSr); |
849 | 31 | DSTi = Builder.CreateFDiv(LHSi, RHSr); |
850 | 31 | } |
851 | 108 | } else { |
852 | 13 | assert(Op.LHS.second && Op.RHS.second && |
853 | 13 | "Both operands of integer complex operators must be complex!"); |
854 | | // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd)) |
855 | 0 | llvm::Value *Tmp1 = Builder.CreateMul(LHSr, RHSr); // a*c |
856 | 13 | llvm::Value *Tmp2 = Builder.CreateMul(LHSi, RHSi); // b*d |
857 | 13 | llvm::Value *Tmp3 = Builder.CreateAdd(Tmp1, Tmp2); // ac+bd |
858 | | |
859 | 13 | llvm::Value *Tmp4 = Builder.CreateMul(RHSr, RHSr); // c*c |
860 | 13 | llvm::Value *Tmp5 = Builder.CreateMul(RHSi, RHSi); // d*d |
861 | 13 | llvm::Value *Tmp6 = Builder.CreateAdd(Tmp4, Tmp5); // cc+dd |
862 | | |
863 | 13 | llvm::Value *Tmp7 = Builder.CreateMul(LHSi, RHSr); // b*c |
864 | 13 | llvm::Value *Tmp8 = Builder.CreateMul(LHSr, RHSi); // a*d |
865 | 13 | llvm::Value *Tmp9 = Builder.CreateSub(Tmp7, Tmp8); // bc-ad |
866 | | |
867 | 13 | if (Op.Ty->castAs<ComplexType>()->getElementType()->isUnsignedIntegerType()) { |
868 | 0 | DSTr = Builder.CreateUDiv(Tmp3, Tmp6); |
869 | 0 | DSTi = Builder.CreateUDiv(Tmp9, Tmp6); |
870 | 13 | } else { |
871 | 13 | DSTr = Builder.CreateSDiv(Tmp3, Tmp6); |
872 | 13 | DSTi = Builder.CreateSDiv(Tmp9, Tmp6); |
873 | 13 | } |
874 | 13 | } |
875 | | |
876 | 50 | return ComplexPairTy(DSTr, DSTi); |
877 | 121 | } |
878 | | |
879 | | ComplexExprEmitter::BinOpInfo |
880 | 622 | ComplexExprEmitter::EmitBinOps(const BinaryOperator *E) { |
881 | 622 | TestAndClearIgnoreReal(); |
882 | 622 | TestAndClearIgnoreImag(); |
883 | 622 | BinOpInfo Ops; |
884 | 622 | if (E->getLHS()->getType()->isRealFloatingType()) |
885 | 165 | Ops.LHS = ComplexPairTy(CGF.EmitScalarExpr(E->getLHS()), nullptr); |
886 | 457 | else |
887 | 457 | Ops.LHS = Visit(E->getLHS()); |
888 | 622 | if (E->getRHS()->getType()->isRealFloatingType()) |
889 | 119 | Ops.RHS = ComplexPairTy(CGF.EmitScalarExpr(E->getRHS()), nullptr); |
890 | 503 | else |
891 | 503 | Ops.RHS = Visit(E->getRHS()); |
892 | | |
893 | 622 | Ops.Ty = E->getType(); |
894 | 622 | return Ops; |
895 | 622 | } |
896 | | |
897 | | |
898 | | LValue ComplexExprEmitter:: |
899 | | EmitCompoundAssignLValue(const CompoundAssignOperator *E, |
900 | | ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&), |
901 | 83 | RValue &Val) { |
902 | 83 | TestAndClearIgnoreReal(); |
903 | 83 | TestAndClearIgnoreImag(); |
904 | 83 | QualType LHSTy = E->getLHS()->getType(); |
905 | 83 | if (const AtomicType *AT = LHSTy->getAs<AtomicType>()) |
906 | 2 | LHSTy = AT->getValueType(); |
907 | | |
908 | 83 | CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, E); |
909 | 83 | BinOpInfo OpInfo; |
910 | | |
911 | | // Load the RHS and LHS operands. |
912 | | // __block variables need to have the rhs evaluated first, plus this should |
913 | | // improve codegen a little. |
914 | 83 | OpInfo.Ty = E->getComputationResultType(); |
915 | 83 | QualType ComplexElementTy = cast<ComplexType>(OpInfo.Ty)->getElementType(); |
916 | | |
917 | | // The RHS should have been converted to the computation type. |
918 | 83 | if (E->getRHS()->getType()->isRealFloatingType()) { |
919 | 3 | assert( |
920 | 3 | CGF.getContext() |
921 | 3 | .hasSameUnqualifiedType(ComplexElementTy, E->getRHS()->getType())); |
922 | 0 | OpInfo.RHS = ComplexPairTy(CGF.EmitScalarExpr(E->getRHS()), nullptr); |
923 | 80 | } else { |
924 | 80 | assert(CGF.getContext() |
925 | 80 | .hasSameUnqualifiedType(OpInfo.Ty, E->getRHS()->getType())); |
926 | 0 | OpInfo.RHS = Visit(E->getRHS()); |
927 | 80 | } |
928 | | |
929 | 0 | LValue LHS = CGF.EmitLValue(E->getLHS()); |
930 | | |
931 | | // Load from the l-value and convert it. |
932 | 83 | SourceLocation Loc = E->getExprLoc(); |
933 | 83 | if (LHSTy->isAnyComplexType()) { |
934 | 79 | ComplexPairTy LHSVal = EmitLoadOfLValue(LHS, Loc); |
935 | 79 | OpInfo.LHS = EmitComplexToComplexCast(LHSVal, LHSTy, OpInfo.Ty, Loc); |
936 | 79 | } else { |
937 | 4 | llvm::Value *LHSVal = CGF.EmitLoadOfScalar(LHS, Loc); |
938 | | // For floating point real operands we can directly pass the scalar form |
939 | | // to the binary operator emission and potentially get more efficient code. |
940 | 4 | if (LHSTy->isRealFloatingType()) { |
941 | 3 | if (!CGF.getContext().hasSameUnqualifiedType(ComplexElementTy, LHSTy)) |
942 | 0 | LHSVal = CGF.EmitScalarConversion(LHSVal, LHSTy, ComplexElementTy, Loc); |
943 | 3 | OpInfo.LHS = ComplexPairTy(LHSVal, nullptr); |
944 | 3 | } else { |
945 | 1 | OpInfo.LHS = EmitScalarToComplexCast(LHSVal, LHSTy, OpInfo.Ty, Loc); |
946 | 1 | } |
947 | 4 | } |
948 | | |
949 | | // Expand the binary operator. |
950 | 83 | ComplexPairTy Result = (this->*Func)(OpInfo); |
951 | | |
952 | | // Truncate the result and store it into the LHS lvalue. |
953 | 83 | if (LHSTy->isAnyComplexType()) { |
954 | 79 | ComplexPairTy ResVal = |
955 | 79 | EmitComplexToComplexCast(Result, OpInfo.Ty, LHSTy, Loc); |
956 | 79 | EmitStoreOfComplex(ResVal, LHS, /*isInit*/ false); |
957 | 79 | Val = RValue::getComplex(ResVal); |
958 | 79 | } else { |
959 | 4 | llvm::Value *ResVal = |
960 | 4 | CGF.EmitComplexToScalarConversion(Result, OpInfo.Ty, LHSTy, Loc); |
961 | 4 | CGF.EmitStoreOfScalar(ResVal, LHS, /*isInit*/ false); |
962 | 4 | Val = RValue::get(ResVal); |
963 | 4 | } |
964 | | |
965 | 83 | return LHS; |
966 | 83 | } |
967 | | |
968 | | // Compound assignments. |
969 | | ComplexPairTy ComplexExprEmitter:: |
970 | | EmitCompoundAssign(const CompoundAssignOperator *E, |
971 | 15 | ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&)){ |
972 | 15 | RValue Val; |
973 | 15 | LValue LV = EmitCompoundAssignLValue(E, Func, Val); |
974 | | |
975 | | // The result of an assignment in C is the assigned r-value. |
976 | 15 | if (!CGF.getLangOpts().CPlusPlus) |
977 | 13 | return Val.getComplexVal(); |
978 | | |
979 | | // If the lvalue is non-volatile, return the computed value of the assignment. |
980 | 2 | if (!LV.isVolatileQualified()) |
981 | 0 | return Val.getComplexVal(); |
982 | | |
983 | 2 | return EmitLoadOfLValue(LV, E->getExprLoc()); |
984 | 2 | } |
985 | | |
986 | | LValue ComplexExprEmitter::EmitBinAssignLValue(const BinaryOperator *E, |
987 | 206 | ComplexPairTy &Val) { |
988 | 206 | assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(), |
989 | 206 | E->getRHS()->getType()) && |
990 | 206 | "Invalid assignment"); |
991 | 0 | TestAndClearIgnoreReal(); |
992 | 206 | TestAndClearIgnoreImag(); |
993 | | |
994 | | // Emit the RHS. __block variables need the RHS evaluated first. |
995 | 206 | Val = Visit(E->getRHS()); |
996 | | |
997 | | // Compute the address to store into. |
998 | 206 | LValue LHS = CGF.EmitLValue(E->getLHS()); |
999 | | |
1000 | | // Store the result value into the LHS lvalue. |
1001 | 206 | EmitStoreOfComplex(Val, LHS, /*isInit*/ false); |
1002 | | |
1003 | 206 | return LHS; |
1004 | 206 | } |
1005 | | |
1006 | 175 | ComplexPairTy ComplexExprEmitter::VisitBinAssign(const BinaryOperator *E) { |
1007 | 175 | ComplexPairTy Val; |
1008 | 175 | LValue LV = EmitBinAssignLValue(E, Val); |
1009 | | |
1010 | | // The result of an assignment in C is the assigned r-value. |
1011 | 175 | if (!CGF.getLangOpts().CPlusPlus) |
1012 | 169 | return Val; |
1013 | | |
1014 | | // If the lvalue is non-volatile, return the computed value of the assignment. |
1015 | 6 | if (!LV.isVolatileQualified()) |
1016 | 0 | return Val; |
1017 | | |
1018 | 6 | return EmitLoadOfLValue(LV, E->getExprLoc()); |
1019 | 6 | } |
1020 | | |
1021 | 0 | ComplexPairTy ComplexExprEmitter::VisitBinComma(const BinaryOperator *E) { |
1022 | 0 | CGF.EmitIgnoredExpr(E->getLHS()); |
1023 | 0 | return Visit(E->getRHS()); |
1024 | 0 | } |
1025 | | |
1026 | | ComplexPairTy ComplexExprEmitter:: |
1027 | 11 | VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) { |
1028 | 11 | TestAndClearIgnoreReal(); |
1029 | 11 | TestAndClearIgnoreImag(); |
1030 | 11 | llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); |
1031 | 11 | llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); |
1032 | 11 | llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); |
1033 | | |
1034 | | // Bind the common expression if necessary. |
1035 | 11 | CodeGenFunction::OpaqueValueMapping binding(CGF, E); |
1036 | | |
1037 | | |
1038 | 11 | CodeGenFunction::ConditionalEvaluation eval(CGF); |
1039 | 11 | CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock, |
1040 | 11 | CGF.getProfileCount(E)); |
1041 | | |
1042 | 11 | eval.begin(CGF); |
1043 | 11 | CGF.EmitBlock(LHSBlock); |
1044 | 11 | CGF.incrementProfileCounter(E); |
1045 | 11 | ComplexPairTy LHS = Visit(E->getTrueExpr()); |
1046 | 11 | LHSBlock = Builder.GetInsertBlock(); |
1047 | 11 | CGF.EmitBranch(ContBlock); |
1048 | 11 | eval.end(CGF); |
1049 | | |
1050 | 11 | eval.begin(CGF); |
1051 | 11 | CGF.EmitBlock(RHSBlock); |
1052 | 11 | ComplexPairTy RHS = Visit(E->getFalseExpr()); |
1053 | 11 | RHSBlock = Builder.GetInsertBlock(); |
1054 | 11 | CGF.EmitBlock(ContBlock); |
1055 | 11 | eval.end(CGF); |
1056 | | |
1057 | | // Create a PHI node for the real part. |
1058 | 11 | llvm::PHINode *RealPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.r"); |
1059 | 11 | RealPN->addIncoming(LHS.first, LHSBlock); |
1060 | 11 | RealPN->addIncoming(RHS.first, RHSBlock); |
1061 | | |
1062 | | // Create a PHI node for the imaginary part. |
1063 | 11 | llvm::PHINode *ImagPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.i"); |
1064 | 11 | ImagPN->addIncoming(LHS.second, LHSBlock); |
1065 | 11 | ImagPN->addIncoming(RHS.second, RHSBlock); |
1066 | | |
1067 | 11 | return ComplexPairTy(RealPN, ImagPN); |
1068 | 11 | } |
1069 | | |
1070 | 0 | ComplexPairTy ComplexExprEmitter::VisitChooseExpr(ChooseExpr *E) { |
1071 | 0 | return Visit(E->getChosenSubExpr()); |
1072 | 0 | } |
1073 | | |
1074 | 28 | ComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) { |
1075 | 28 | bool Ignore = TestAndClearIgnoreReal(); |
1076 | 28 | (void)Ignore; |
1077 | 28 | assert (Ignore == false && "init list ignored"); |
1078 | 0 | Ignore = TestAndClearIgnoreImag(); |
1079 | 28 | (void)Ignore; |
1080 | 28 | assert (Ignore == false && "init list ignored"); |
1081 | | |
1082 | 28 | if (E->getNumInits() == 2) { |
1083 | 14 | llvm::Value *Real = CGF.EmitScalarExpr(E->getInit(0)); |
1084 | 14 | llvm::Value *Imag = CGF.EmitScalarExpr(E->getInit(1)); |
1085 | 14 | return ComplexPairTy(Real, Imag); |
1086 | 14 | } else if (E->getNumInits() == 1) { |
1087 | 2 | return Visit(E->getInit(0)); |
1088 | 2 | } |
1089 | | |
1090 | | // Empty init list initializes to null |
1091 | 12 | assert(E->getNumInits() == 0 && "Unexpected number of inits"); |
1092 | 0 | QualType Ty = E->getType()->castAs<ComplexType>()->getElementType(); |
1093 | 12 | llvm::Type* LTy = CGF.ConvertType(Ty); |
1094 | 12 | llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy); |
1095 | 12 | return ComplexPairTy(zeroConstant, zeroConstant); |
1096 | 28 | } |
1097 | | |
1098 | 22 | ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) { |
1099 | 22 | Address ArgValue = Address::invalid(); |
1100 | 22 | Address ArgPtr = CGF.EmitVAArg(E, ArgValue); |
1101 | | |
1102 | 22 | if (!ArgPtr.isValid()) { |
1103 | 0 | CGF.ErrorUnsupported(E, "complex va_arg expression"); |
1104 | 0 | llvm::Type *EltTy = |
1105 | 0 | CGF.ConvertType(E->getType()->castAs<ComplexType>()->getElementType()); |
1106 | 0 | llvm::Value *U = llvm::UndefValue::get(EltTy); |
1107 | 0 | return ComplexPairTy(U, U); |
1108 | 0 | } |
1109 | | |
1110 | 22 | return EmitLoadOfLValue(CGF.MakeAddrLValue(ArgPtr, E->getType()), |
1111 | 22 | E->getExprLoc()); |
1112 | 22 | } |
1113 | | |
1114 | | //===----------------------------------------------------------------------===// |
1115 | | // Entry Point into this File |
1116 | | //===----------------------------------------------------------------------===// |
1117 | | |
1118 | | /// EmitComplexExpr - Emit the computation of the specified expression of |
1119 | | /// complex type, ignoring the result. |
1120 | | ComplexPairTy CodeGenFunction::EmitComplexExpr(const Expr *E, bool IgnoreReal, |
1121 | 1.30k | bool IgnoreImag) { |
1122 | 1.30k | assert(E && getComplexType(E->getType()) && |
1123 | 1.30k | "Invalid complex expression to emit"); |
1124 | | |
1125 | 0 | return ComplexExprEmitter(*this, IgnoreReal, IgnoreImag) |
1126 | 1.30k | .Visit(const_cast<Expr *>(E)); |
1127 | 1.30k | } |
1128 | | |
1129 | | void CodeGenFunction::EmitComplexExprIntoLValue(const Expr *E, LValue dest, |
1130 | 728 | bool isInit) { |
1131 | 728 | assert(E && getComplexType(E->getType()) && |
1132 | 728 | "Invalid complex expression to emit"); |
1133 | 0 | ComplexExprEmitter Emitter(*this); |
1134 | 728 | ComplexPairTy Val = Emitter.Visit(const_cast<Expr*>(E)); |
1135 | 728 | Emitter.EmitStoreOfComplex(Val, dest, isInit); |
1136 | 728 | } |
1137 | | |
1138 | | /// EmitStoreOfComplex - Store a complex number into the specified l-value. |
1139 | | void CodeGenFunction::EmitStoreOfComplex(ComplexPairTy V, LValue dest, |
1140 | 893 | bool isInit) { |
1141 | 893 | ComplexExprEmitter(*this).EmitStoreOfComplex(V, dest, isInit); |
1142 | 893 | } |
1143 | | |
1144 | | /// EmitLoadOfComplex - Load a complex number from the specified address. |
1145 | | ComplexPairTy CodeGenFunction::EmitLoadOfComplex(LValue src, |
1146 | 594 | SourceLocation loc) { |
1147 | 594 | return ComplexExprEmitter(*this).EmitLoadOfLValue(src, loc); |
1148 | 594 | } |
1149 | | |
1150 | 31 | LValue CodeGenFunction::EmitComplexAssignmentLValue(const BinaryOperator *E) { |
1151 | 31 | assert(E->getOpcode() == BO_Assign); |
1152 | 0 | ComplexPairTy Val; // ignored |
1153 | 31 | LValue LVal = ComplexExprEmitter(*this).EmitBinAssignLValue(E, Val); |
1154 | 31 | if (getLangOpts().OpenMP) |
1155 | 4 | CGM.getOpenMPRuntime().checkAndEmitLastprivateConditional(*this, |
1156 | 4 | E->getLHS()); |
1157 | 31 | return LVal; |
1158 | 31 | } |
1159 | | |
1160 | | typedef ComplexPairTy (ComplexExprEmitter::*CompoundFunc)( |
1161 | | const ComplexExprEmitter::BinOpInfo &); |
1162 | | |
1163 | 68 | static CompoundFunc getComplexOp(BinaryOperatorKind Op) { |
1164 | 68 | switch (Op) { |
1165 | 58 | case BO_MulAssign: return &ComplexExprEmitter::EmitBinMul; |
1166 | 0 | case BO_DivAssign: return &ComplexExprEmitter::EmitBinDiv; |
1167 | 0 | case BO_SubAssign: return &ComplexExprEmitter::EmitBinSub; |
1168 | 10 | case BO_AddAssign: return &ComplexExprEmitter::EmitBinAdd; |
1169 | 0 | default: |
1170 | 0 | llvm_unreachable("unexpected complex compound assignment"); |
1171 | 68 | } |
1172 | 68 | } |
1173 | | |
1174 | | LValue CodeGenFunction:: |
1175 | 64 | EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E) { |
1176 | 64 | CompoundFunc Op = getComplexOp(E->getOpcode()); |
1177 | 64 | RValue Val; |
1178 | 64 | return ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val); |
1179 | 64 | } |
1180 | | |
1181 | | LValue CodeGenFunction:: |
1182 | | EmitScalarCompoundAssignWithComplex(const CompoundAssignOperator *E, |
1183 | 4 | llvm::Value *&Result) { |
1184 | 4 | CompoundFunc Op = getComplexOp(E->getOpcode()); |
1185 | 4 | RValue Val; |
1186 | 4 | LValue Ret = ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val); |
1187 | 4 | Result = Val.getScalarVal(); |
1188 | 4 | return Ret; |
1189 | 4 | } |