1//===- llvm/Function.h - Class to represent a single function ---*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file contains the declaration of the Function class, which represents a
11// single function/procedure in LLVM.
12//
13// A function basically consists of a list of basic blocks, a list of arguments,
14// and a symbol table.
15//
16//===----------------------------------------------------------------------===//
17
18#ifndef LLVM_IR_FUNCTION_H
19#define LLVM_IR_FUNCTION_H
20
21#include "llvm/ADT/DenseSet.h"
22#include "llvm/ADT/StringRef.h"
23#include "llvm/ADT/Twine.h"
24#include "llvm/ADT/ilist_node.h"
25#include "llvm/ADT/iterator_range.h"
26#include "llvm/IR/Argument.h"
27#include "llvm/IR/Attributes.h"
28#include "llvm/IR/BasicBlock.h"
29#include "llvm/IR/CallingConv.h"
30#include "llvm/IR/DerivedTypes.h"
31#include "llvm/IR/GlobalObject.h"
32#include "llvm/IR/GlobalValue.h"
33#include "llvm/IR/OperandTraits.h"
34#include "llvm/IR/SymbolTableListTraits.h"
35#include "llvm/IR/Value.h"
36#include "llvm/Support/Casting.h"
37#include "llvm/Support/Compiler.h"
38#include <cassert>
39#include <cstddef>
40#include <cstdint>
41#include <memory>
42#include <string>
43
44namespace llvm {
45
46namespace Intrinsic {
47enum ID : unsigned;
48}
49
50class AssemblyAnnotationWriter;
51class Constant;
52class DISubprogram;
53class LLVMContext;
54class Module;
55template <typename T> class Optional;
56class raw_ostream;
57class Type;
58class User;
59
60class Function : public GlobalObject, public ilist_node<Function> {
61public:
62 using BasicBlockListType = SymbolTableList<BasicBlock>;
63
64 // BasicBlock iterators...
65 using iterator = BasicBlockListType::iterator;
66 using const_iterator = BasicBlockListType::const_iterator;
67
68 using arg_iterator = Argument *;
69 using const_arg_iterator = const Argument *;
70
71private:
72 // Important things that make up a function!
73 BasicBlockListType BasicBlocks; ///< The basic blocks
74 mutable Argument *Arguments = nullptr; ///< The formal arguments
75 size_t NumArgs;
76 std::unique_ptr<ValueSymbolTable>
77 SymTab; ///< Symbol table of args/instructions
78 AttributeList AttributeSets; ///< Parameter attributes
79
80 /*
81 * Value::SubclassData
82 *
83 * bit 0 : HasLazyArguments
84 * bit 1 : HasPrefixData
85 * bit 2 : HasPrologueData
86 * bit 3 : HasPersonalityFn
87 * bits 4-13 : CallingConvention
88 * bits 14 : HasGC
89 * bits 15 : [reserved]
90 */
91
92 /// Bits from GlobalObject::GlobalObjectSubclassData.
93 enum {
94 /// Whether this function is materializable.
95 IsMaterializableBit = 0,
96 };
97
98 friend class SymbolTableListTraits<Function>;
99
100 /// hasLazyArguments/CheckLazyArguments - The argument list of a function is
101 /// built on demand, so that the list isn't allocated until the first client
102 /// needs it. The hasLazyArguments predicate returns true if the arg list
103 /// hasn't been set up yet.
104public:
105 bool hasLazyArguments() const {
106 return getSubclassDataFromValue() & (1<<0);
107 }
108
109private:
110 void CheckLazyArguments() const {
111 if (hasLazyArguments())
112 BuildLazyArguments();
113 }
114
115 void BuildLazyArguments() const;
116
117 void clearArguments();
118
119 /// Function ctor - If the (optional) Module argument is specified, the
120 /// function is automatically inserted into the end of the function list for
121 /// the module.
122 ///
123 Function(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace,
124 const Twine &N = "", Module *M = nullptr);
125
126public:
127 Function(const Function&) = delete;
128 void operator=(const Function&) = delete;
129 ~Function();
130
131 // This is here to help easily convert from FunctionT * (Function * or
132 // MachineFunction *) in BlockFrequencyInfoImpl to Function * by calling
133 // FunctionT->getFunction().
134 const Function &getFunction() const { return *this; }
135
136 static Function *Create(FunctionType *Ty, LinkageTypes Linkage,
137 unsigned AddrSpace, const Twine &N = "",
138 Module *M = nullptr) {
139 return new Function(Ty, Linkage, AddrSpace, N, M);
140 }
141
142 // TODO: remove this once all users have been updated to pass an AddrSpace
143 static Function *Create(FunctionType *Ty, LinkageTypes Linkage,
144 const Twine &N = "", Module *M = nullptr) {
145 return new Function(Ty, Linkage, static_cast<unsigned>(-1), N, M);
146 }
147
148 /// Creates a new function and attaches it to a module.
149 ///
150 /// Places the function in the program address space as specified
151 /// by the module's data layout.
152 static Function *Create(FunctionType *Ty, LinkageTypes Linkage,
153 const Twine &N, Module &M);
154
155 // Provide fast operand accessors.
156 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
157
158 /// Returns the number of non-debug IR instructions in this function.
159 /// This is equivalent to the sum of the sizes of each basic block contained
160 /// within this function.
161 unsigned getInstructionCount() const;
162
163 /// Returns the FunctionType for me.
164 FunctionType *getFunctionType() const {
165 return cast<FunctionType>(getValueType());
166 }
167
168 /// Returns the type of the ret val.
169 Type *getReturnType() const { return getFunctionType()->getReturnType(); }
170
171 /// getContext - Return a reference to the LLVMContext associated with this
172 /// function.
173 LLVMContext &getContext() const;
174
175 /// isVarArg - Return true if this function takes a variable number of
176 /// arguments.
177 bool isVarArg() const { return getFunctionType()->isVarArg(); }
178
179 bool isMaterializable() const {
180 return getGlobalObjectSubClassData() & (1 << IsMaterializableBit);
181 }
182 void setIsMaterializable(bool V) {
183 unsigned Mask = 1 << IsMaterializableBit;
184 setGlobalObjectSubClassData((~Mask & getGlobalObjectSubClassData()) |
185 (V ? Mask : 0u));
186 }
187
188 /// getIntrinsicID - This method returns the ID number of the specified
189 /// function, or Intrinsic::not_intrinsic if the function is not an
190 /// intrinsic, or if the pointer is null. This value is always defined to be
191 /// zero to allow easy checking for whether a function is intrinsic or not.
192 /// The particular intrinsic functions which correspond to this value are
193 /// defined in llvm/Intrinsics.h.
194 Intrinsic::ID getIntrinsicID() const LLVM_READONLY { return IntID; }
195
196 /// isIntrinsic - Returns true if the function's name starts with "llvm.".
197 /// It's possible for this function to return true while getIntrinsicID()
198 /// returns Intrinsic::not_intrinsic!
199 bool isIntrinsic() const { return HasLLVMReservedName; }
200
201 static Intrinsic::ID lookupIntrinsicID(StringRef Name);
202
203 /// Recalculate the ID for this function if it is an Intrinsic defined
204 /// in llvm/Intrinsics.h. Sets the intrinsic ID to Intrinsic::not_intrinsic
205 /// if the name of this function does not match an intrinsic in that header.
206 /// Note, this method does not need to be called directly, as it is called
207 /// from Value::setName() whenever the name of this function changes.
208 void recalculateIntrinsicID();
209
210 /// getCallingConv()/setCallingConv(CC) - These method get and set the
211 /// calling convention of this function. The enum values for the known
212 /// calling conventions are defined in CallingConv.h.
213 CallingConv::ID getCallingConv() const {
214 return static_cast<CallingConv::ID>((getSubclassDataFromValue() >> 4) &
215 CallingConv::MaxID);
216 }
217 void setCallingConv(CallingConv::ID CC) {
218 auto ID = static_cast<unsigned>(CC);
219 assert(!(ID & ~CallingConv::MaxID) && "Unsupported calling convention");
220 setValueSubclassData((getSubclassDataFromValue() & 0xc00f) | (ID << 4));
221 }
222
223 /// Return the attribute list for this Function.
224 AttributeList getAttributes() const { return AttributeSets; }
225
226 /// Set the attribute list for this Function.
227 void setAttributes(AttributeList Attrs) { AttributeSets = Attrs; }
228
229 /// Add function attributes to this function.
230 void addFnAttr(Attribute::AttrKind Kind) {
231 addAttribute(AttributeList::FunctionIndex, Kind);
232 }
233
234 /// Add function attributes to this function.
235 void addFnAttr(StringRef Kind, StringRef Val = StringRef()) {
236 addAttribute(AttributeList::FunctionIndex,
237 Attribute::get(getContext(), Kind, Val));
238 }
239
240 /// Add function attributes to this function.
241 void addFnAttr(Attribute Attr) {
242 addAttribute(AttributeList::FunctionIndex, Attr);
243 }
244
245 /// Remove function attributes from this function.
246 void removeFnAttr(Attribute::AttrKind Kind) {
247 removeAttribute(AttributeList::FunctionIndex, Kind);
248 }
249
250 /// Remove function attribute from this function.
251 void removeFnAttr(StringRef Kind) {
252 setAttributes(getAttributes().removeAttribute(
253 getContext(), AttributeList::FunctionIndex, Kind));
254 }
255
256 enum ProfileCountType { PCT_Invalid, PCT_Real, PCT_Synthetic };
257
258 /// Class to represent profile counts.
259 ///
260 /// This class represents both real and synthetic profile counts.
261 class ProfileCount {
262 private:
263 uint64_t Count;
264 ProfileCountType PCT;
265 static ProfileCount Invalid;
266
267 public:
268 ProfileCount() : Count(-1), PCT(PCT_Invalid) {}
269 ProfileCount(uint64_t Count, ProfileCountType PCT)
270 : Count(Count), PCT(PCT) {}
271 bool hasValue() const { return PCT != PCT_Invalid; }
272 uint64_t getCount() const { return Count; }
273 ProfileCountType getType() const { return PCT; }
274 bool isSynthetic() const { return PCT == PCT_Synthetic; }
275 explicit operator bool() { return hasValue(); }
276 bool operator!() const { return !hasValue(); }
277 // Update the count retaining the same profile count type.
278 ProfileCount &setCount(uint64_t C) {
279 Count = C;
280 return *this;
281 }
282 static ProfileCount getInvalid() { return ProfileCount(-1, PCT_Invalid); }
283 };
284
285 /// Set the entry count for this function.
286 ///
287 /// Entry count is the number of times this function was executed based on
288 /// pgo data. \p Imports points to a set of GUIDs that needs to
289 /// be imported by the function for sample PGO, to enable the same inlines as
290 /// the profiled optimized binary.
291 void setEntryCount(ProfileCount Count,
292 const DenseSet<GlobalValue::GUID> *Imports = nullptr);
293
294 /// A convenience wrapper for setting entry count
295 void setEntryCount(uint64_t Count, ProfileCountType Type = PCT_Real,
296 const DenseSet<GlobalValue::GUID> *Imports = nullptr);
297
298 /// Get the entry count for this function.
299 ///
300 /// Entry count is the number of times the function was executed based on
301 /// pgo data.
302 ProfileCount getEntryCount() const;
303
304 /// Return true if the function is annotated with profile data.
305 ///
306 /// Presence of entry counts from a profile run implies the function has
307 /// profile annotations.
308 bool hasProfileData() const { return getEntryCount().hasValue(); }
309
310 /// Returns the set of GUIDs that needs to be imported to the function for
311 /// sample PGO, to enable the same inlines as the profiled optimized binary.
312 DenseSet<GlobalValue::GUID> getImportGUIDs() const;
313
314 /// Set the section prefix for this function.
315 void setSectionPrefix(StringRef Prefix);
316
317 /// Get the section prefix for this function.
318 Optional<StringRef> getSectionPrefix() const;
319
320 /// Return true if the function has the attribute.
321 bool hasFnAttribute(Attribute::AttrKind Kind) const {
322 return AttributeSets.hasFnAttribute(Kind);
323 }
324
325 /// Return true if the function has the attribute.
326 bool hasFnAttribute(StringRef Kind) const {
327 return AttributeSets.hasFnAttribute(Kind);
328 }
329
330 /// Return the attribute for the given attribute kind.
331 Attribute getFnAttribute(Attribute::AttrKind Kind) const {
332 return getAttribute(AttributeList::FunctionIndex, Kind);
333 }
334
335 /// Return the attribute for the given attribute kind.
336 Attribute getFnAttribute(StringRef Kind) const {
337 return getAttribute(AttributeList::FunctionIndex, Kind);
338 }
339
340 /// Return the stack alignment for the function.
341 unsigned getFnStackAlignment() const {
342 if (!hasFnAttribute(Attribute::StackAlignment))
343 return 0;
344 return AttributeSets.getStackAlignment(AttributeList::FunctionIndex);
345 }
346
347 /// hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm
348 /// to use during code generation.
349 bool hasGC() const {
350 return getSubclassDataFromValue() & (1<<14);
351 }
352 const std::string &getGC() const;
353 void setGC(std::string Str);
354 void clearGC();
355
356 /// adds the attribute to the list of attributes.
357 void addAttribute(unsigned i, Attribute::AttrKind Kind);
358
359 /// adds the attribute to the list of attributes.
360 void addAttribute(unsigned i, Attribute Attr);
361
362 /// adds the attributes to the list of attributes.
363 void addAttributes(unsigned i, const AttrBuilder &Attrs);
364
365 /// adds the attribute to the list of attributes for the given arg.
366 void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind);
367
368 /// adds the attribute to the list of attributes for the given arg.
369 void addParamAttr(unsigned ArgNo, Attribute Attr);
370
371 /// adds the attributes to the list of attributes for the given arg.
372 void addParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs);
373
374 /// removes the attribute from the list of attributes.
375 void removeAttribute(unsigned i, Attribute::AttrKind Kind);
376
377 /// removes the attribute from the list of attributes.
378 void removeAttribute(unsigned i, StringRef Kind);
379
380 /// removes the attributes from the list of attributes.
381 void removeAttributes(unsigned i, const AttrBuilder &Attrs);
382
383 /// removes the attribute from the list of attributes.
384 void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind);
385
386 /// removes the attribute from the list of attributes.
387 void removeParamAttr(unsigned ArgNo, StringRef Kind);
388
389 /// removes the attribute from the list of attributes.
390 void removeParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs);
391
392 /// check if an attributes is in the list of attributes.
393 bool hasAttribute(unsigned i, Attribute::AttrKind Kind) const {
394 return getAttributes().hasAttribute(i, Kind);
395 }
396
397 /// check if an attributes is in the list of attributes.
398 bool hasParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const {
399 return getAttributes().hasParamAttribute(ArgNo, Kind);
400 }
401
402 /// gets the attribute from the list of attributes.
403 Attribute getAttribute(unsigned i, Attribute::AttrKind Kind) const {
404 return AttributeSets.getAttribute(i, Kind);
405 }
406
407 /// gets the attribute from the list of attributes.
408 Attribute getAttribute(unsigned i, StringRef Kind) const {
409 return AttributeSets.getAttribute(i, Kind);
410 }
411
412 /// adds the dereferenceable attribute to the list of attributes.
413 void addDereferenceableAttr(unsigned i, uint64_t Bytes);
414
415 /// adds the dereferenceable attribute to the list of attributes for
416 /// the given arg.
417 void addDereferenceableParamAttr(unsigned ArgNo, uint64_t Bytes);
418
419 /// adds the dereferenceable_or_null attribute to the list of
420 /// attributes.
421 void addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes);
422
423 /// adds the dereferenceable_or_null attribute to the list of
424 /// attributes for the given arg.
425 void addDereferenceableOrNullParamAttr(unsigned ArgNo, uint64_t Bytes);
426
427 /// Extract the alignment for a call or parameter (0=unknown).
428 unsigned getParamAlignment(unsigned ArgNo) const {
429 return AttributeSets.getParamAlignment(ArgNo);
430 }
431
432 /// Extract the number of dereferenceable bytes for a call or
433 /// parameter (0=unknown).
434 /// @param i AttributeList index, referring to a return value or argument.
435 uint64_t getDereferenceableBytes(unsigned i) const {
436 return AttributeSets.getDereferenceableBytes(i);
437 }
438
439 /// Extract the number of dereferenceable bytes for a parameter.
440 /// @param ArgNo Index of an argument, with 0 being the first function arg.
441 uint64_t getParamDereferenceableBytes(unsigned ArgNo) const {
442 return AttributeSets.getParamDereferenceableBytes(ArgNo);
443 }
444
445 /// Extract the number of dereferenceable_or_null bytes for a call or
446 /// parameter (0=unknown).
447 /// @param i AttributeList index, referring to a return value or argument.
448 uint64_t getDereferenceableOrNullBytes(unsigned i) const {
449 return AttributeSets.getDereferenceableOrNullBytes(i);
450 }
451
452 /// Extract the number of dereferenceable_or_null bytes for a
453 /// parameter.
454 /// @param ArgNo AttributeList ArgNo, referring to an argument.
455 uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const {
456 return AttributeSets.getParamDereferenceableOrNullBytes(ArgNo);
457 }
458
459 /// Determine if the function does not access memory.
460 bool doesNotAccessMemory() const {
461 return hasFnAttribute(Attribute::ReadNone);
462 }
463 void setDoesNotAccessMemory() {
464 addFnAttr(Attribute::ReadNone);
465 }
466
467 /// Determine if the function does not access or only reads memory.
468 bool onlyReadsMemory() const {
469 return doesNotAccessMemory() || hasFnAttribute(Attribute::ReadOnly);
470 }
471 void setOnlyReadsMemory() {
472 addFnAttr(Attribute::ReadOnly);
473 }
474
475 /// Determine if the function does not access or only writes memory.
476 bool doesNotReadMemory() const {
477 return doesNotAccessMemory() || hasFnAttribute(Attribute::WriteOnly);
478 }
479 void setDoesNotReadMemory() {
480 addFnAttr(Attribute::WriteOnly);
481 }
482
483 /// Determine if the call can access memmory only using pointers based
484 /// on its arguments.
485 bool onlyAccessesArgMemory() const {
486 return hasFnAttribute(Attribute::ArgMemOnly);
487 }
488 void setOnlyAccessesArgMemory() { addFnAttr(Attribute::ArgMemOnly); }
489
490 /// Determine if the function may only access memory that is
491 /// inaccessible from the IR.
492 bool onlyAccessesInaccessibleMemory() const {
493 return hasFnAttribute(Attribute::InaccessibleMemOnly);
494 }
495 void setOnlyAccessesInaccessibleMemory() {
496 addFnAttr(Attribute::InaccessibleMemOnly);
497 }
498
499 /// Determine if the function may only access memory that is
500 /// either inaccessible from the IR or pointed to by its arguments.
501 bool onlyAccessesInaccessibleMemOrArgMem() const {
502 return hasFnAttribute(Attribute::InaccessibleMemOrArgMemOnly);
503 }
504 void setOnlyAccessesInaccessibleMemOrArgMem() {
505 addFnAttr(Attribute::InaccessibleMemOrArgMemOnly);
506 }
507
508 /// Determine if the function cannot return.
509 bool doesNotReturn() const {
510 return hasFnAttribute(Attribute::NoReturn);
511 }
512 void setDoesNotReturn() {
513 addFnAttr(Attribute::NoReturn);
514 }
515
516 /// Determine if the function should not perform indirect branch tracking.
517 bool doesNoCfCheck() const { return hasFnAttribute(Attribute::NoCfCheck); }
518
519 /// Determine if the function cannot unwind.
520 bool doesNotThrow() const {
521 return hasFnAttribute(Attribute::NoUnwind);
522 }
523 void setDoesNotThrow() {
524 addFnAttr(Attribute::NoUnwind);
525 }
526
527 /// Determine if the call cannot be duplicated.
528 bool cannotDuplicate() const {
529 return hasFnAttribute(Attribute::NoDuplicate);
530 }
531 void setCannotDuplicate() {
532 addFnAttr(Attribute::NoDuplicate);
533 }
534
535 /// Determine if the call is convergent.
536 bool isConvergent() const {
537 return hasFnAttribute(Attribute::Convergent);
538 }
539 void setConvergent() {
540 addFnAttr(Attribute::Convergent);
541 }
542 void setNotConvergent() {
543 removeFnAttr(Attribute::Convergent);
544 }
545
546 /// Determine if the call has sideeffects.
547 bool isSpeculatable() const {
548 return hasFnAttribute(Attribute::Speculatable);
549 }
550 void setSpeculatable() {
551 addFnAttr(Attribute::Speculatable);
552 }
553
554 /// Determine if the function is known not to recurse, directly or
555 /// indirectly.
556 bool doesNotRecurse() const {
557 return hasFnAttribute(Attribute::NoRecurse);
558 }
559 void setDoesNotRecurse() {
560 addFnAttr(Attribute::NoRecurse);
561 }
562
563 /// True if the ABI mandates (or the user requested) that this
564 /// function be in a unwind table.
565 bool hasUWTable() const {
566 return hasFnAttribute(Attribute::UWTable);
567 }
568 void setHasUWTable() {
569 addFnAttr(Attribute::UWTable);
570 }
571
572 /// True if this function needs an unwind table.
573 bool needsUnwindTableEntry() const {
574 return hasUWTable() || !doesNotThrow() || hasPersonalityFn();
575 }
576
577 /// Determine if the function returns a structure through first
578 /// or second pointer argument.
579 bool hasStructRetAttr() const {
580 return AttributeSets.hasParamAttribute(0, Attribute::StructRet) ||
581 AttributeSets.hasParamAttribute(1, Attribute::StructRet);
582 }
583
584 /// Determine if the parameter or return value is marked with NoAlias
585 /// attribute.
586 bool returnDoesNotAlias() const {
587 return AttributeSets.hasAttribute(AttributeList::ReturnIndex,
588 Attribute::NoAlias);
589 }
590 void setReturnDoesNotAlias() {
591 addAttribute(AttributeList::ReturnIndex, Attribute::NoAlias);
592 }
593
594 /// Optimize this function for minimum size (-Oz).
595 bool optForMinSize() const { return hasFnAttribute(Attribute::MinSize); }
596
597 /// Optimize this function for size (-Os) or minimum size (-Oz).
598 bool optForSize() const {
599 return hasFnAttribute(Attribute::OptimizeForSize) || optForMinSize();
600 }
601
602 /// copyAttributesFrom - copy all additional attributes (those not needed to
603 /// create a Function) from the Function Src to this one.
604 void copyAttributesFrom(const Function *Src);
605
606 /// deleteBody - This method deletes the body of the function, and converts
607 /// the linkage to external.
608 ///
609 void deleteBody() {
610 dropAllReferences();
611 setLinkage(ExternalLinkage);
612 }
613
614 /// removeFromParent - This method unlinks 'this' from the containing module,
615 /// but does not delete it.
616 ///
617 void removeFromParent();
618
619 /// eraseFromParent - This method unlinks 'this' from the containing module
620 /// and deletes it.
621 ///
622 void eraseFromParent();
623
624 /// Steal arguments from another function.
625 ///
626 /// Drop this function's arguments and splice in the ones from \c Src.
627 /// Requires that this has no function body.
628 void stealArgumentListFrom(Function &Src);
629
630 /// Get the underlying elements of the Function... the basic block list is
631 /// empty for external functions.
632 ///
633 const BasicBlockListType &getBasicBlockList() const { return BasicBlocks; }
634 BasicBlockListType &getBasicBlockList() { return BasicBlocks; }
635
636 static BasicBlockListType Function::*getSublistAccess(BasicBlock*) {
637 return &Function::BasicBlocks;
638 }
639
640 const BasicBlock &getEntryBlock() const { return front(); }
641 BasicBlock &getEntryBlock() { return front(); }
642
643 //===--------------------------------------------------------------------===//
644 // Symbol Table Accessing functions...
645
646 /// getSymbolTable() - Return the symbol table if any, otherwise nullptr.
647 ///
648 inline ValueSymbolTable *getValueSymbolTable() { return SymTab.get(); }
649 inline const ValueSymbolTable *getValueSymbolTable() const {
650 return SymTab.get();
651 }
652
653 //===--------------------------------------------------------------------===//
654 // BasicBlock iterator forwarding functions
655 //
656 iterator begin() { return BasicBlocks.begin(); }
657 const_iterator begin() const { return BasicBlocks.begin(); }
658 iterator end () { return BasicBlocks.end(); }
659 const_iterator end () const { return BasicBlocks.end(); }
660
661 size_t size() const { return BasicBlocks.size(); }
662 bool empty() const { return BasicBlocks.empty(); }
663 const BasicBlock &front() const { return BasicBlocks.front(); }
664 BasicBlock &front() { return BasicBlocks.front(); }
665 const BasicBlock &back() const { return BasicBlocks.back(); }
666 BasicBlock &back() { return BasicBlocks.back(); }
667
668/// @name Function Argument Iteration
669/// @{
670
671 arg_iterator arg_begin() {
672 CheckLazyArguments();
673 return Arguments;
674 }
675 const_arg_iterator arg_begin() const {
676 CheckLazyArguments();
677 return Arguments;
678 }
679
680 arg_iterator arg_end() {
681 CheckLazyArguments();
682 return Arguments + NumArgs;
683 }
684 const_arg_iterator arg_end() const {
685 CheckLazyArguments();
686 return Arguments + NumArgs;
687 }
688
689 iterator_range<arg_iterator> args() {
690 return make_range(arg_begin(), arg_end());
691 }
692 iterator_range<const_arg_iterator> args() const {
693 return make_range(arg_begin(), arg_end());
694 }
695
696/// @}
697
698 size_t arg_size() const { return NumArgs; }
699 bool arg_empty() const { return arg_size() == 0; }
700
701 /// Check whether this function has a personality function.
702 bool hasPersonalityFn() const {
703 return getSubclassDataFromValue() & (1<<3);
704 }
705
706 /// Get the personality function associated with this function.
707 Constant *getPersonalityFn() const;
708 void setPersonalityFn(Constant *Fn);
709
710 /// Check whether this function has prefix data.
711 bool hasPrefixData() const {
712 return getSubclassDataFromValue() & (1<<1);
713 }
714
715 /// Get the prefix data associated with this function.
716 Constant *getPrefixData() const;
717 void setPrefixData(Constant *PrefixData);
718
719 /// Check whether this function has prologue data.
720 bool hasPrologueData() const {
721 return getSubclassDataFromValue() & (1<<2);
722 }
723
724 /// Get the prologue data associated with this function.
725 Constant *getPrologueData() const;
726 void setPrologueData(Constant *PrologueData);
727
728 /// Print the function to an output stream with an optional
729 /// AssemblyAnnotationWriter.
730 void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW = nullptr,
731 bool ShouldPreserveUseListOrder = false,
732 bool IsForDebug = false) const;
733
734 /// viewCFG - This function is meant for use from the debugger. You can just
735 /// say 'call F->viewCFG()' and a ghostview window should pop up from the
736 /// program, displaying the CFG of the current function with the code for each
737 /// basic block inside. This depends on there being a 'dot' and 'gv' program
738 /// in your path.
739 ///
740 void viewCFG() const;
741
742 /// viewCFGOnly - This function is meant for use from the debugger. It works
743 /// just like viewCFG, but it does not include the contents of basic blocks
744 /// into the nodes, just the label. If you are only interested in the CFG
745 /// this can make the graph smaller.
746 ///
747 void viewCFGOnly() const;
748
749 /// Methods for support type inquiry through isa, cast, and dyn_cast:
750 static bool classof(const Value *V) {
751 return V->getValueID() == Value::FunctionVal;
752 }
753
754 /// dropAllReferences() - This method causes all the subinstructions to "let
755 /// go" of all references that they are maintaining. This allows one to
756 /// 'delete' a whole module at a time, even though there may be circular
757 /// references... first all references are dropped, and all use counts go to
758 /// zero. Then everything is deleted for real. Note that no operations are
759 /// valid on an object that has "dropped all references", except operator
760 /// delete.
761 ///
762 /// Since no other object in the module can have references into the body of a
763 /// function, dropping all references deletes the entire body of the function,
764 /// including any contained basic blocks.
765 ///
766 void dropAllReferences();
767
768 /// hasAddressTaken - returns true if there are any uses of this function
769 /// other than direct calls or invokes to it, or blockaddress expressions.
770 /// Optionally passes back an offending user for diagnostic purposes.
771 ///
772 bool hasAddressTaken(const User** = nullptr) const;
773
774 /// isDefTriviallyDead - Return true if it is trivially safe to remove
775 /// this function definition from the module (because it isn't externally
776 /// visible, does not have its address taken, and has no callers). To make
777 /// this more accurate, call removeDeadConstantUsers first.
778 bool isDefTriviallyDead() const;
779
780 /// callsFunctionThatReturnsTwice - Return true if the function has a call to
781 /// setjmp or other function that gcc recognizes as "returning twice".
782 bool callsFunctionThatReturnsTwice() const;
783
784 /// Set the attached subprogram.
785 ///
786 /// Calls \a setMetadata() with \a LLVMContext::MD_dbg.
787 void setSubprogram(DISubprogram *SP);
788
789 /// Get the attached subprogram.
790 ///
791 /// Calls \a getMetadata() with \a LLVMContext::MD_dbg and casts the result
792 /// to \a DISubprogram.
793 DISubprogram *getSubprogram() const;
794
795 /// Returns true if we should emit debug info for profiling.
796 bool isDebugInfoForProfiling() const;
797
798 /// Check if null pointer dereferencing is considered undefined behavior for
799 /// the function.
800 /// Return value: false => null pointer dereference is undefined.
801 /// Return value: true => null pointer dereference is not undefined.
802 bool nullPointerIsDefined() const;
803
804private:
805 void allocHungoffUselist();
806 template<int Idx> void setHungoffOperand(Constant *C);
807
808 /// Shadow Value::setValueSubclassData with a private forwarding method so
809 /// that subclasses cannot accidentally use it.
810 void setValueSubclassData(unsigned short D) {
811 Value::setValueSubclassData(D);
812 }
813 void setValueSubclassDataBit(unsigned Bit, bool On);
814};
815
816/// Check whether null pointer dereferencing is considered undefined behavior
817/// for a given function or an address space.
818/// Null pointer access in non-zero address space is not considered undefined.
819/// Return value: false => null pointer dereference is undefined.
820/// Return value: true => null pointer dereference is not undefined.
821bool NullPointerIsDefined(const Function *F, unsigned AS = 0);
822
823template <>
824struct OperandTraits<Function> : public HungoffOperandTraits<3> {};
825
826DEFINE_TRANSPARENT_OPERAND_ACCESSORS(Function, Value)
827
828} // end namespace llvm
829
830#endif // LLVM_IR_FUNCTION_H
831