Line data Source code
1 : //===- llvm/Function.h - Class to represent a single function ---*- C++ -*-===//
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 file contains the declaration of the Function class, which represents a
10 : // single function/procedure in LLVM.
11 : //
12 : // A function basically consists of a list of basic blocks, a list of arguments,
13 : // and a symbol table.
14 : //
15 : //===----------------------------------------------------------------------===//
16 :
17 : #ifndef LLVM_IR_FUNCTION_H
18 : #define LLVM_IR_FUNCTION_H
19 :
20 : #include "llvm/ADT/DenseSet.h"
21 : #include "llvm/ADT/StringRef.h"
22 : #include "llvm/ADT/Twine.h"
23 : #include "llvm/ADT/ilist_node.h"
24 : #include "llvm/ADT/iterator_range.h"
25 : #include "llvm/IR/Argument.h"
26 : #include "llvm/IR/Attributes.h"
27 : #include "llvm/IR/BasicBlock.h"
28 : #include "llvm/IR/CallingConv.h"
29 : #include "llvm/IR/DerivedTypes.h"
30 : #include "llvm/IR/GlobalObject.h"
31 : #include "llvm/IR/GlobalValue.h"
32 : #include "llvm/IR/OperandTraits.h"
33 : #include "llvm/IR/SymbolTableListTraits.h"
34 : #include "llvm/IR/Value.h"
35 : #include <cassert>
36 : #include <cstddef>
37 : #include <cstdint>
38 : #include <memory>
39 : #include <string>
40 :
41 : namespace llvm {
42 :
43 : namespace Intrinsic {
44 : typedef unsigned ID;
45 : }
46 :
47 : class AssemblyAnnotationWriter;
48 : class Constant;
49 : class ConstantRange;
50 : class DataLayout;
51 : struct DenormalMode;
52 : class DISubprogram;
53 : enum LibFunc : unsigned;
54 : class LLVMContext;
55 : class Module;
56 : class raw_ostream;
57 : class TargetLibraryInfoImpl;
58 : class Type;
59 : class User;
60 : class BranchProbabilityInfo;
61 : class BlockFrequencyInfo;
62 :
63 : class LLVM_EXTERNAL_VISIBILITY Function : public GlobalObject,
64 : public ilist_node<Function> {
65 : public:
66 : using BasicBlockListType = SymbolTableList<BasicBlock>;
67 :
68 : // BasicBlock iterators...
69 : using iterator = BasicBlockListType::iterator;
70 : using const_iterator = BasicBlockListType::const_iterator;
71 :
72 : using arg_iterator = Argument *;
73 : using const_arg_iterator = const Argument *;
74 :
75 : private:
76 : // Important things that make up a function!
77 : BasicBlockListType BasicBlocks; ///< The basic blocks
78 : mutable Argument *Arguments = nullptr; ///< The formal arguments
79 : size_t NumArgs;
80 : std::unique_ptr<ValueSymbolTable>
81 : SymTab; ///< Symbol table of args/instructions
82 : AttributeList AttributeSets; ///< Parameter attributes
83 :
84 : /*
85 : * Value::SubclassData
86 : *
87 : * bit 0 : HasLazyArguments
88 : * bit 1 : HasPrefixData
89 : * bit 2 : HasPrologueData
90 : * bit 3 : HasPersonalityFn
91 : * bits 4-13 : CallingConvention
92 : * bits 14 : HasGC
93 : * bits 15 : [reserved]
94 : */
95 :
96 : /// Bits from GlobalObject::GlobalObjectSubclassData.
97 : enum {
98 : /// Whether this function is materializable.
99 : IsMaterializableBit = 0,
100 : };
101 :
102 : friend class SymbolTableListTraits<Function>;
103 :
104 : public:
105 : /// Is this function using intrinsics to record the position of debugging
106 : /// information, or non-intrinsic records? See IsNewDbgInfoFormat in
107 : /// \ref BasicBlock.
108 : bool IsNewDbgInfoFormat;
109 :
110 : /// hasLazyArguments/CheckLazyArguments - The argument list of a function is
111 : /// built on demand, so that the list isn't allocated until the first client
112 : /// needs it. The hasLazyArguments predicate returns true if the arg list
113 : /// hasn't been set up yet.
114 0 : bool hasLazyArguments() const {
115 0 : return getSubclassDataFromValue() & (1<<0);
116 : }
117 :
118 : /// \see BasicBlock::convertToNewDbgValues.
119 : void convertToNewDbgValues();
120 :
121 : /// \see BasicBlock::convertFromNewDbgValues.
122 : void convertFromNewDbgValues();
123 :
124 : void setIsNewDbgInfoFormat(bool NewVal);
125 : void setNewDbgInfoFormatFlag(bool NewVal);
126 :
127 : private:
128 : friend class TargetLibraryInfoImpl;
129 :
130 : static constexpr LibFunc UnknownLibFunc = LibFunc(-1);
131 :
132 : /// Cache for TLI::getLibFunc() result without prototype validation.
133 : /// UnknownLibFunc if uninitialized. NotLibFunc if definitely not lib func.
134 : /// Otherwise may be libfunc if prototype validation passes.
135 : mutable LibFunc LibFuncCache = UnknownLibFunc;
136 :
137 0 : void CheckLazyArguments() const {
138 0 : if (hasLazyArguments())
139 0 : BuildLazyArguments();
140 0 : }
141 :
142 : void BuildLazyArguments() const;
143 :
144 : void clearArguments();
145 :
146 : void deleteBodyImpl(bool ShouldDrop);
147 :
148 : /// Function ctor - If the (optional) Module argument is specified, the
149 : /// function is automatically inserted into the end of the function list for
150 : /// the module.
151 : ///
152 : Function(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace,
153 : const Twine &N = "", Module *M = nullptr);
154 :
155 : public:
156 : Function(const Function&) = delete;
157 : void operator=(const Function&) = delete;
158 : ~Function();
159 :
160 : // This is here to help easily convert from FunctionT * (Function * or
161 : // MachineFunction *) in BlockFrequencyInfoImpl to Function * by calling
162 : // FunctionT->getFunction().
163 : const Function &getFunction() const { return *this; }
164 :
165 : static Function *Create(FunctionType *Ty, LinkageTypes Linkage,
166 : unsigned AddrSpace, const Twine &N = "",
167 : Module *M = nullptr) {
168 : return new Function(Ty, Linkage, AddrSpace, N, M);
169 : }
170 :
171 : // TODO: remove this once all users have been updated to pass an AddrSpace
172 0 : static Function *Create(FunctionType *Ty, LinkageTypes Linkage,
173 : const Twine &N = "", Module *M = nullptr) {
174 0 : return new Function(Ty, Linkage, static_cast<unsigned>(-1), N, M);
175 : }
176 :
177 : /// Creates a new function and attaches it to a module.
178 : ///
179 : /// Places the function in the program address space as specified
180 : /// by the module's data layout.
181 : static Function *Create(FunctionType *Ty, LinkageTypes Linkage,
182 : const Twine &N, Module &M);
183 :
184 : /// Creates a function with some attributes recorded in llvm.module.flags
185 : /// and the LLVMContext applied.
186 : ///
187 : /// Use this when synthesizing new functions that need attributes that would
188 : /// have been set by command line options.
189 : ///
190 : /// This function should not be called from backends or the LTO pipeline. If
191 : /// it is called from one of those places, some default attributes will not be
192 : /// applied to the function.
193 : static Function *createWithDefaultAttr(FunctionType *Ty, LinkageTypes Linkage,
194 : unsigned AddrSpace,
195 : const Twine &N = "",
196 : Module *M = nullptr);
197 :
198 : // Provide fast operand accessors.
199 : DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
200 :
201 : /// Returns the number of non-debug IR instructions in this function.
202 : /// This is equivalent to the sum of the sizes of each basic block contained
203 : /// within this function.
204 : unsigned getInstructionCount() const;
205 :
206 : /// Returns the FunctionType for me.
207 29108 : FunctionType *getFunctionType() const {
208 29108 : return cast<FunctionType>(getValueType());
209 : }
210 :
211 : /// Returns the type of the ret val.
212 7370 : Type *getReturnType() const { return getFunctionType()->getReturnType(); }
213 :
214 : /// getContext - Return a reference to the LLVMContext associated with this
215 : /// function.
216 : LLVMContext &getContext() const;
217 :
218 : /// Get the data layout of the module this function belongs to.
219 : ///
220 : /// Requires the function to have a parent module.
221 : const DataLayout &getDataLayout() const;
222 :
223 : /// isVarArg - Return true if this function takes a variable number of
224 : /// arguments.
225 : bool isVarArg() const { return getFunctionType()->isVarArg(); }
226 :
227 : bool isMaterializable() const {
228 : return getGlobalObjectSubClassData() & (1 << IsMaterializableBit);
229 : }
230 : void setIsMaterializable(bool V) {
231 : unsigned Mask = 1 << IsMaterializableBit;
232 : setGlobalObjectSubClassData((~Mask & getGlobalObjectSubClassData()) |
233 : (V ? Mask : 0u));
234 : }
235 :
236 : /// getIntrinsicID - This method returns the ID number of the specified
237 : /// function, or Intrinsic::not_intrinsic if the function is not an
238 : /// intrinsic, or if the pointer is null. This value is always defined to be
239 : /// zero to allow easy checking for whether a function is intrinsic or not.
240 : /// The particular intrinsic functions which correspond to this value are
241 : /// defined in llvm/Intrinsics.h.
242 7032 : Intrinsic::ID getIntrinsicID() const LLVM_READONLY { return IntID; }
243 :
244 : /// isIntrinsic - Returns true if the function's name starts with "llvm.".
245 : /// It's possible for this function to return true while getIntrinsicID()
246 : /// returns Intrinsic::not_intrinsic!
247 78732 : bool isIntrinsic() const { return HasLLVMReservedName; }
248 :
249 : /// isTargetIntrinsic - Returns true if IID is an intrinsic specific to a
250 : /// certain target. If it is a generic intrinsic false is returned.
251 : static bool isTargetIntrinsic(Intrinsic::ID IID);
252 :
253 : /// isTargetIntrinsic - Returns true if this function is an intrinsic and the
254 : /// intrinsic is specific to a certain target. If this is not an intrinsic
255 : /// or a generic intrinsic, false is returned.
256 : bool isTargetIntrinsic() const;
257 :
258 : /// Returns true if the function is one of the "Constrained Floating-Point
259 : /// Intrinsics". Returns false if not, and returns false when
260 : /// getIntrinsicID() returns Intrinsic::not_intrinsic.
261 : bool isConstrainedFPIntrinsic() const;
262 :
263 : static Intrinsic::ID lookupIntrinsicID(StringRef Name);
264 :
265 : /// Update internal caches that depend on the function name (such as the
266 : /// intrinsic ID and libcall cache).
267 : /// Note, this method does not need to be called directly, as it is called
268 : /// from Value::setName() whenever the name of this function changes.
269 : void updateAfterNameChange();
270 :
271 : /// getCallingConv()/setCallingConv(CC) - These method get and set the
272 : /// calling convention of this function. The enum values for the known
273 : /// calling conventions are defined in CallingConv.h.
274 : CallingConv::ID getCallingConv() const {
275 : return static_cast<CallingConv::ID>((getSubclassDataFromValue() >> 4) &
276 : CallingConv::MaxID);
277 : }
278 : void setCallingConv(CallingConv::ID CC) {
279 : auto ID = static_cast<unsigned>(CC);
280 : assert(!(ID & ~CallingConv::MaxID) && "Unsupported calling convention");
281 : setValueSubclassData((getSubclassDataFromValue() & 0xc00f) | (ID << 4));
282 : }
283 :
284 : enum ProfileCountType { PCT_Real, PCT_Synthetic };
285 :
286 : /// Class to represent profile counts.
287 : ///
288 : /// This class represents both real and synthetic profile counts.
289 : class ProfileCount {
290 : private:
291 : uint64_t Count = 0;
292 : ProfileCountType PCT = PCT_Real;
293 :
294 : public:
295 : ProfileCount(uint64_t Count, ProfileCountType PCT)
296 : : Count(Count), PCT(PCT) {}
297 : uint64_t getCount() const { return Count; }
298 : ProfileCountType getType() const { return PCT; }
299 : bool isSynthetic() const { return PCT == PCT_Synthetic; }
300 : };
301 :
302 : /// Set the entry count for this function.
303 : ///
304 : /// Entry count is the number of times this function was executed based on
305 : /// pgo data. \p Imports points to a set of GUIDs that needs to
306 : /// be imported by the function for sample PGO, to enable the same inlines as
307 : /// the profiled optimized binary.
308 : void setEntryCount(ProfileCount Count,
309 : const DenseSet<GlobalValue::GUID> *Imports = nullptr);
310 :
311 : /// A convenience wrapper for setting entry count
312 : void setEntryCount(uint64_t Count, ProfileCountType Type = PCT_Real,
313 : const DenseSet<GlobalValue::GUID> *Imports = nullptr);
314 :
315 : /// Get the entry count for this function.
316 : ///
317 : /// Entry count is the number of times the function was executed.
318 : /// When AllowSynthetic is false, only pgo_data will be returned.
319 : std::optional<ProfileCount> getEntryCount(bool AllowSynthetic = false) const;
320 :
321 : /// Return true if the function is annotated with profile data.
322 : ///
323 : /// Presence of entry counts from a profile run implies the function has
324 : /// profile annotations. If IncludeSynthetic is false, only return true
325 : /// when the profile data is real.
326 : bool hasProfileData(bool IncludeSynthetic = false) const {
327 : return getEntryCount(IncludeSynthetic).has_value();
328 : }
329 :
330 : /// Returns the set of GUIDs that needs to be imported to the function for
331 : /// sample PGO, to enable the same inlines as the profiled optimized binary.
332 : DenseSet<GlobalValue::GUID> getImportGUIDs() const;
333 :
334 : /// Set the section prefix for this function.
335 : void setSectionPrefix(StringRef Prefix);
336 :
337 : /// Get the section prefix for this function.
338 : std::optional<StringRef> getSectionPrefix() const;
339 :
340 : /// hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm
341 : /// to use during code generation.
342 : bool hasGC() const {
343 : return getSubclassDataFromValue() & (1<<14);
344 : }
345 : const std::string &getGC() const;
346 : void setGC(std::string Str);
347 : void clearGC();
348 :
349 : /// Return the attribute list for this Function.
350 4395 : AttributeList getAttributes() const { return AttributeSets; }
351 :
352 : /// Set the attribute list for this Function.
353 : void setAttributes(AttributeList Attrs) { AttributeSets = Attrs; }
354 :
355 : // TODO: remove non-AtIndex versions of these methods.
356 : /// adds the attribute to the list of attributes.
357 : void addAttributeAtIndex(unsigned i, Attribute Attr);
358 :
359 : /// Add function attributes to this function.
360 : void addFnAttr(Attribute::AttrKind Kind);
361 :
362 : /// Add function attributes to this function.
363 : void addFnAttr(StringRef Kind, StringRef Val = StringRef());
364 :
365 : /// Add function attributes to this function.
366 : void addFnAttr(Attribute Attr);
367 :
368 : /// Add function attributes to this function.
369 : void addFnAttrs(const AttrBuilder &Attrs);
370 :
371 : /// Add return value attributes to this function.
372 : void addRetAttr(Attribute::AttrKind Kind);
373 :
374 : /// Add return value attributes to this function.
375 : void addRetAttr(Attribute Attr);
376 :
377 : /// Add return value attributes to this function.
378 : void addRetAttrs(const AttrBuilder &Attrs);
379 :
380 : /// adds the attribute to the list of attributes for the given arg.
381 : void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind);
382 :
383 : /// adds the attribute to the list of attributes for the given arg.
384 : void addParamAttr(unsigned ArgNo, Attribute Attr);
385 :
386 : /// adds the attributes to the list of attributes for the given arg.
387 : void addParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs);
388 :
389 : /// removes the attribute from the list of attributes.
390 : void removeAttributeAtIndex(unsigned i, Attribute::AttrKind Kind);
391 :
392 : /// removes the attribute from the list of attributes.
393 : void removeAttributeAtIndex(unsigned i, StringRef Kind);
394 :
395 : /// Remove function attributes from this function.
396 : void removeFnAttr(Attribute::AttrKind Kind);
397 :
398 : /// Remove function attribute from this function.
399 : void removeFnAttr(StringRef Kind);
400 :
401 : void removeFnAttrs(const AttributeMask &Attrs);
402 :
403 : /// removes the attribute from the return value list of attributes.
404 : void removeRetAttr(Attribute::AttrKind Kind);
405 :
406 : /// removes the attribute from the return value list of attributes.
407 : void removeRetAttr(StringRef Kind);
408 :
409 : /// removes the attributes from the return value list of attributes.
410 : void removeRetAttrs(const AttributeMask &Attrs);
411 :
412 : /// removes the attribute from the list of attributes.
413 : void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind);
414 :
415 : /// removes the attribute from the list of attributes.
416 : void removeParamAttr(unsigned ArgNo, StringRef Kind);
417 :
418 : /// removes the attribute from the list of attributes.
419 : void removeParamAttrs(unsigned ArgNo, const AttributeMask &Attrs);
420 :
421 : /// Return true if the function has the attribute.
422 : bool hasFnAttribute(Attribute::AttrKind Kind) const;
423 :
424 : /// Return true if the function has the attribute.
425 : bool hasFnAttribute(StringRef Kind) const;
426 :
427 : /// check if an attribute is in the list of attributes for the return value.
428 : bool hasRetAttribute(Attribute::AttrKind Kind) const;
429 :
430 : /// check if an attributes is in the list of attributes.
431 : bool hasParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const;
432 :
433 : /// gets the attribute from the list of attributes.
434 : Attribute getAttributeAtIndex(unsigned i, Attribute::AttrKind Kind) const;
435 :
436 : /// gets the attribute from the list of attributes.
437 : Attribute getAttributeAtIndex(unsigned i, StringRef Kind) const;
438 :
439 : /// Return the attribute for the given attribute kind.
440 : Attribute getFnAttribute(Attribute::AttrKind Kind) const;
441 :
442 : /// Return the attribute for the given attribute kind.
443 : Attribute getFnAttribute(StringRef Kind) const;
444 :
445 : /// Return the attribute for the given attribute kind for the return value.
446 : Attribute getRetAttribute(Attribute::AttrKind Kind) const;
447 :
448 : /// For a string attribute \p Kind, parse attribute as an integer.
449 : ///
450 : /// \returns \p Default if attribute is not present.
451 : ///
452 : /// \returns \p Default if there is an error parsing the attribute integer,
453 : /// and error is emitted to the LLVMContext
454 : uint64_t getFnAttributeAsParsedInteger(StringRef Kind,
455 : uint64_t Default = 0) const;
456 :
457 : /// gets the specified attribute from the list of attributes.
458 : Attribute getParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const;
459 :
460 : /// Return the stack alignment for the function.
461 : MaybeAlign getFnStackAlign() const {
462 : return AttributeSets.getFnStackAlignment();
463 : }
464 :
465 : /// Returns true if the function has ssp, sspstrong, or sspreq fn attrs.
466 : bool hasStackProtectorFnAttr() const;
467 :
468 : /// adds the dereferenceable attribute to the list of attributes for
469 : /// the given arg.
470 : void addDereferenceableParamAttr(unsigned ArgNo, uint64_t Bytes);
471 :
472 : /// adds the dereferenceable_or_null attribute to the list of
473 : /// attributes for the given arg.
474 : void addDereferenceableOrNullParamAttr(unsigned ArgNo, uint64_t Bytes);
475 :
476 : /// adds the range attribute to the list of attributes for the return value.
477 : void addRangeRetAttr(const ConstantRange &CR);
478 :
479 : MaybeAlign getParamAlign(unsigned ArgNo) const {
480 : return AttributeSets.getParamAlignment(ArgNo);
481 : }
482 :
483 : MaybeAlign getParamStackAlign(unsigned ArgNo) const {
484 : return AttributeSets.getParamStackAlignment(ArgNo);
485 : }
486 :
487 : /// Extract the byval type for a parameter.
488 : Type *getParamByValType(unsigned ArgNo) const {
489 : return AttributeSets.getParamByValType(ArgNo);
490 : }
491 :
492 : /// Extract the sret type for a parameter.
493 : Type *getParamStructRetType(unsigned ArgNo) const {
494 : return AttributeSets.getParamStructRetType(ArgNo);
495 : }
496 :
497 : /// Extract the inalloca type for a parameter.
498 : Type *getParamInAllocaType(unsigned ArgNo) const {
499 : return AttributeSets.getParamInAllocaType(ArgNo);
500 : }
501 :
502 : /// Extract the byref type for a parameter.
503 : Type *getParamByRefType(unsigned ArgNo) const {
504 : return AttributeSets.getParamByRefType(ArgNo);
505 : }
506 :
507 : /// Extract the preallocated type for a parameter.
508 : Type *getParamPreallocatedType(unsigned ArgNo) const {
509 : return AttributeSets.getParamPreallocatedType(ArgNo);
510 : }
511 :
512 : /// Extract the number of dereferenceable bytes for a parameter.
513 : /// @param ArgNo Index of an argument, with 0 being the first function arg.
514 : uint64_t getParamDereferenceableBytes(unsigned ArgNo) const {
515 : return AttributeSets.getParamDereferenceableBytes(ArgNo);
516 : }
517 :
518 : /// Extract the number of dereferenceable_or_null bytes for a
519 : /// parameter.
520 : /// @param ArgNo AttributeList ArgNo, referring to an argument.
521 : uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const {
522 : return AttributeSets.getParamDereferenceableOrNullBytes(ArgNo);
523 : }
524 :
525 : /// Extract the nofpclass attribute for a parameter.
526 : FPClassTest getParamNoFPClass(unsigned ArgNo) const {
527 : return AttributeSets.getParamNoFPClass(ArgNo);
528 : }
529 :
530 : /// Determine if the function is presplit coroutine.
531 : bool isPresplitCoroutine() const {
532 : return hasFnAttribute(Attribute::PresplitCoroutine);
533 : }
534 : void setPresplitCoroutine() { addFnAttr(Attribute::PresplitCoroutine); }
535 : void setSplittedCoroutine() { removeFnAttr(Attribute::PresplitCoroutine); }
536 :
537 : bool isCoroOnlyDestroyWhenComplete() const {
538 : return hasFnAttribute(Attribute::CoroDestroyOnlyWhenComplete);
539 : }
540 : void setCoroDestroyOnlyWhenComplete() {
541 : addFnAttr(Attribute::CoroDestroyOnlyWhenComplete);
542 : }
543 :
544 : MemoryEffects getMemoryEffects() const;
545 : void setMemoryEffects(MemoryEffects ME);
546 :
547 : /// Determine if the function does not access memory.
548 : bool doesNotAccessMemory() const;
549 : void setDoesNotAccessMemory();
550 :
551 : /// Determine if the function does not access or only reads memory.
552 : bool onlyReadsMemory() const;
553 : void setOnlyReadsMemory();
554 :
555 : /// Determine if the function does not access or only writes memory.
556 : bool onlyWritesMemory() const;
557 : void setOnlyWritesMemory();
558 :
559 : /// Determine if the call can access memmory only using pointers based
560 : /// on its arguments.
561 : bool onlyAccessesArgMemory() const;
562 : void setOnlyAccessesArgMemory();
563 :
564 : /// Determine if the function may only access memory that is
565 : /// inaccessible from the IR.
566 : bool onlyAccessesInaccessibleMemory() const;
567 : void setOnlyAccessesInaccessibleMemory();
568 :
569 : /// Determine if the function may only access memory that is
570 : /// either inaccessible from the IR or pointed to by its arguments.
571 : bool onlyAccessesInaccessibleMemOrArgMem() const;
572 : void setOnlyAccessesInaccessibleMemOrArgMem();
573 :
574 : /// Determine if the function cannot return.
575 : bool doesNotReturn() const {
576 : return hasFnAttribute(Attribute::NoReturn);
577 : }
578 : void setDoesNotReturn() {
579 : addFnAttr(Attribute::NoReturn);
580 : }
581 :
582 : /// Determine if the function should not perform indirect branch tracking.
583 : bool doesNoCfCheck() const { return hasFnAttribute(Attribute::NoCfCheck); }
584 :
585 : /// Determine if the function cannot unwind.
586 : bool doesNotThrow() const {
587 : return hasFnAttribute(Attribute::NoUnwind);
588 : }
589 : void setDoesNotThrow() {
590 : addFnAttr(Attribute::NoUnwind);
591 : }
592 :
593 : /// Determine if the call cannot be duplicated.
594 : bool cannotDuplicate() const {
595 : return hasFnAttribute(Attribute::NoDuplicate);
596 : }
597 : void setCannotDuplicate() {
598 : addFnAttr(Attribute::NoDuplicate);
599 : }
600 :
601 : /// Determine if the call is convergent.
602 : bool isConvergent() const {
603 : return hasFnAttribute(Attribute::Convergent);
604 : }
605 : void setConvergent() {
606 : addFnAttr(Attribute::Convergent);
607 : }
608 : void setNotConvergent() {
609 : removeFnAttr(Attribute::Convergent);
610 : }
611 :
612 : /// Determine if the call has sideeffects.
613 : bool isSpeculatable() const {
614 : return hasFnAttribute(Attribute::Speculatable);
615 : }
616 : void setSpeculatable() {
617 : addFnAttr(Attribute::Speculatable);
618 : }
619 :
620 : /// Determine if the call might deallocate memory.
621 : bool doesNotFreeMemory() const {
622 : return onlyReadsMemory() || hasFnAttribute(Attribute::NoFree);
623 : }
624 : void setDoesNotFreeMemory() {
625 : addFnAttr(Attribute::NoFree);
626 : }
627 :
628 : /// Determine if the call can synchroize with other threads
629 : bool hasNoSync() const {
630 : return hasFnAttribute(Attribute::NoSync);
631 : }
632 : void setNoSync() {
633 : addFnAttr(Attribute::NoSync);
634 : }
635 :
636 : /// Determine if the function is known not to recurse, directly or
637 : /// indirectly.
638 : bool doesNotRecurse() const {
639 : return hasFnAttribute(Attribute::NoRecurse);
640 : }
641 : void setDoesNotRecurse() {
642 : addFnAttr(Attribute::NoRecurse);
643 : }
644 :
645 : /// Determine if the function is required to make forward progress.
646 : bool mustProgress() const {
647 : return hasFnAttribute(Attribute::MustProgress) ||
648 : hasFnAttribute(Attribute::WillReturn);
649 : }
650 : void setMustProgress() { addFnAttr(Attribute::MustProgress); }
651 :
652 : /// Determine if the function will return.
653 : bool willReturn() const { return hasFnAttribute(Attribute::WillReturn); }
654 : void setWillReturn() { addFnAttr(Attribute::WillReturn); }
655 :
656 : /// Get what kind of unwind table entry to generate for this function.
657 : UWTableKind getUWTableKind() const {
658 : return AttributeSets.getUWTableKind();
659 : }
660 :
661 : /// True if the ABI mandates (or the user requested) that this
662 : /// function be in a unwind table.
663 : bool hasUWTable() const {
664 : return getUWTableKind() != UWTableKind::None;
665 : }
666 : void setUWTableKind(UWTableKind K) {
667 : if (K == UWTableKind::None)
668 : removeFnAttr(Attribute::UWTable);
669 : else
670 : addFnAttr(Attribute::getWithUWTableKind(getContext(), K));
671 : }
672 : /// True if this function needs an unwind table.
673 : bool needsUnwindTableEntry() const {
674 : return hasUWTable() || !doesNotThrow() || hasPersonalityFn();
675 : }
676 :
677 : /// Determine if the function returns a structure through first
678 : /// or second pointer argument.
679 : bool hasStructRetAttr() const {
680 : return AttributeSets.hasParamAttr(0, Attribute::StructRet) ||
681 : AttributeSets.hasParamAttr(1, Attribute::StructRet);
682 : }
683 :
684 : /// Determine if the parameter or return value is marked with NoAlias
685 : /// attribute.
686 : bool returnDoesNotAlias() const {
687 : return AttributeSets.hasRetAttr(Attribute::NoAlias);
688 : }
689 : void setReturnDoesNotAlias() { addRetAttr(Attribute::NoAlias); }
690 :
691 : /// Do not optimize this function (-O0).
692 : bool hasOptNone() const { return hasFnAttribute(Attribute::OptimizeNone); }
693 :
694 : /// Optimize this function for minimum size (-Oz).
695 : bool hasMinSize() const { return hasFnAttribute(Attribute::MinSize); }
696 :
697 : /// Optimize this function for size (-Os) or minimum size (-Oz).
698 : bool hasOptSize() const {
699 : return hasFnAttribute(Attribute::OptimizeForSize) || hasMinSize();
700 : }
701 :
702 : /// Returns the denormal handling type for the default rounding mode of the
703 : /// function.
704 : DenormalMode getDenormalMode(const fltSemantics &FPType) const;
705 :
706 : /// Return the representational value of "denormal-fp-math". Code interested
707 : /// in the semantics of the function should use getDenormalMode instead.
708 : DenormalMode getDenormalModeRaw() const;
709 :
710 : /// Return the representational value of "denormal-fp-math-f32". Code
711 : /// interested in the semantics of the function should use getDenormalMode
712 : /// instead.
713 : DenormalMode getDenormalModeF32Raw() const;
714 :
715 : /// copyAttributesFrom - copy all additional attributes (those not needed to
716 : /// create a Function) from the Function Src to this one.
717 : void copyAttributesFrom(const Function *Src);
718 :
719 : /// deleteBody - This method deletes the body of the function, and converts
720 : /// the linkage to external.
721 : ///
722 : void deleteBody() {
723 : deleteBodyImpl(/*ShouldDrop=*/false);
724 : setLinkage(ExternalLinkage);
725 : }
726 :
727 : /// removeFromParent - This method unlinks 'this' from the containing module,
728 : /// but does not delete it.
729 : ///
730 : void removeFromParent();
731 :
732 : /// eraseFromParent - This method unlinks 'this' from the containing module
733 : /// and deletes it.
734 : ///
735 : void eraseFromParent();
736 :
737 : /// Steal arguments from another function.
738 : ///
739 : /// Drop this function's arguments and splice in the ones from \c Src.
740 : /// Requires that this has no function body.
741 : void stealArgumentListFrom(Function &Src);
742 :
743 : /// Insert \p BB in the basic block list at \p Position. \Returns an iterator
744 : /// to the newly inserted BB.
745 : Function::iterator insert(Function::iterator Position, BasicBlock *BB) {
746 : Function::iterator FIt = BasicBlocks.insert(Position, BB);
747 : BB->setIsNewDbgInfoFormat(IsNewDbgInfoFormat);
748 : return FIt;
749 : }
750 :
751 : /// Transfer all blocks from \p FromF to this function at \p ToIt.
752 : void splice(Function::iterator ToIt, Function *FromF) {
753 : splice(ToIt, FromF, FromF->begin(), FromF->end());
754 : }
755 :
756 : /// Transfer one BasicBlock from \p FromF at \p FromIt to this function
757 : /// at \p ToIt.
758 : void splice(Function::iterator ToIt, Function *FromF,
759 : Function::iterator FromIt) {
760 : auto FromItNext = std::next(FromIt);
761 : // Single-element splice is a noop if destination == source.
762 : if (ToIt == FromIt || ToIt == FromItNext)
763 : return;
764 : splice(ToIt, FromF, FromIt, FromItNext);
765 : }
766 :
767 : /// Transfer a range of basic blocks that belong to \p FromF from \p
768 : /// FromBeginIt to \p FromEndIt, to this function at \p ToIt.
769 : void splice(Function::iterator ToIt, Function *FromF,
770 : Function::iterator FromBeginIt,
771 : Function::iterator FromEndIt);
772 :
773 : /// Erases a range of BasicBlocks from \p FromIt to (not including) \p ToIt.
774 : /// \Returns \p ToIt.
775 : Function::iterator erase(Function::iterator FromIt, Function::iterator ToIt);
776 :
777 : private:
778 : // These need access to the underlying BB list.
779 : friend void BasicBlock::removeFromParent();
780 : friend iplist<BasicBlock>::iterator BasicBlock::eraseFromParent();
781 : template <class BB_t, class BB_i_t, class BI_t, class II_t>
782 : friend class InstIterator;
783 : friend class llvm::SymbolTableListTraits<llvm::BasicBlock>;
784 : friend class llvm::ilist_node_with_parent<llvm::BasicBlock, llvm::Function>;
785 :
786 : /// Get the underlying elements of the Function... the basic block list is
787 : /// empty for external functions.
788 : ///
789 : /// This is deliberately private because we have implemented an adequate set
790 : /// of functions to modify the list, including Function::splice(),
791 : /// Function::erase(), Function::insert() etc.
792 : const BasicBlockListType &getBasicBlockList() const { return BasicBlocks; }
793 : BasicBlockListType &getBasicBlockList() { return BasicBlocks; }
794 :
795 : static BasicBlockListType Function::*getSublistAccess(BasicBlock*) {
796 : return &Function::BasicBlocks;
797 : }
798 :
799 : public:
800 : const BasicBlock &getEntryBlock() const { return front(); }
801 : BasicBlock &getEntryBlock() { return front(); }
802 :
803 : //===--------------------------------------------------------------------===//
804 : // Symbol Table Accessing functions...
805 :
806 : /// getSymbolTable() - Return the symbol table if any, otherwise nullptr.
807 : ///
808 : inline ValueSymbolTable *getValueSymbolTable() { return SymTab.get(); }
809 : inline const ValueSymbolTable *getValueSymbolTable() const {
810 : return SymTab.get();
811 : }
812 :
813 : //===--------------------------------------------------------------------===//
814 : // BasicBlock iterator forwarding functions
815 : //
816 4374 : iterator begin() { return BasicBlocks.begin(); }
817 : const_iterator begin() const { return BasicBlocks.begin(); }
818 4374 : iterator end () { return BasicBlocks.end(); }
819 : const_iterator end () const { return BasicBlocks.end(); }
820 :
821 : size_t size() const { return BasicBlocks.size(); }
822 : bool empty() const { return BasicBlocks.empty(); }
823 : const BasicBlock &front() const { return BasicBlocks.front(); }
824 : BasicBlock &front() { return BasicBlocks.front(); }
825 : const BasicBlock &back() const { return BasicBlocks.back(); }
826 : BasicBlock &back() { return BasicBlocks.back(); }
827 :
828 : /// @name Function Argument Iteration
829 : /// @{
830 :
831 0 : arg_iterator arg_begin() {
832 0 : CheckLazyArguments();
833 0 : return Arguments;
834 : }
835 : const_arg_iterator arg_begin() const {
836 : CheckLazyArguments();
837 : return Arguments;
838 : }
839 :
840 : arg_iterator arg_end() {
841 : CheckLazyArguments();
842 : return Arguments + NumArgs;
843 : }
844 : const_arg_iterator arg_end() const {
845 : CheckLazyArguments();
846 : return Arguments + NumArgs;
847 : }
848 :
849 : Argument* getArg(unsigned i) const {
850 : assert (i < NumArgs && "getArg() out of range!");
851 : CheckLazyArguments();
852 : return Arguments + i;
853 : }
854 :
855 : iterator_range<arg_iterator> args() {
856 : return make_range(arg_begin(), arg_end());
857 : }
858 : iterator_range<const_arg_iterator> args() const {
859 : return make_range(arg_begin(), arg_end());
860 : }
861 :
862 : /// @}
863 :
864 : size_t arg_size() const { return NumArgs; }
865 : bool arg_empty() const { return arg_size() == 0; }
866 :
867 : /// Check whether this function has a personality function.
868 : bool hasPersonalityFn() const {
869 : return getSubclassDataFromValue() & (1<<3);
870 : }
871 :
872 : /// Get the personality function associated with this function.
873 : Constant *getPersonalityFn() const;
874 : void setPersonalityFn(Constant *Fn);
875 :
876 : /// Check whether this function has prefix data.
877 : bool hasPrefixData() const {
878 : return getSubclassDataFromValue() & (1<<1);
879 : }
880 :
881 : /// Get the prefix data associated with this function.
882 : Constant *getPrefixData() const;
883 : void setPrefixData(Constant *PrefixData);
884 :
885 : /// Check whether this function has prologue data.
886 : bool hasPrologueData() const {
887 : return getSubclassDataFromValue() & (1<<2);
888 : }
889 :
890 : /// Get the prologue data associated with this function.
891 : Constant *getPrologueData() const;
892 : void setPrologueData(Constant *PrologueData);
893 :
894 : /// Print the function to an output stream with an optional
895 : /// AssemblyAnnotationWriter.
896 : void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW = nullptr,
897 : bool ShouldPreserveUseListOrder = false,
898 : bool IsForDebug = false) const;
899 :
900 : /// viewCFG - This function is meant for use from the debugger. You can just
901 : /// say 'call F->viewCFG()' and a ghostview window should pop up from the
902 : /// program, displaying the CFG of the current function with the code for each
903 : /// basic block inside. This depends on there being a 'dot' and 'gv' program
904 : /// in your path.
905 : ///
906 : void viewCFG() const;
907 :
908 : /// Extended form to print edge weights.
909 : void viewCFG(bool ViewCFGOnly, const BlockFrequencyInfo *BFI,
910 : const BranchProbabilityInfo *BPI) const;
911 :
912 : /// viewCFGOnly - This function is meant for use from the debugger. It works
913 : /// just like viewCFG, but it does not include the contents of basic blocks
914 : /// into the nodes, just the label. If you are only interested in the CFG
915 : /// this can make the graph smaller.
916 : ///
917 : void viewCFGOnly() const;
918 :
919 : /// Extended form to print edge weights.
920 : void viewCFGOnly(const BlockFrequencyInfo *BFI,
921 : const BranchProbabilityInfo *BPI) const;
922 :
923 : /// Methods for support type inquiry through isa, cast, and dyn_cast:
924 449286 : static bool classof(const Value *V) {
925 449286 : return V->getValueID() == Value::FunctionVal;
926 : }
927 :
928 : /// dropAllReferences() - This method causes all the subinstructions to "let
929 : /// go" of all references that they are maintaining. This allows one to
930 : /// 'delete' a whole module at a time, even though there may be circular
931 : /// references... first all references are dropped, and all use counts go to
932 : /// zero. Then everything is deleted for real. Note that no operations are
933 : /// valid on an object that has "dropped all references", except operator
934 : /// delete.
935 : ///
936 : /// Since no other object in the module can have references into the body of a
937 : /// function, dropping all references deletes the entire body of the function,
938 : /// including any contained basic blocks.
939 : ///
940 : void dropAllReferences() {
941 : deleteBodyImpl(/*ShouldDrop=*/true);
942 : }
943 :
944 : /// hasAddressTaken - returns true if there are any uses of this function
945 : /// other than direct calls or invokes to it, or blockaddress expressions.
946 : /// Optionally passes back an offending user for diagnostic purposes,
947 : /// ignores callback uses, assume like pointer annotation calls, references in
948 : /// llvm.used and llvm.compiler.used variables, operand bundle
949 : /// "clang.arc.attachedcall", and direct calls with a different call site
950 : /// signature (the function is implicitly casted).
951 : bool hasAddressTaken(const User ** = nullptr, bool IgnoreCallbackUses = false,
952 : bool IgnoreAssumeLikeCalls = true,
953 : bool IngoreLLVMUsed = false,
954 : bool IgnoreARCAttachedCall = false,
955 : bool IgnoreCastedDirectCall = false) const;
956 :
957 : /// isDefTriviallyDead - Return true if it is trivially safe to remove
958 : /// this function definition from the module (because it isn't externally
959 : /// visible, does not have its address taken, and has no callers). To make
960 : /// this more accurate, call removeDeadConstantUsers first.
961 : bool isDefTriviallyDead() const;
962 :
963 : /// callsFunctionThatReturnsTwice - Return true if the function has a call to
964 : /// setjmp or other function that gcc recognizes as "returning twice".
965 : bool callsFunctionThatReturnsTwice() const;
966 :
967 : /// Set the attached subprogram.
968 : ///
969 : /// Calls \a setMetadata() with \a LLVMContext::MD_dbg.
970 : void setSubprogram(DISubprogram *SP);
971 :
972 : /// Get the attached subprogram.
973 : ///
974 : /// Calls \a getMetadata() with \a LLVMContext::MD_dbg and casts the result
975 : /// to \a DISubprogram.
976 : DISubprogram *getSubprogram() const;
977 :
978 : /// Returns true if we should emit debug info for profiling.
979 : bool shouldEmitDebugInfoForProfiling() const;
980 :
981 : /// Check if null pointer dereferencing is considered undefined behavior for
982 : /// the function.
983 : /// Return value: false => null pointer dereference is undefined.
984 : /// Return value: true => null pointer dereference is not undefined.
985 : bool nullPointerIsDefined() const;
986 :
987 : private:
988 : void allocHungoffUselist();
989 : template<int Idx> void setHungoffOperand(Constant *C);
990 :
991 : /// Shadow Value::setValueSubclassData with a private forwarding method so
992 : /// that subclasses cannot accidentally use it.
993 : void setValueSubclassData(unsigned short D) {
994 : Value::setValueSubclassData(D);
995 : }
996 : void setValueSubclassDataBit(unsigned Bit, bool On);
997 : };
998 :
999 : /// Check whether null pointer dereferencing is considered undefined behavior
1000 : /// for a given function or an address space.
1001 : /// Null pointer access in non-zero address space is not considered undefined.
1002 : /// Return value: false => null pointer dereference is undefined.
1003 : /// Return value: true => null pointer dereference is not undefined.
1004 : bool NullPointerIsDefined(const Function *F, unsigned AS = 0);
1005 :
1006 : template <>
1007 : struct OperandTraits<Function> : public HungoffOperandTraits<3> {};
1008 :
1009 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(Function, Value)
1010 :
1011 : } // end namespace llvm
1012 :
1013 : #endif // LLVM_IR_FUNCTION_H
|
