[clang] [llvm] [WIP] Clang ABI Types (PR #133080)
via llvm-commits
llvm-commits at lists.llvm.org
Wed Mar 26 06:32:08 PDT 2025
https://github.com/easyonaadit created https://github.com/llvm/llvm-project/pull/133080
None
>From 16f156dbd83fe0b272f9d485584b1fb9d9a04015 Mon Sep 17 00:00:00 2001
From: easyonaadit <aaditya.alokdeshpande at amd.com>
Date: Fri, 21 Mar 2025 11:37:31 +0530
Subject: [PATCH 1/2] temp commit have annotated the code with some parts of
understanding.
---
LLVMABI/CGFunctionInfo.h | 841 +++++++++++++++++++
clang/include/clang/CodeGen/CGFunctionInfo.h | 2 +-
clang/lib/CodeGen/ABIInfoImpl.cpp | 2 +-
clang/lib/CodeGen/CGCall.cpp | 18 +-
clang/lib/CodeGen/CodeGenAction.cpp | 2 +-
clang/lib/CodeGen/CodeGenModule.cpp | 6 +-
clang/lib/CodeGen/ModuleBuilder.cpp | 2 +-
clang/lib/CodeGen/Targets/AMDGPU.cpp | 2 +-
clang/lib/Parse/ParseAST.cpp | 10 +-
clang/lib/Parse/Parser.cpp | 2 +-
llvm/include/llvm/ADT/FoldingSet.h | 2 +-
11 files changed, 865 insertions(+), 24 deletions(-)
create mode 100644 LLVMABI/CGFunctionInfo.h
diff --git a/LLVMABI/CGFunctionInfo.h b/LLVMABI/CGFunctionInfo.h
new file mode 100644
index 0000000000000..91276e743a8c6
--- /dev/null
+++ b/LLVMABI/CGFunctionInfo.h
@@ -0,0 +1,841 @@
+//==-- CGFunctionInfo.h - Representation of function argument/return types -==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Defines CGFunctionInfo and associated types used in representing the
+// LLVM source types and ABI-coerced types for function arguments and
+// return values.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_CODEGEN_CGFUNCTIONINFO_H
+#define LLVM_CLANG_CODEGEN_CGFUNCTIONINFO_H
+
+#include "clang/AST/CanonicalType.h"
+#include "clang/AST/CharUnits.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/Type.h"
+#include "llvm/IR/DerivedTypes.h"
+#include "llvm/ADT/FoldingSet.h"
+#include "llvm/Support/TrailingObjects.h"
+#include <cassert>
+
+namespace clang {
+namespace CodeGen {
+
+/// ABIArgInfo - Helper class to encapsulate information about how a
+/// specific C type should be passed to or returned from a function.
+class ABIArgInfo {
+public:
+ enum Kind : uint8_t {
+ /// Direct - Pass the argument directly using the normal converted LLVM
+ /// type, or by coercing to another specified type stored in
+ /// 'CoerceToType'). If an offset is specified (in UIntData), then the
+ /// argument passed is offset by some number of bytes in the memory
+ /// representation. A dummy argument is emitted before the real argument
+ /// if the specified type stored in "PaddingType" is not zero.
+ Direct,
+
+ /// Extend - Valid only for integer argument types. Same as 'direct'
+ /// but also emit a zero/sign extension attribute.
+ Extend,
+
+ /// Indirect - Pass the argument indirectly via a hidden pointer with the
+ /// specified alignment (0 indicates default alignment) and address space.
+ Indirect,
+
+ /// IndirectAliased - Similar to Indirect, but the pointer may be to an
+ /// object that is otherwise referenced. The object is known to not be
+ /// modified through any other references for the duration of the call, and
+ /// the callee must not itself modify the object. Because C allows
+ /// parameter variables to be modified and guarantees that they have unique
+ /// addresses, the callee must defensively copy the object into a local
+ /// variable if it might be modified or its address might be compared.
+ /// Since those are uncommon, in principle this convention allows programs
+ /// to avoid copies in more situations. However, it may introduce *extra*
+ /// copies if the callee fails to prove that a copy is unnecessary and the
+ /// caller naturally produces an unaliased object for the argument.
+ IndirectAliased,
+
+ /// Ignore - Ignore the argument (treat as void). Useful for void and
+ /// empty structs.
+ Ignore,
+
+ /// Expand - Only valid for aggregate argument types. The structure should
+ /// be expanded into consecutive arguments for its constituent fields.
+ /// Currently expand is only allowed on structures whose fields
+ /// are all scalar types or are themselves expandable types.
+ Expand,
+
+ /// CoerceAndExpand - Only valid for aggregate argument types. The
+ /// structure should be expanded into consecutive arguments corresponding
+ /// to the non-array elements of the type stored in CoerceToType.
+ /// Array elements in the type are assumed to be padding and skipped.
+ CoerceAndExpand,
+
+ /// InAlloca - Pass the argument directly using the LLVM inalloca attribute.
+ /// This is similar to indirect with byval, except it only applies to
+ /// arguments stored in memory and forbids any implicit copies. When
+ /// applied to a return type, it means the value is returned indirectly via
+ /// an implicit sret parameter stored in the argument struct.
+ InAlloca,
+ KindFirst = Direct,
+ KindLast = InAlloca
+ };
+
+private:
+ llvm::Type *TypeData; // canHaveCoerceToType()
+ union {
+ llvm::Type *PaddingType; // canHavePaddingType()
+ llvm::Type *UnpaddedCoerceAndExpandType; // isCoerceAndExpand()
+ };
+ struct DirectAttrInfo {
+ unsigned Offset;
+ unsigned Align;
+ };
+ struct IndirectAttrInfo {
+ unsigned Align;
+ unsigned AddrSpace;
+ };
+ union {
+ DirectAttrInfo DirectAttr; // isDirect() || isExtend()
+ IndirectAttrInfo IndirectAttr; // isIndirect()
+ unsigned AllocaFieldIndex; // isInAlloca()
+ };
+ Kind TheKind;
+ bool PaddingInReg : 1;
+ bool InAllocaSRet : 1; // isInAlloca()
+ bool InAllocaIndirect : 1;// isInAlloca()
+ bool IndirectByVal : 1; // isIndirect()
+ bool IndirectRealign : 1; // isIndirect()
+ bool SRetAfterThis : 1; // isIndirect()
+ bool InReg : 1; // isDirect() || isExtend() || isIndirect()
+ bool CanBeFlattened: 1; // isDirect()
+ bool SignExt : 1; // isExtend()
+ bool ZeroExt : 1; // isExtend()
+
+ bool canHavePaddingType() const {
+ return isDirect() || isExtend() || isIndirect() || isIndirectAliased() ||
+ isExpand();
+ }
+ void setPaddingType(llvm::Type *T) {
+ assert(canHavePaddingType());
+ PaddingType = T;
+ }
+
+ void setUnpaddedCoerceToType(llvm::Type *T) {
+ assert(isCoerceAndExpand());
+ UnpaddedCoerceAndExpandType = T;
+ }
+
+public:
+ ABIArgInfo(Kind K = Direct)
+ : TypeData(nullptr), PaddingType(nullptr), DirectAttr{0, 0}, TheKind(K),
+ PaddingInReg(false), InAllocaSRet(false),
+ InAllocaIndirect(false), IndirectByVal(false), IndirectRealign(false),
+ SRetAfterThis(false), InReg(false), CanBeFlattened(false),
+ SignExt(false), ZeroExt(false) {}
+
+ static ABIArgInfo getDirect(llvm::Type *T = nullptr, unsigned Offset = 0,
+ llvm::Type *Padding = nullptr,
+ bool CanBeFlattened = true, unsigned Align = 0) {
+ auto AI = ABIArgInfo(Direct);
+ AI.setCoerceToType(T);
+ AI.setPaddingType(Padding);
+ AI.setDirectOffset(Offset);
+ AI.setDirectAlign(Align);
+ AI.setCanBeFlattened(CanBeFlattened);
+ return AI;
+ }
+ static ABIArgInfo getDirectInReg(llvm::Type *T = nullptr) {
+ auto AI = getDirect(T);
+ AI.setInReg(true);
+ return AI;
+ }
+
+ static ABIArgInfo getSignExtend(QualType Ty, llvm::Type *T = nullptr) {
+ assert(Ty->isIntegralOrEnumerationType() && "Unexpected QualType");
+ auto AI = ABIArgInfo(Extend);
+ AI.setCoerceToType(T);
+ AI.setPaddingType(nullptr);
+ AI.setDirectOffset(0);
+ AI.setDirectAlign(0);
+ AI.setSignExt(true);
+ return AI;
+ }
+
+ static ABIArgInfo getZeroExtend(QualType Ty, llvm::Type *T = nullptr) {
+ assert(Ty->isIntegralOrEnumerationType() && "Unexpected QualType");
+ auto AI = ABIArgInfo(Extend);
+ AI.setCoerceToType(T);
+ AI.setPaddingType(nullptr);
+ AI.setDirectOffset(0);
+ AI.setDirectAlign(0);
+ AI.setZeroExt(true);
+ return AI;
+ }
+
+ // ABIArgInfo will record the argument as being extended based on the sign
+ // of its type. Produces a sign or zero extension.
+ static ABIArgInfo getExtend(QualType Ty, llvm::Type *T = nullptr) {
+ assert(Ty->isIntegralOrEnumerationType() && "Unexpected QualType");
+ if (Ty->hasSignedIntegerRepresentation())
+ return getSignExtend(Ty, T);
+ return getZeroExtend(Ty, T);
+ }
+
+ // Struct in register marked explicitly as not needing extension.
+ static ABIArgInfo getNoExtend(llvm::IntegerType *T) {
+ auto AI = ABIArgInfo(Extend);
+ AI.setCoerceToType(T);
+ AI.setPaddingType(nullptr);
+ AI.setDirectOffset(0);
+ AI.setDirectAlign(0);
+ return AI;
+ }
+
+ static ABIArgInfo getExtendInReg(QualType Ty, llvm::Type *T = nullptr) {
+ auto AI = getExtend(Ty, T);
+ AI.setInReg(true);
+ return AI;
+ }
+ static ABIArgInfo getIgnore() {
+ return ABIArgInfo(Ignore);
+ }
+ static ABIArgInfo getIndirect(CharUnits Alignment, unsigned AddrSpace,
+ bool ByVal = true, bool Realign = false,
+ llvm::Type *Padding = nullptr) {
+ auto AI = ABIArgInfo(Indirect);
+ AI.setIndirectAlign(Alignment);
+ AI.setIndirectByVal(ByVal);
+ AI.setIndirectRealign(Realign);
+ AI.setSRetAfterThis(false);
+ AI.setPaddingType(Padding);
+ AI.setIndirectAddrSpace(AddrSpace);
+ return AI;
+ }
+
+ /// Pass this in memory using the IR byref attribute.
+ static ABIArgInfo getIndirectAliased(CharUnits Alignment, unsigned AddrSpace,
+ bool Realign = false,
+ llvm::Type *Padding = nullptr) {
+ auto AI = ABIArgInfo(IndirectAliased);
+ AI.setIndirectAlign(Alignment);
+ AI.setIndirectRealign(Realign);
+ AI.setPaddingType(Padding);
+ AI.setIndirectAddrSpace(AddrSpace);
+ return AI;
+ }
+
+ static ABIArgInfo getIndirectInReg(CharUnits Alignment, bool ByVal = true,
+ bool Realign = false) {
+ auto AI = getIndirect(Alignment, 0, ByVal, Realign);
+ AI.setInReg(true);
+ return AI;
+ }
+ static ABIArgInfo getInAlloca(unsigned FieldIndex, bool Indirect = false) {
+ auto AI = ABIArgInfo(InAlloca);
+ AI.setInAllocaFieldIndex(FieldIndex);
+ AI.setInAllocaIndirect(Indirect);
+ return AI;
+ }
+ static ABIArgInfo getExpand() {
+ auto AI = ABIArgInfo(Expand);
+ AI.setPaddingType(nullptr);
+ return AI;
+ }
+ static ABIArgInfo getExpandWithPadding(bool PaddingInReg,
+ llvm::Type *Padding) {
+ auto AI = getExpand();
+ AI.setPaddingInReg(PaddingInReg);
+ AI.setPaddingType(Padding);
+ return AI;
+ }
+
+ /// \param unpaddedCoerceToType The coerce-to type with padding elements
+ /// removed, canonicalized to a single element if it would otherwise
+ /// have exactly one element.
+ static ABIArgInfo getCoerceAndExpand(llvm::StructType *coerceToType,
+ llvm::Type *unpaddedCoerceToType) {
+#ifndef NDEBUG
+ // Check that unpaddedCoerceToType has roughly the right shape.
+
+ // Assert that we only have a struct type if there are multiple elements.
+ auto unpaddedStruct = dyn_cast<llvm::StructType>(unpaddedCoerceToType);
+ assert(!unpaddedStruct || unpaddedStruct->getNumElements() != 1);
+
+ // Assert that all the non-padding elements have a corresponding element
+ // in the unpadded type.
+ unsigned unpaddedIndex = 0;
+ for (auto eltType : coerceToType->elements()) {
+ if (isPaddingForCoerceAndExpand(eltType))
+ continue;
+ unpaddedIndex++;
+ }
+
+ // Assert that there aren't extra elements in the unpadded type.
+ if (unpaddedStruct) {
+ assert(unpaddedStruct->getNumElements() == unpaddedIndex);
+ } else {
+ assert(unpaddedIndex == 1);
+ }
+#endif
+
+ auto AI = ABIArgInfo(CoerceAndExpand);
+ AI.setCoerceToType(coerceToType);
+ AI.setUnpaddedCoerceToType(unpaddedCoerceToType);
+ return AI;
+ }
+
+ static bool isPaddingForCoerceAndExpand(llvm::Type *eltType) {
+ return eltType->isArrayTy() &&
+ eltType->getArrayElementType()->isIntegerTy(8);
+ }
+
+ Kind getKind() const { return TheKind; }
+ bool isDirect() const { return TheKind == Direct; }
+ bool isInAlloca() const { return TheKind == InAlloca; }
+ bool isExtend() const { return TheKind == Extend; }
+ bool isIgnore() const { return TheKind == Ignore; }
+ bool isIndirect() const { return TheKind == Indirect; }
+ bool isIndirectAliased() const { return TheKind == IndirectAliased; }
+ bool isExpand() const { return TheKind == Expand; }
+ bool isCoerceAndExpand() const { return TheKind == CoerceAndExpand; }
+
+ bool canHaveCoerceToType() const {
+ return isDirect() || isExtend() || isCoerceAndExpand();
+ }
+
+ // Direct/Extend accessors
+ unsigned getDirectOffset() const {
+ assert((isDirect() || isExtend()) && "Not a direct or extend kind");
+ return DirectAttr.Offset;
+ }
+ void setDirectOffset(unsigned Offset) {
+ assert((isDirect() || isExtend()) && "Not a direct or extend kind");
+ DirectAttr.Offset = Offset;
+ }
+
+ unsigned getDirectAlign() const {
+ assert((isDirect() || isExtend()) && "Not a direct or extend kind");
+ return DirectAttr.Align;
+ }
+ void setDirectAlign(unsigned Align) {
+ assert((isDirect() || isExtend()) && "Not a direct or extend kind");
+ DirectAttr.Align = Align;
+ }
+
+ bool isSignExt() const {
+ assert(isExtend() && (SignExt + ZeroExt <= 1) && "Invalid kind / flags!");
+ return SignExt;
+ }
+ void setSignExt(bool SExt) {
+ assert(isExtend() && "Invalid kind!");
+ SignExt = SExt;
+ }
+
+ bool isZeroExt() const {
+ assert(isExtend() && (SignExt + ZeroExt <= 1) && "Invalid kind / flags!");
+ return ZeroExt;
+ }
+ void setZeroExt(bool ZExt) {
+ assert(isExtend() && "Invalid kind!");
+ ZeroExt = ZExt;
+ }
+
+ bool isNoExt() const {
+ assert(isExtend() && (SignExt + ZeroExt <= 1) && "Invalid kind / flags!");
+ return !SignExt && !ZeroExt;
+ }
+
+ llvm::Type *getPaddingType() const {
+ return (canHavePaddingType() ? PaddingType : nullptr);
+ }
+
+ bool getPaddingInReg() const {
+ return PaddingInReg;
+ }
+ void setPaddingInReg(bool PIR) {
+ PaddingInReg = PIR;
+ }
+
+ llvm::Type *getCoerceToType() const {
+ assert(canHaveCoerceToType() && "Invalid kind!");
+ return TypeData;
+ }
+
+ void setCoerceToType(llvm::Type *T) {
+ assert(canHaveCoerceToType() && "Invalid kind!");
+ TypeData = T;
+ }
+
+ llvm::StructType *getCoerceAndExpandType() const {
+ assert(isCoerceAndExpand());
+ return cast<llvm::StructType>(TypeData);
+ }
+
+ llvm::Type *getUnpaddedCoerceAndExpandType() const {
+ assert(isCoerceAndExpand());
+ return UnpaddedCoerceAndExpandType;
+ }
+
+ ArrayRef<llvm::Type *>getCoerceAndExpandTypeSequence() const {
+ assert(isCoerceAndExpand());
+ if (auto structTy =
+ dyn_cast<llvm::StructType>(UnpaddedCoerceAndExpandType)) {
+ return structTy->elements();
+ } else {
+ return llvm::ArrayRef(&UnpaddedCoerceAndExpandType, 1);
+ }
+ }
+
+ bool getInReg() const {
+ assert((isDirect() || isExtend() || isIndirect()) && "Invalid kind!");
+ return InReg;
+ }
+
+ void setInReg(bool IR) {
+ assert((isDirect() || isExtend() || isIndirect()) && "Invalid kind!");
+ InReg = IR;
+ }
+
+ // Indirect accessors
+ CharUnits getIndirectAlign() const {
+ assert((isIndirect() || isIndirectAliased()) && "Invalid kind!");
+ return CharUnits::fromQuantity(IndirectAttr.Align);
+ }
+ void setIndirectAlign(CharUnits IA) {
+ assert((isIndirect() || isIndirectAliased()) && "Invalid kind!");
+ IndirectAttr.Align = IA.getQuantity();
+ }
+
+ bool getIndirectByVal() const {
+ assert(isIndirect() && "Invalid kind!");
+ return IndirectByVal;
+ }
+ void setIndirectByVal(bool IBV) {
+ assert(isIndirect() && "Invalid kind!");
+ IndirectByVal = IBV;
+ }
+
+ unsigned getIndirectAddrSpace() const {
+ assert((isIndirect() || isIndirectAliased()) && "Invalid kind!");
+ return IndirectAttr.AddrSpace;
+ }
+
+ void setIndirectAddrSpace(unsigned AddrSpace) {
+ assert((isIndirect() || isIndirectAliased()) && "Invalid kind!");
+ IndirectAttr.AddrSpace = AddrSpace;
+ }
+
+ bool getIndirectRealign() const {
+ assert((isIndirect() || isIndirectAliased()) && "Invalid kind!");
+ return IndirectRealign;
+ }
+ void setIndirectRealign(bool IR) {
+ assert((isIndirect() || isIndirectAliased()) && "Invalid kind!");
+ IndirectRealign = IR;
+ }
+
+ bool isSRetAfterThis() const {
+ assert(isIndirect() && "Invalid kind!");
+ return SRetAfterThis;
+ }
+ void setSRetAfterThis(bool AfterThis) {
+ assert(isIndirect() && "Invalid kind!");
+ SRetAfterThis = AfterThis;
+ }
+
+ unsigned getInAllocaFieldIndex() const {
+ assert(isInAlloca() && "Invalid kind!");
+ return AllocaFieldIndex;
+ }
+ void setInAllocaFieldIndex(unsigned FieldIndex) {
+ assert(isInAlloca() && "Invalid kind!");
+ AllocaFieldIndex = FieldIndex;
+ }
+
+ unsigned getInAllocaIndirect() const {
+ assert(isInAlloca() && "Invalid kind!");
+ return InAllocaIndirect;
+ }
+ void setInAllocaIndirect(bool Indirect) {
+ assert(isInAlloca() && "Invalid kind!");
+ InAllocaIndirect = Indirect;
+ }
+
+ /// Return true if this field of an inalloca struct should be returned
+ /// to implement a struct return calling convention.
+ bool getInAllocaSRet() const {
+ assert(isInAlloca() && "Invalid kind!");
+ return InAllocaSRet;
+ }
+
+ void setInAllocaSRet(bool SRet) {
+ assert(isInAlloca() && "Invalid kind!");
+ InAllocaSRet = SRet;
+ }
+
+ bool getCanBeFlattened() const {
+ assert(isDirect() && "Invalid kind!");
+ return CanBeFlattened;
+ }
+
+ void setCanBeFlattened(bool Flatten) {
+ assert(isDirect() && "Invalid kind!");
+ CanBeFlattened = Flatten;
+ }
+
+ void dump() const;
+};
+
+/// A class for recording the number of arguments that a function
+/// signature requires.
+class RequiredArgs {
+ /// The number of required arguments, or ~0 if the signature does
+ /// not permit optional arguments.
+ unsigned NumRequired;
+public:
+ enum All_t { All };
+
+ RequiredArgs(All_t _) : NumRequired(~0U) {}
+ explicit RequiredArgs(unsigned n) : NumRequired(n) {
+ assert(n != ~0U);
+ }
+
+ /// Compute the arguments required by the given formal prototype,
+ /// given that there may be some additional, non-formal arguments
+ /// in play.
+ ///
+ /// If FD is not null, this will consider pass_object_size params in FD.
+ static RequiredArgs forPrototypePlus(const FunctionProtoType *prototype,
+ unsigned additional) {
+ if (!prototype->isVariadic()) return All;
+
+ if (prototype->hasExtParameterInfos())
+ additional += llvm::count_if(
+ prototype->getExtParameterInfos(),
+ [](const FunctionProtoType::ExtParameterInfo &ExtInfo) {
+ return ExtInfo.hasPassObjectSize();
+ });
+
+ return RequiredArgs(prototype->getNumParams() + additional);
+ }
+
+ static RequiredArgs forPrototypePlus(CanQual<FunctionProtoType> prototype,
+ unsigned additional) {
+ return forPrototypePlus(prototype.getTypePtr(), additional);
+ }
+
+ static RequiredArgs forPrototype(const FunctionProtoType *prototype) {
+ return forPrototypePlus(prototype, 0);
+ }
+
+ static RequiredArgs forPrototype(CanQual<FunctionProtoType> prototype) {
+ return forPrototypePlus(prototype.getTypePtr(), 0);
+ }
+
+ bool allowsOptionalArgs() const { return NumRequired != ~0U; }
+ unsigned getNumRequiredArgs() const {
+ assert(allowsOptionalArgs());
+ return NumRequired;
+ }
+
+ /// Return true if the argument at a given index is required.
+ bool isRequiredArg(unsigned argIdx) const {
+ return argIdx == ~0U || argIdx < NumRequired;
+ }
+
+ unsigned getOpaqueData() const { return NumRequired; }
+ static RequiredArgs getFromOpaqueData(unsigned value) {
+ if (value == ~0U) return All;
+ return RequiredArgs(value);
+ }
+};
+
+// Implementation detail of CGFunctionInfo, factored out so it can be named
+// in the TrailingObjects base class of CGFunctionInfo.
+struct CGFunctionInfoArgInfo {
+ CanQualType type;
+ ABIArgInfo info;
+};
+
+/// CGFunctionInfo - Class to encapsulate the information about a
+/// function definition.
+class CGFunctionInfo final
+ : public llvm::FoldingSetNode,
+ private llvm::TrailingObjects<CGFunctionInfo, CGFunctionInfoArgInfo,
+ FunctionProtoType::ExtParameterInfo> {
+ typedef CGFunctionInfoArgInfo ArgInfo;
+ typedef FunctionProtoType::ExtParameterInfo ExtParameterInfo;
+
+ /// The LLVM::CallingConv to use for this function (as specified by the
+ /// user).
+ unsigned CallingConvention : 8;
+
+ /// The LLVM::CallingConv to actually use for this function, which may
+ /// depend on the ABI.
+ unsigned EffectiveCallingConvention : 8;
+
+ /// The clang::CallingConv that this was originally created with.
+ LLVM_PREFERRED_TYPE(CallingConv)
+ unsigned ASTCallingConvention : 6;
+
+ /// Whether this is an instance method.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned InstanceMethod : 1;
+
+ /// Whether this is a chain call.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned ChainCall : 1;
+
+ /// Whether this function is called by forwarding arguments.
+ /// This doesn't support inalloca or varargs.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned DelegateCall : 1;
+
+ /// Whether this function is a CMSE nonsecure call
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned CmseNSCall : 1;
+
+ /// Whether this function is noreturn.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned NoReturn : 1;
+
+ /// Whether this function is returns-retained.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned ReturnsRetained : 1;
+
+ /// Whether this function saved caller registers.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned NoCallerSavedRegs : 1;
+
+ /// How many arguments to pass inreg.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned HasRegParm : 1;
+ unsigned RegParm : 3;
+
+ /// Whether this function has nocf_check attribute.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned NoCfCheck : 1;
+
+ /// Log 2 of the maximum vector width.
+ unsigned MaxVectorWidth : 4;
+
+ RequiredArgs Required;
+
+ /// The struct representing all arguments passed in memory. Only used when
+ /// passing non-trivial types with inalloca. Not part of the profile.
+ llvm::StructType *ArgStruct;
+ unsigned ArgStructAlign : 31;
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned HasExtParameterInfos : 1;
+
+ unsigned NumArgs;
+
+ ArgInfo *getArgsBuffer() {
+ return getTrailingObjects<ArgInfo>();
+ }
+ const ArgInfo *getArgsBuffer() const {
+ return getTrailingObjects<ArgInfo>();
+ }
+
+ ExtParameterInfo *getExtParameterInfosBuffer() {
+ return getTrailingObjects<ExtParameterInfo>();
+ }
+ const ExtParameterInfo *getExtParameterInfosBuffer() const{
+ return getTrailingObjects<ExtParameterInfo>();
+ }
+
+ CGFunctionInfo() : Required(RequiredArgs::All) {}
+
+public:
+ static CGFunctionInfo *
+ create(unsigned llvmCC, bool instanceMethod, bool chainCall,
+ bool delegateCall, const FunctionType::ExtInfo &extInfo,
+ ArrayRef<ExtParameterInfo> paramInfos, CanQualType resultType,
+ ArrayRef<CanQualType> argTypes, RequiredArgs required);
+ void operator delete(void *p) { ::operator delete(p); }
+
+ // Friending class TrailingObjects is apparently not good enough for MSVC,
+ // so these have to be public.
+ friend class TrailingObjects;
+ size_t numTrailingObjects(OverloadToken<ArgInfo>) const {
+ return NumArgs + 1;
+ }
+ size_t numTrailingObjects(OverloadToken<ExtParameterInfo>) const {
+ return (HasExtParameterInfos ? NumArgs : 0);
+ }
+
+ typedef const ArgInfo *const_arg_iterator;
+ typedef ArgInfo *arg_iterator;
+
+ MutableArrayRef<ArgInfo> arguments() {
+ return MutableArrayRef<ArgInfo>(arg_begin(), NumArgs);
+ }
+ ArrayRef<ArgInfo> arguments() const {
+ return ArrayRef<ArgInfo>(arg_begin(), NumArgs);
+ }
+
+ const_arg_iterator arg_begin() const { return getArgsBuffer() + 1; }
+ const_arg_iterator arg_end() const { return getArgsBuffer() + 1 + NumArgs; }
+ arg_iterator arg_begin() { return getArgsBuffer() + 1; }
+ arg_iterator arg_end() { return getArgsBuffer() + 1 + NumArgs; }
+
+ unsigned arg_size() const { return NumArgs; }
+
+ bool isVariadic() const { return Required.allowsOptionalArgs(); }
+ RequiredArgs getRequiredArgs() const { return Required; }
+ unsigned getNumRequiredArgs() const {
+ return isVariadic() ? getRequiredArgs().getNumRequiredArgs() : arg_size();
+ }
+
+ bool isInstanceMethod() const { return InstanceMethod; }
+
+ bool isChainCall() const { return ChainCall; }
+
+ bool isDelegateCall() const { return DelegateCall; }
+
+ bool isCmseNSCall() const { return CmseNSCall; }
+
+ bool isNoReturn() const { return NoReturn; }
+
+ /// In ARC, whether this function retains its return value. This
+ /// is not always reliable for call sites.
+ bool isReturnsRetained() const { return ReturnsRetained; }
+
+ /// Whether this function no longer saves caller registers.
+ bool isNoCallerSavedRegs() const { return NoCallerSavedRegs; }
+
+ /// Whether this function has nocf_check attribute.
+ bool isNoCfCheck() const { return NoCfCheck; }
+
+ /// getASTCallingConvention() - Return the AST-specified calling
+ /// convention.
+ CallingConv getASTCallingConvention() const {
+ return CallingConv(ASTCallingConvention);
+ }
+
+ /// getCallingConvention - Return the user specified calling
+ /// convention, which has been translated into an LLVM CC. //this is important, that clang/ast calling convention has been translated into an llvm (target specific?) calling convention.
+ unsigned getCallingConvention() const { return CallingConvention; }
+
+ /// getEffectiveCallingConvention - Return the actual calling convention to
+ /// use, which may depend on the ABI.
+ unsigned getEffectiveCallingConvention() const {
+ return EffectiveCallingConvention;
+ }
+ void setEffectiveCallingConvention(unsigned Value) {
+ EffectiveCallingConvention = Value;
+ }
+
+ bool getHasRegParm() const { return HasRegParm; }
+ unsigned getRegParm() const { return RegParm; }
+
+ FunctionType::ExtInfo getExtInfo() const {
+ return FunctionType::ExtInfo(isNoReturn(), getHasRegParm(), getRegParm(),
+ getASTCallingConvention(), isReturnsRetained(),
+ isNoCallerSavedRegs(), isNoCfCheck(),
+ isCmseNSCall());
+ }
+
+ CanQualType getReturnType() const { return getArgsBuffer()[0].type; }
+
+ ABIArgInfo &getReturnInfo() { return getArgsBuffer()[0].info; }
+ const ABIArgInfo &getReturnInfo() const { return getArgsBuffer()[0].info; }
+
+ ArrayRef<ExtParameterInfo> getExtParameterInfos() const {
+ if (!HasExtParameterInfos) return {};
+ return llvm::ArrayRef(getExtParameterInfosBuffer(), NumArgs);
+ }
+ ExtParameterInfo getExtParameterInfo(unsigned argIndex) const {
+ assert(argIndex <= NumArgs);
+ if (!HasExtParameterInfos) return ExtParameterInfo();
+ return getExtParameterInfos()[argIndex];
+ }
+
+ /// Return true if this function uses inalloca arguments.
+ bool usesInAlloca() const { return ArgStruct; }
+
+ /// Get the struct type used to represent all the arguments in memory.
+ llvm::StructType *getArgStruct() const { return ArgStruct; }
+ CharUnits getArgStructAlignment() const {
+ return CharUnits::fromQuantity(ArgStructAlign);
+ }
+ void setArgStruct(llvm::StructType *Ty, CharUnits Align) {
+ ArgStruct = Ty;
+ ArgStructAlign = Align.getQuantity();
+ }
+
+ /// Return the maximum vector width in the arguments.
+ unsigned getMaxVectorWidth() const {
+ return MaxVectorWidth ? 1U << (MaxVectorWidth - 1) : 0;
+ }
+
+ /// Set the maximum vector width in the arguments.
+ void setMaxVectorWidth(unsigned Width) {
+ assert(llvm::isPowerOf2_32(Width) && "Expected power of 2 vector");
+ MaxVectorWidth = llvm::countr_zero(Width) + 1;
+ }
+
+ void Profile(llvm::FoldingSetNodeID &ID) {
+ ID.AddInteger(getASTCallingConvention());
+ ID.AddBoolean(InstanceMethod);
+ ID.AddBoolean(ChainCall);
+ ID.AddBoolean(DelegateCall);
+ ID.AddBoolean(NoReturn);
+ ID.AddBoolean(ReturnsRetained);
+ ID.AddBoolean(NoCallerSavedRegs);
+ ID.AddBoolean(HasRegParm);
+ ID.AddInteger(RegParm);
+ ID.AddBoolean(NoCfCheck);
+ ID.AddBoolean(CmseNSCall);
+ ID.AddInteger(Required.getOpaqueData());
+ ID.AddBoolean(HasExtParameterInfos);
+ if (HasExtParameterInfos) {
+ for (auto paramInfo : getExtParameterInfos())
+ ID.AddInteger(paramInfo.getOpaqueValue());
+ }
+ getReturnType().Profile(ID);
+ for (const auto &I : arguments())
+ I.type.Profile(ID);
+ }
+ static void Profile(llvm::FoldingSetNodeID &ID, bool InstanceMethod,
+ bool ChainCall, bool IsDelegateCall,
+ const FunctionType::ExtInfo &info,
+ ArrayRef<ExtParameterInfo> paramInfos,
+ RequiredArgs required, CanQualType resultType,
+ ArrayRef<CanQualType> argTypes) {
+ ID.AddInteger(info.getCC());
+ ID.AddBoolean(InstanceMethod);
+ ID.AddBoolean(ChainCall);
+ ID.AddBoolean(IsDelegateCall);
+ ID.AddBoolean(info.getNoReturn());
+ ID.AddBoolean(info.getProducesResult());
+ ID.AddBoolean(info.getNoCallerSavedRegs());
+ ID.AddBoolean(info.getHasRegParm());
+ ID.AddInteger(info.getRegParm());
+ ID.AddBoolean(info.getNoCfCheck());
+ ID.AddBoolean(info.getCmseNSCall());
+ ID.AddInteger(required.getOpaqueData());
+ ID.AddBoolean(!paramInfos.empty());
+ if (!paramInfos.empty()) {
+ for (auto paramInfo : paramInfos)
+ ID.AddInteger(paramInfo.getOpaqueValue());
+ }
+ resultType.Profile(ID);
+ for (ArrayRef<CanQualType>::iterator
+ i = argTypes.begin(), e = argTypes.end(); i != e; ++i) {
+ i->Profile(ID);
+ }
+ }
+};
+
+} // end namespace CodeGen
+} // end namespace clang
+
+#endif
diff --git a/clang/include/clang/CodeGen/CGFunctionInfo.h b/clang/include/clang/CodeGen/CGFunctionInfo.h
index 040ee025afaa8..91276e743a8c6 100644
--- a/clang/include/clang/CodeGen/CGFunctionInfo.h
+++ b/clang/include/clang/CodeGen/CGFunctionInfo.h
@@ -721,7 +721,7 @@ class CGFunctionInfo final
}
/// getCallingConvention - Return the user specified calling
- /// convention, which has been translated into an LLVM CC.
+ /// convention, which has been translated into an LLVM CC. //this is important, that clang/ast calling convention has been translated into an llvm (target specific?) calling convention.
unsigned getCallingConvention() const { return CallingConvention; }
/// getEffectiveCallingConvention - Return the actual calling convention to
diff --git a/clang/lib/CodeGen/ABIInfoImpl.cpp b/clang/lib/CodeGen/ABIInfoImpl.cpp
index 0a612d3461dc2..dcccebb8daad7 100644
--- a/clang/lib/CodeGen/ABIInfoImpl.cpp
+++ b/clang/lib/CodeGen/ABIInfoImpl.cpp
@@ -62,7 +62,7 @@ ABIArgInfo DefaultABIInfo::classifyReturnType(QualType RetTy) const {
: getContext().LongLongTy))
return getNaturalAlignIndirect(RetTy,
getDataLayout().getAllocaAddrSpace());
-
+// what is a promotable integer type?
return (isPromotableIntegerTypeForABI(RetTy) ? ABIArgInfo::getExtend(RetTy)
: ABIArgInfo::getDirect());
}
diff --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp
index 7aa77e55dbfcc..0f0b7788fc450 100644
--- a/clang/lib/CodeGen/CGCall.cpp
+++ b/clang/lib/CodeGen/CGCall.cpp
@@ -46,7 +46,7 @@ using namespace clang;
using namespace CodeGen;
/***/
-
+// clang and llvm have different calling conventions? what is it used for? what does it do?
unsigned CodeGenTypes::ClangCallConvToLLVMCallConv(CallingConv CC) {
switch (CC) {
default: return llvm::CallingConv::C;
@@ -217,7 +217,7 @@ arrangeLLVMFunctionInfo(CodeGenTypes &CGT, bool instanceMethod,
}
/// Arrange the argument and result information for a value of the
-/// given freestanding function type.
+/// given freestanding function type. // what does this mean??
const CGFunctionInfo &
CodeGenTypes::arrangeFreeFunctionType(CanQual<FunctionProtoType> FTP) {
SmallVector<CanQualType, 16> argTypes;
@@ -800,7 +800,7 @@ void computeSPIRKernelABIInfo(CodeGenModule &CGM, CGFunctionInfo &FI);
/// Arrange the argument and result information for an abstract value
/// of a given function type. This is the method which all of the
-/// above functions ultimately defer to.
+/// above functions ultimately defer to. // this is important, what is this? what does it mean?
const CGFunctionInfo &CodeGenTypes::arrangeLLVMFunctionInfo(
CanQualType resultType, FnInfoOpts opts, ArrayRef<CanQualType> argTypes,
FunctionType::ExtInfo info,
@@ -830,13 +830,13 @@ const CGFunctionInfo &CodeGenTypes::arrangeLLVMFunctionInfo(
// Construct the function info. We co-allocate the ArgInfos.
FI = CGFunctionInfo::create(CC, isInstanceMethod, isChainCall, isDelegateCall,
info, paramInfos, resultType, argTypes, required);
- FunctionInfos.InsertNode(FI, insertPos);
+ FunctionInfos.InsertNode(FI, insertPos); //what is this inserting? is it inserting a function call node in the IR module?
bool inserted = FunctionsBeingProcessed.insert(FI).second;
(void)inserted;
assert(inserted && "Recursively being processed?");
- // Compute ABI information.
+ // Compute ABI information. //why do we need the ABI info at this point? is it that first we add the positino of the funciton call in the IR module? and then before putting any of the parameters or any of the inputs or anything, we need to use the abi info.
if (CC == llvm::CallingConv::SPIR_KERNEL) {
// Force target independent argument handling for the host visible
// kernel functions.
@@ -844,7 +844,7 @@ const CGFunctionInfo &CodeGenTypes::arrangeLLVMFunctionInfo(
} else if (info.getCC() == CC_Swift || info.getCC() == CC_SwiftAsync) {
swiftcall::computeABIInfo(CGM, *FI);
} else {
- CGM.getABIInfo().computeInfo(*FI);
+ CGM.getABIInfo().computeInfo(*FI); //this is going into compute info. but what is it doing there? is it just setting up the information needed for lowering, or is it actually doing the lowering?
}
// Loop over all of the computed argument and return value info. If any of
@@ -863,7 +863,7 @@ const CGFunctionInfo &CodeGenTypes::arrangeLLVMFunctionInfo(
return *FI;
}
-
+// this is important. this object seems to hold both information about the clang calling convention as well as the llvm calling convention. maybe its a mapping between the two. also it has an AST field.
CGFunctionInfo *CGFunctionInfo::create(unsigned llvmCC, bool instanceMethod,
bool chainCall, bool delegateCall,
const FunctionType::ExtInfo &info,
@@ -5187,7 +5187,7 @@ RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
ArgMemory = RawAddress(AI, ArgStruct, Align);
}
- ClangToLLVMArgMapping IRFunctionArgs(CGM.getContext(), CallInfo);
+ ClangToLLVMArgMapping IRFunctionArgs(CGM.getContext(), CallInfo); // --> this seems imp
SmallVector<llvm::Value *, 16> IRCallArgs(IRFunctionArgs.totalIRArgs());
// If the call returns a temporary with struct return, create a temporary
@@ -5251,7 +5251,7 @@ RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
"Mismatch between function signature & arguments.");
unsigned ArgNo = 0;
CGFunctionInfo::const_arg_iterator info_it = CallInfo.arg_begin();
- for (CallArgList::const_iterator I = CallArgs.begin(), E = CallArgs.end();
+ for (CallArgList::const_iterator I = CallArgs.begin(), E = CallArgs.end(); // -> for all the function parameters, handle it based on abi info.
I != E; ++I, ++info_it, ++ArgNo) {
const ABIArgInfo &ArgInfo = info_it->info;
diff --git a/clang/lib/CodeGen/CodeGenAction.cpp b/clang/lib/CodeGen/CodeGenAction.cpp
index 4321efd49af36..b3a897e20ddaa 100644
--- a/clang/lib/CodeGen/CodeGenAction.cpp
+++ b/clang/lib/CodeGen/CodeGenAction.cpp
@@ -162,7 +162,7 @@ bool BackendConsumer::HandleTopLevelDecl(DeclGroupRef D) {
Context->getSourceManager(),
"LLVM IR generation of declaration");
- // Recurse.
+ // Recurse. //if we are starting ir generation, then we stop the frontend timer and start the ir gen timer.
if (TimerIsEnabled && !LLVMIRGenerationRefCount++)
CI.getFrontendTimer().yieldTo(LLVMIRGeneration);
diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp
index ecce52ef9eaf5..34baf6734bbc8 100644
--- a/clang/lib/CodeGen/CodeGenModule.cpp
+++ b/clang/lib/CodeGen/CodeGenModule.cpp
@@ -103,7 +103,7 @@ static CGCXXABI *createCXXABI(CodeGenModule &CGM) {
llvm_unreachable("invalid C++ ABI kind");
}
-
+// this is importatnt!! this is the start of the abi info part.
static std::unique_ptr<TargetCodeGenInfo>
createTargetCodeGenInfo(CodeGenModule &CGM) {
const TargetInfo &Target = CGM.getTarget();
@@ -3889,7 +3889,7 @@ void CodeGenModule::EmitGlobal(GlobalDecl GD) {
}
}
- // Ignore declarations, they will be emitted on their first use.
+ // Ignore declarations, they will be emitted on their first use. //If we have just declared a function, dont parse it now, that will be handled when it is first used.
if (const auto *FD = dyn_cast<FunctionDecl>(Global)) {
// Update deferred annotations with the latest declaration if the function
// function was already used or defined.
@@ -6105,7 +6105,7 @@ void CodeGenModule::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) {
void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD,
llvm::GlobalValue *GV) {
const auto *D = cast<FunctionDecl>(GD.getDecl());
-
+// THIS IS THE PLACE!!
// Compute the function info and LLVM type.
const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD);
llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
diff --git a/clang/lib/CodeGen/ModuleBuilder.cpp b/clang/lib/CodeGen/ModuleBuilder.cpp
index 09a7d79ae4afb..0b4d0ee580435 100644
--- a/clang/lib/CodeGen/ModuleBuilder.cpp
+++ b/clang/lib/CodeGen/ModuleBuilder.cpp
@@ -185,7 +185,7 @@ namespace {
HandlingTopLevelDeclRAII HandlingDecl(*this);
- // Make sure to emit all elements of a Decl.
+ // Make sure to emit all elements of a Decl. //What is a Decl really, what components does it have? what are we looping over? are we looping over its children?
for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
Builder->EmitTopLevelDecl(*I);
diff --git a/clang/lib/CodeGen/Targets/AMDGPU.cpp b/clang/lib/CodeGen/Targets/AMDGPU.cpp
index e3c8243cbb0b5..a4c5adc6ef426 100644
--- a/clang/lib/CodeGen/Targets/AMDGPU.cpp
+++ b/clang/lib/CodeGen/Targets/AMDGPU.cpp
@@ -112,7 +112,7 @@ unsigned AMDGPUABIInfo::numRegsForType(QualType Ty) const {
void AMDGPUABIInfo::computeInfo(CGFunctionInfo &FI) const {
llvm::CallingConv::ID CC = FI.getCallingConvention();
-
+// what is this, this is important.
if (!getCXXABI().classifyReturnType(FI))
FI.getReturnInfo() = classifyReturnType(FI.getReturnType());
diff --git a/clang/lib/Parse/ParseAST.cpp b/clang/lib/Parse/ParseAST.cpp
index 761f84070681e..0200fa4f9ca04 100644
--- a/clang/lib/Parse/ParseAST.cpp
+++ b/clang/lib/Parse/ParseAST.cpp
@@ -111,7 +111,7 @@ void clang::ParseAST(Preprocessor &PP, ASTConsumer *Consumer,
ParseAST(*S.get(), PrintStats, SkipFunctionBodies);
}
-
+// is this specific to clang fronend? what about if some other frontend wants to do this? where do the frontends diverge and what parts are common?
void clang::ParseAST(Sema &S, bool PrintStats, bool SkipFunctionBodies) {
// Collect global stats on Decls/Stmts (until we have a module streamer).
if (PrintStats) {
@@ -131,7 +131,7 @@ void clang::ParseAST(Sema &S, bool PrintStats, bool SkipFunctionBodies) {
std::unique_ptr<Parser> ParseOP(
new Parser(S.getPreprocessor(), S, SkipFunctionBodies));
- Parser &P = *ParseOP.get();
+ Parser &P = *ParseOP.get(); // we have the AST and now we are getting a parser which will parse that ast.
llvm::CrashRecoveryContextCleanupRegistrar<const void, ResetStackCleanup>
CleanupPrettyStack(llvm::SavePrettyStackState());
@@ -161,12 +161,12 @@ void clang::ParseAST(Sema &S, bool PrintStats, bool SkipFunctionBodies) {
}
return M;
});
- P.Initialize();
+ P.Initialize(); // this sets up the parser and gets the first token i guess?
Parser::DeclGroupPtrTy ADecl;
Sema::ModuleImportState ImportState;
EnterExpressionEvaluationContext PotentiallyEvaluated(
S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
-
+// I think translational unit decls are the top level decls. everything else is counted as a "sub-decl"/ other type of decl. so this loop works for each translational unit. i guess.
for (bool AtEOF = P.ParseFirstTopLevelDecl(ADecl, ImportState); !AtEOF;
AtEOF = P.ParseTopLevelDecl(ADecl, ImportState)) {
// If we got a null return and something *was* parsed, ignore it. This
@@ -191,7 +191,7 @@ void clang::ParseAST(Sema &S, bool PrintStats, bool SkipFunctionBodies) {
finalize(S.TemplateInstCallbacks, S);
std::swap(OldCollectStats, S.CollectStats);
- if (PrintStats) {
+ if (true) {
llvm::errs() << "\nSTATISTICS:\n";
if (HaveLexer) P.getActions().PrintStats();
S.getASTContext().PrintStats();
diff --git a/clang/lib/Parse/Parser.cpp b/clang/lib/Parse/Parser.cpp
index 6128bc58d69c0..03d6bf5d4f157 100644
--- a/clang/lib/Parse/Parser.cpp
+++ b/clang/lib/Parse/Parser.cpp
@@ -631,7 +631,7 @@ bool Parser::ParseFirstTopLevelDecl(DeclGroupPtrTy &Result,
bool Parser::ParseTopLevelDecl(DeclGroupPtrTy &Result,
Sema::ModuleImportState &ImportState) {
DestroyTemplateIdAnnotationsRAIIObj CleanupRAII(*this);
-
+// to parseTopLevelDecl, we get the first token from the lexer. and then based on the kind of that token, we do some special handling if needed, otherwise we just return.
Result = nullptr;
switch (Tok.getKind()) {
case tok::annot_pragma_unused:
diff --git a/llvm/include/llvm/ADT/FoldingSet.h b/llvm/include/llvm/ADT/FoldingSet.h
index 3c2eaade57e47..cd28963a5da61 100644
--- a/llvm/include/llvm/ADT/FoldingSet.h
+++ b/llvm/include/llvm/ADT/FoldingSet.h
@@ -509,7 +509,7 @@ template <class Derived, class T> class FoldingSetImpl : public FoldingSetBase {
/// InsertNode - Insert the specified node into the folding set, knowing that
/// it is not already in the folding set. InsertPos must be obtained from
- /// FindNodeOrInsertPos.
+ /// FindNodeOrInsertPos. //what is the folding set?
void InsertNode(T *N, void *InsertPos) {
FoldingSetBase::InsertNode(N, InsertPos, Derived::getFoldingSetInfo());
}
>From 2fde3d1079bed13375456975e7ac8167103e9f9f Mon Sep 17 00:00:00 2001
From: easyonaadit <aaditya.alokdeshpande at amd.com>
Date: Wed, 26 Mar 2025 18:29:53 +0530
Subject: [PATCH 2/2] Implementation logic for ABI Library
---
clang/include/clang/CodeGen/CGFunctionInfo.h | 2 +-
clang/lib/CodeGen/ABIInfoImpl.cpp | 2 +-
clang/lib/CodeGen/CGCall.cpp | 44 +++++++++++++++-----
clang/lib/CodeGen/CodeGenAction.cpp | 2 +-
clang/lib/CodeGen/CodeGenModule.cpp | 6 +--
clang/lib/CodeGen/ModuleBuilder.cpp | 2 +-
clang/lib/CodeGen/Targets/AMDGPU.cpp | 2 +-
clang/lib/Parse/ParseAST.cpp | 10 ++---
clang/lib/Parse/Parser.cpp | 2 +-
llvm/include/llvm/ADT/FoldingSet.h | 2 +-
10 files changed, 48 insertions(+), 26 deletions(-)
diff --git a/clang/include/clang/CodeGen/CGFunctionInfo.h b/clang/include/clang/CodeGen/CGFunctionInfo.h
index 91276e743a8c6..040ee025afaa8 100644
--- a/clang/include/clang/CodeGen/CGFunctionInfo.h
+++ b/clang/include/clang/CodeGen/CGFunctionInfo.h
@@ -721,7 +721,7 @@ class CGFunctionInfo final
}
/// getCallingConvention - Return the user specified calling
- /// convention, which has been translated into an LLVM CC. //this is important, that clang/ast calling convention has been translated into an llvm (target specific?) calling convention.
+ /// convention, which has been translated into an LLVM CC.
unsigned getCallingConvention() const { return CallingConvention; }
/// getEffectiveCallingConvention - Return the actual calling convention to
diff --git a/clang/lib/CodeGen/ABIInfoImpl.cpp b/clang/lib/CodeGen/ABIInfoImpl.cpp
index dcccebb8daad7..0a612d3461dc2 100644
--- a/clang/lib/CodeGen/ABIInfoImpl.cpp
+++ b/clang/lib/CodeGen/ABIInfoImpl.cpp
@@ -62,7 +62,7 @@ ABIArgInfo DefaultABIInfo::classifyReturnType(QualType RetTy) const {
: getContext().LongLongTy))
return getNaturalAlignIndirect(RetTy,
getDataLayout().getAllocaAddrSpace());
-// what is a promotable integer type?
+
return (isPromotableIntegerTypeForABI(RetTy) ? ABIArgInfo::getExtend(RetTy)
: ABIArgInfo::getDirect());
}
diff --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp
index 0f0b7788fc450..719af045fe607 100644
--- a/clang/lib/CodeGen/CGCall.cpp
+++ b/clang/lib/CodeGen/CGCall.cpp
@@ -46,7 +46,6 @@ using namespace clang;
using namespace CodeGen;
/***/
-// clang and llvm have different calling conventions? what is it used for? what does it do?
unsigned CodeGenTypes::ClangCallConvToLLVMCallConv(CallingConv CC) {
switch (CC) {
default: return llvm::CallingConv::C;
@@ -217,7 +216,7 @@ arrangeLLVMFunctionInfo(CodeGenTypes &CGT, bool instanceMethod,
}
/// Arrange the argument and result information for a value of the
-/// given freestanding function type. // what does this mean??
+/// given freestanding function type.
const CGFunctionInfo &
CodeGenTypes::arrangeFreeFunctionType(CanQual<FunctionProtoType> FTP) {
SmallVector<CanQualType, 16> argTypes;
@@ -800,7 +799,7 @@ void computeSPIRKernelABIInfo(CodeGenModule &CGM, CGFunctionInfo &FI);
/// Arrange the argument and result information for an abstract value
/// of a given function type. This is the method which all of the
-/// above functions ultimately defer to. // this is important, what is this? what does it mean?
+/// above functions ultimately defer to.
const CGFunctionInfo &CodeGenTypes::arrangeLLVMFunctionInfo(
CanQualType resultType, FnInfoOpts opts, ArrayRef<CanQualType> argTypes,
FunctionType::ExtInfo info,
@@ -809,6 +808,29 @@ const CGFunctionInfo &CodeGenTypes::arrangeLLVMFunctionInfo(
assert(llvm::all_of(argTypes,
[](CanQualType T) { return T.isCanonicalAsParam(); }));
+// first convert each of these types into ABI::types. -> info, paramInfos, required, resultType, argTypes
+// then in the library, create abi::functionInfo type, same as how CGFunctionInfo is created.
+// then in the library, lower abi::functionInfo to abi::x_86_abiArgInfo
+// then return that. then the frontend has to lower that to llvm-ir.
+// so clang will have to map that to clang::CGFunctionInfo.
+ ABIType resultTypeABI = getABIType(resultType);
+ghp_2xbJR1q3ZrX8jjWL7FTYAmgZJYgkmU2KxLpt
+ std::vector<ABIType> abiTypes;
+ abiTypes.reserve(canQualTypes.size());
+
+ for (const llvm::CanQualType &element : argTypes) {
+ abiTypes.push_back(getABIType(element));
+ }
+ llvm::ArrayRef<ABIType> argTypesABI = llvm::ArrayRef<ABIType>(abiTypes);
+
+ ABIFunctionInfo *ABIFI = ABIFunctionInfo::create(CC, isInstanceMethod, isChainCall, isDelegateCall,
+ info, paramInfos, resultType, argTypes, required);
+
+ // TargetCodeGenInfo &CodeGenModule::getTargetCodeGenInfo() ;
+ ABIInfo::computeFunctionInfo(CodeGenModule::getTargetCodeGenInfo(), ABIFI);
+
+ CGFunctionInfo *FI = mapABIFunctionInfoToCGFunctionInfo(ABIFI);
+
// Lookup or create unique function info.
llvm::FoldingSetNodeID ID;
bool isInstanceMethod =
@@ -828,15 +850,15 @@ const CGFunctionInfo &CodeGenTypes::arrangeLLVMFunctionInfo(
unsigned CC = ClangCallConvToLLVMCallConv(info.getCC());
// Construct the function info. We co-allocate the ArgInfos.
- FI = CGFunctionInfo::create(CC, isInstanceMethod, isChainCall, isDelegateCall,
- info, paramInfos, resultType, argTypes, required);
- FunctionInfos.InsertNode(FI, insertPos); //what is this inserting? is it inserting a function call node in the IR module?
+ // FI = CGFunctionInfo::create(CC, isInstanceMethod, isChainCall, isDelegateCall,
+ // info, paramInfos, resultType, argTypes, required);
+ FunctionInfos.InsertNode(FI, insertPos);
bool inserted = FunctionsBeingProcessed.insert(FI).second;
(void)inserted;
assert(inserted && "Recursively being processed?");
- // Compute ABI information. //why do we need the ABI info at this point? is it that first we add the positino of the funciton call in the IR module? and then before putting any of the parameters or any of the inputs or anything, we need to use the abi info.
+ // Compute ABI information.
if (CC == llvm::CallingConv::SPIR_KERNEL) {
// Force target independent argument handling for the host visible
// kernel functions.
@@ -844,7 +866,7 @@ const CGFunctionInfo &CodeGenTypes::arrangeLLVMFunctionInfo(
} else if (info.getCC() == CC_Swift || info.getCC() == CC_SwiftAsync) {
swiftcall::computeABIInfo(CGM, *FI);
} else {
- CGM.getABIInfo().computeInfo(*FI); //this is going into compute info. but what is it doing there? is it just setting up the information needed for lowering, or is it actually doing the lowering?
+ CGM.getABIInfo().computeInfo(*FI);
}
// Loop over all of the computed argument and return value info. If any of
@@ -863,7 +885,7 @@ const CGFunctionInfo &CodeGenTypes::arrangeLLVMFunctionInfo(
return *FI;
}
-// this is important. this object seems to hold both information about the clang calling convention as well as the llvm calling convention. maybe its a mapping between the two. also it has an AST field.
+
CGFunctionInfo *CGFunctionInfo::create(unsigned llvmCC, bool instanceMethod,
bool chainCall, bool delegateCall,
const FunctionType::ExtInfo &info,
@@ -5187,7 +5209,7 @@ RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
ArgMemory = RawAddress(AI, ArgStruct, Align);
}
- ClangToLLVMArgMapping IRFunctionArgs(CGM.getContext(), CallInfo); // --> this seems imp
+ ClangToLLVMArgMapping IRFunctionArgs(CGM.getContext(), CallInfo);
SmallVector<llvm::Value *, 16> IRCallArgs(IRFunctionArgs.totalIRArgs());
// If the call returns a temporary with struct return, create a temporary
@@ -5251,7 +5273,7 @@ RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
"Mismatch between function signature & arguments.");
unsigned ArgNo = 0;
CGFunctionInfo::const_arg_iterator info_it = CallInfo.arg_begin();
- for (CallArgList::const_iterator I = CallArgs.begin(), E = CallArgs.end(); // -> for all the function parameters, handle it based on abi info.
+ for (CallArgList::const_iterator I = CallArgs.begin(), E = CallArgs.end();
I != E; ++I, ++info_it, ++ArgNo) {
const ABIArgInfo &ArgInfo = info_it->info;
diff --git a/clang/lib/CodeGen/CodeGenAction.cpp b/clang/lib/CodeGen/CodeGenAction.cpp
index b3a897e20ddaa..4321efd49af36 100644
--- a/clang/lib/CodeGen/CodeGenAction.cpp
+++ b/clang/lib/CodeGen/CodeGenAction.cpp
@@ -162,7 +162,7 @@ bool BackendConsumer::HandleTopLevelDecl(DeclGroupRef D) {
Context->getSourceManager(),
"LLVM IR generation of declaration");
- // Recurse. //if we are starting ir generation, then we stop the frontend timer and start the ir gen timer.
+ // Recurse.
if (TimerIsEnabled && !LLVMIRGenerationRefCount++)
CI.getFrontendTimer().yieldTo(LLVMIRGeneration);
diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp
index 34baf6734bbc8..ecce52ef9eaf5 100644
--- a/clang/lib/CodeGen/CodeGenModule.cpp
+++ b/clang/lib/CodeGen/CodeGenModule.cpp
@@ -103,7 +103,7 @@ static CGCXXABI *createCXXABI(CodeGenModule &CGM) {
llvm_unreachable("invalid C++ ABI kind");
}
-// this is importatnt!! this is the start of the abi info part.
+
static std::unique_ptr<TargetCodeGenInfo>
createTargetCodeGenInfo(CodeGenModule &CGM) {
const TargetInfo &Target = CGM.getTarget();
@@ -3889,7 +3889,7 @@ void CodeGenModule::EmitGlobal(GlobalDecl GD) {
}
}
- // Ignore declarations, they will be emitted on their first use. //If we have just declared a function, dont parse it now, that will be handled when it is first used.
+ // Ignore declarations, they will be emitted on their first use.
if (const auto *FD = dyn_cast<FunctionDecl>(Global)) {
// Update deferred annotations with the latest declaration if the function
// function was already used or defined.
@@ -6105,7 +6105,7 @@ void CodeGenModule::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) {
void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD,
llvm::GlobalValue *GV) {
const auto *D = cast<FunctionDecl>(GD.getDecl());
-// THIS IS THE PLACE!!
+
// Compute the function info and LLVM type.
const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD);
llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
diff --git a/clang/lib/CodeGen/ModuleBuilder.cpp b/clang/lib/CodeGen/ModuleBuilder.cpp
index 0b4d0ee580435..09a7d79ae4afb 100644
--- a/clang/lib/CodeGen/ModuleBuilder.cpp
+++ b/clang/lib/CodeGen/ModuleBuilder.cpp
@@ -185,7 +185,7 @@ namespace {
HandlingTopLevelDeclRAII HandlingDecl(*this);
- // Make sure to emit all elements of a Decl. //What is a Decl really, what components does it have? what are we looping over? are we looping over its children?
+ // Make sure to emit all elements of a Decl.
for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
Builder->EmitTopLevelDecl(*I);
diff --git a/clang/lib/CodeGen/Targets/AMDGPU.cpp b/clang/lib/CodeGen/Targets/AMDGPU.cpp
index a4c5adc6ef426..e3c8243cbb0b5 100644
--- a/clang/lib/CodeGen/Targets/AMDGPU.cpp
+++ b/clang/lib/CodeGen/Targets/AMDGPU.cpp
@@ -112,7 +112,7 @@ unsigned AMDGPUABIInfo::numRegsForType(QualType Ty) const {
void AMDGPUABIInfo::computeInfo(CGFunctionInfo &FI) const {
llvm::CallingConv::ID CC = FI.getCallingConvention();
-// what is this, this is important.
+
if (!getCXXABI().classifyReturnType(FI))
FI.getReturnInfo() = classifyReturnType(FI.getReturnType());
diff --git a/clang/lib/Parse/ParseAST.cpp b/clang/lib/Parse/ParseAST.cpp
index 0200fa4f9ca04..761f84070681e 100644
--- a/clang/lib/Parse/ParseAST.cpp
+++ b/clang/lib/Parse/ParseAST.cpp
@@ -111,7 +111,7 @@ void clang::ParseAST(Preprocessor &PP, ASTConsumer *Consumer,
ParseAST(*S.get(), PrintStats, SkipFunctionBodies);
}
-// is this specific to clang fronend? what about if some other frontend wants to do this? where do the frontends diverge and what parts are common?
+
void clang::ParseAST(Sema &S, bool PrintStats, bool SkipFunctionBodies) {
// Collect global stats on Decls/Stmts (until we have a module streamer).
if (PrintStats) {
@@ -131,7 +131,7 @@ void clang::ParseAST(Sema &S, bool PrintStats, bool SkipFunctionBodies) {
std::unique_ptr<Parser> ParseOP(
new Parser(S.getPreprocessor(), S, SkipFunctionBodies));
- Parser &P = *ParseOP.get(); // we have the AST and now we are getting a parser which will parse that ast.
+ Parser &P = *ParseOP.get();
llvm::CrashRecoveryContextCleanupRegistrar<const void, ResetStackCleanup>
CleanupPrettyStack(llvm::SavePrettyStackState());
@@ -161,12 +161,12 @@ void clang::ParseAST(Sema &S, bool PrintStats, bool SkipFunctionBodies) {
}
return M;
});
- P.Initialize(); // this sets up the parser and gets the first token i guess?
+ P.Initialize();
Parser::DeclGroupPtrTy ADecl;
Sema::ModuleImportState ImportState;
EnterExpressionEvaluationContext PotentiallyEvaluated(
S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
-// I think translational unit decls are the top level decls. everything else is counted as a "sub-decl"/ other type of decl. so this loop works for each translational unit. i guess.
+
for (bool AtEOF = P.ParseFirstTopLevelDecl(ADecl, ImportState); !AtEOF;
AtEOF = P.ParseTopLevelDecl(ADecl, ImportState)) {
// If we got a null return and something *was* parsed, ignore it. This
@@ -191,7 +191,7 @@ void clang::ParseAST(Sema &S, bool PrintStats, bool SkipFunctionBodies) {
finalize(S.TemplateInstCallbacks, S);
std::swap(OldCollectStats, S.CollectStats);
- if (true) {
+ if (PrintStats) {
llvm::errs() << "\nSTATISTICS:\n";
if (HaveLexer) P.getActions().PrintStats();
S.getASTContext().PrintStats();
diff --git a/clang/lib/Parse/Parser.cpp b/clang/lib/Parse/Parser.cpp
index 03d6bf5d4f157..6128bc58d69c0 100644
--- a/clang/lib/Parse/Parser.cpp
+++ b/clang/lib/Parse/Parser.cpp
@@ -631,7 +631,7 @@ bool Parser::ParseFirstTopLevelDecl(DeclGroupPtrTy &Result,
bool Parser::ParseTopLevelDecl(DeclGroupPtrTy &Result,
Sema::ModuleImportState &ImportState) {
DestroyTemplateIdAnnotationsRAIIObj CleanupRAII(*this);
-// to parseTopLevelDecl, we get the first token from the lexer. and then based on the kind of that token, we do some special handling if needed, otherwise we just return.
+
Result = nullptr;
switch (Tok.getKind()) {
case tok::annot_pragma_unused:
diff --git a/llvm/include/llvm/ADT/FoldingSet.h b/llvm/include/llvm/ADT/FoldingSet.h
index cd28963a5da61..3c2eaade57e47 100644
--- a/llvm/include/llvm/ADT/FoldingSet.h
+++ b/llvm/include/llvm/ADT/FoldingSet.h
@@ -509,7 +509,7 @@ template <class Derived, class T> class FoldingSetImpl : public FoldingSetBase {
/// InsertNode - Insert the specified node into the folding set, knowing that
/// it is not already in the folding set. InsertPos must be obtained from
- /// FindNodeOrInsertPos. //what is the folding set?
+ /// FindNodeOrInsertPos.
void InsertNode(T *N, void *InsertPos) {
FoldingSetBase::InsertNode(N, InsertPos, Derived::getFoldingSetInfo());
}
More information about the llvm-commits
mailing list