[clang][CodeGen] Remove the signed version of createExpression

[achieveartificialintelligence]

Summary

Fix a TODO. Remove the callers of this signed version and delete.

[achieveartificialintelligence]

ping

[CodaFi]

C API changes LGTM.

[achieveartificialintelligence]

In D116014#3210212, @CodaFi wrote:

C API changes LGTM.

Thanks for your review!

clang/lib/CodeGen/CGDebugInfo.h

#include "clang/Basic/OpenCLExtensionTypes.def"
 
   /// If target-specific LLVM \p AddressSpace directly maps to target-specific
   /// DWARF address space, appends extended dereferencing mechanism to complex
   /// expression \p Expr. Otherwise, does nothing.
   ///
   /// Extended dereferencing mechanism is has the following format:
   ///     DW_OP_constu <DWARF Address Space> DW_OP_swap DW_OP_xderef
   void AppendAddressSpaceXDeref(unsigned AddressSpace,
-                                SmallVectorImpl<int64_t> &Expr) const;
+                                SmallVectorImpl<uint64_t> &Expr) const;
 
   /// A helper function to collect debug info for the default elements of a
   /// block.
   ///
   /// \returns The next available field offset after the default elements.
   uint64_t collectDefaultElementTypesForBlockPointer(
       const BlockPointerType *Ty, llvm::DIFile *Unit,
       llvm::DIDerivedType *DescTy, unsigned LineNo,

clang/lib/CodeGen/CGDebugInfo.cpp

#include "clang/Basic/AArch64SVEACLETypes.def"
       if (Info.ElementType == CGM.getContext().BoolTy) {
         NumElemsPerVG /= 8;
         Info.ElementType = CGM.getContext().UnsignedCharTy;
       }
 
       auto *LowerBound =
           llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
               llvm::Type::getInt64Ty(CGM.getLLVMContext()), 0));
-      SmallVector<int64_t, 9> Expr(
+      SmallVector<uint64_t, 9> Expr(
           {llvm::dwarf::DW_OP_constu, NumElemsPerVG, llvm::dwarf::DW_OP_bregx,
            /* AArch64::VG */ 46, 0, llvm::dwarf::DW_OP_mul,
            llvm::dwarf::DW_OP_constu, 1, llvm::dwarf::DW_OP_minus});
       auto *UpperBound = DBuilder.createExpression(Expr);
 
       llvm::Metadata *Subscript = DBuilder.getOrCreateSubrange(
           /*count*/ nullptr, LowerBound, UpperBound, /*stride*/ nullptr);
       llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscript);
#include "clang/Basic/RISCVVTypes.def"
         // In RVV scalable vector types, we encode 64 bits in the fixed part.
         Fractional = true;
         LMUL = 64 / FixedSize;
       } else {
         LMUL = FixedSize / 64;
       }
 
       // Element count = (VLENB / SEW) x LMUL
-      SmallVector<int64_t, 12> Expr(
+      SmallVector<uint64_t, 12> Expr(
           // The DW_OP_bregx operation has two operands: a register which is
           // specified by an unsigned LEB128 number, followed by a signed LEB128
           // offset.
           {llvm::dwarf::DW_OP_bregx, // Read the contents of a register.
            4096 + 0xC22,             // RISC-V VLENB CSR register.
            0, // Offset for DW_OP_bregx. It is dummy here.
            llvm::dwarf::DW_OP_constu,
            SEW / 8, // SEW is in bits.
void CGDebugInfo::CreateLexicalBlock(SourceLocation Loc) {
   if (!LexicalBlockStack.empty())
     Back = LexicalBlockStack.back().get();
   LexicalBlockStack.emplace_back(DBuilder.createLexicalBlock(
       cast<llvm::DIScope>(Back), getOrCreateFile(CurLoc), getLineNumber(CurLoc),
       getColumnNumber(CurLoc)));
 }
 
 void CGDebugInfo::AppendAddressSpaceXDeref(
-    unsigned AddressSpace, SmallVectorImpl<int64_t> &Expr) const {
+    unsigned AddressSpace, SmallVectorImpl<uint64_t> &Expr) const {
   Optional<unsigned> DWARFAddressSpace =
       CGM.getTarget().getDWARFAddressSpace(AddressSpace);
   if (!DWARFAddressSpace)
     return;
 
   Expr.push_back(llvm::dwarf::DW_OP_constu);
   Expr.push_back(DWARFAddressSpace.getValue());
   Expr.push_back(llvm::dwarf::DW_OP_swap);
llvm::DILocalVariable *CGDebugInfo::EmitDeclare(const VarDecl *VD,
 
   // Get location information.
   unsigned Line = 0;
   unsigned Column = 0;
   if (!Unwritten) {
     Line = getLineNumber(VD->getLocation());
     Column = getColumnNumber(VD->getLocation());
   }
-  SmallVector<int64_t, 13> Expr;
+  SmallVector<uint64_t, 13> Expr;
   llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
   if (VD->isImplicit())
     Flags |= llvm::DINode::FlagArtificial;
 
   auto Align = getDeclAlignIfRequired(VD, CGM.getContext());
 
   unsigned AddressSpace = CGM.getContext().getTargetAddressSpace(VD->getType());
   AppendAddressSpaceXDeref(AddressSpace, Expr);
void CGDebugInfo::EmitDeclareOfBlockDeclRefVariable(
   unsigned Column = getColumnNumber(VD->getLocation());
 
   const llvm::DataLayout &target = CGM.getDataLayout();
 
   CharUnits offset = CharUnits::fromQuantity(
       target.getStructLayout(blockInfo.StructureType)
           ->getElementOffset(blockInfo.getCapture(VD).getIndex()));
 
-  SmallVector<int64_t, 9> addr;
+  SmallVector<uint64_t, 9> addr;
   addr.push_back(llvm::dwarf::DW_OP_deref);
   addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
   addr.push_back(offset.getQuantity());
   if (isByRef) {
     addr.push_back(llvm::dwarf::DW_OP_deref);
     addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
     // offset of __forwarding field
     offset =
void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var,
   if (T->isUnionType() && DeclName.empty()) {
     const RecordDecl *RD = T->castAs<RecordType>()->getDecl();
     assert(RD->isAnonymousStructOrUnion() &&
            "unnamed non-anonymous struct or union?");
     GVE = CollectAnonRecordDecls(RD, Unit, LineNo, LinkageName, Var, DContext);
   } else {
     auto Align = getDeclAlignIfRequired(D, CGM.getContext());
 
-    SmallVector<int64_t, 4> Expr;
+    SmallVector<uint64_t, 4> Expr;
     unsigned AddressSpace =
         CGM.getContext().getTargetAddressSpace(D->getType());
     if (CGM.getLangOpts().CUDA && CGM.getLangOpts().CUDAIsDevice) {
       if (D->hasAttr<CUDASharedAttr>())
         AddressSpace =
             CGM.getContext().getTargetAddressSpace(LangAS::cuda_shared);
       else if (D->hasAttr<CUDAConstantAttr>())
         AddressSpace =

llvm/bindings/ocaml/debuginfo/debuginfo_ocaml.c

 value llvm_instr_set_debug_loc(LLVMValueRef Inst, LLVMMetadataRef Loc) {
   LLVMInstructionSetDebugLoc(Inst, Loc);
   return Val_unit;
 }
 
 LLVMMetadataRef llvm_dibuild_create_constant_value_expression(value Builder,
                                                               value Value) {
   return LLVMDIBuilderCreateConstantValueExpression(DIBuilder_val(Builder),
-                                                    (int64_t)Int_val(Value));
+                                                    (uint64_t)Int_val(Value));
 }
 
 LLVMMetadataRef llvm_dibuild_create_global_variable_expression_native(
     value Builder, LLVMMetadataRef Scope, value Name, value Linkage,
     LLVMMetadataRef File, value Line, LLVMMetadataRef Ty, value LocalToUnit,
     LLVMMetadataRef Expr, LLVMMetadataRef Decl, value AlignInBits) {
   return LLVMDIBuilderCreateGlobalVariableExpression(
       DIBuilder_val(Builder), Scope, String_val(Name), caml_string_length(Name),

llvm/include/llvm-c/DebugInfo.h

 /**
  * Create a new descriptor for the specified variable which has a complex
  * address expression for its address.
  * \param Builder     The DIBuilder.
  * \param Addr        An array of complex address operations.
  * \param Length      Length of the address operation array.
  */
 LLVMMetadataRef LLVMDIBuilderCreateExpression(LLVMDIBuilderRef Builder,
-                                              int64_t *Addr, size_t Length);
+                                              uint64_t *Addr, size_t Length);
 
 /**
  * Create a new descriptor for the specified variable that does not have an
  * address, but does have a constant value.
  * \param Builder     The DIBuilder.
  * \param Value       The constant value.
  */
 LLVMMetadataRef
 LLVMDIBuilderCreateConstantValueExpression(LLVMDIBuilderRef Builder,
-                                           int64_t Value);
+                                           uint64_t Value);
 
 /**
  * Create a new descriptor for the specified variable.
  * \param Scope       Variable scope.
  * \param Name        Name of the variable.
  * \param NameLen     The length of the C string passed to \c Name.
  * \param Linkage     Mangled  name of the variable.
  * \param LinkLen     The length of the C string passed to \c Linkage.

llvm/include/llvm/IR/DIBuilder.h

createParameterVariable(DIScope *Scope, StringRef Name, unsigned ArgNo,
                             bool AlwaysPreserve = false,
                             DINode::DIFlags Flags = DINode::FlagZero,
                             DINodeArray Annotations = nullptr);
 
     /// Create a new descriptor for the specified
     /// variable which has a complex address expression for its address.
     /// \param Addr        An array of complex address operations.
     DIExpression *createExpression(ArrayRef<uint64_t> Addr = None);
-    DIExpression *createExpression(ArrayRef<int64_t> Addr);
 
     /// Create an expression for a variable that does not have an address, but
     /// does have a constant value.
     DIExpression *createConstantValueExpression(uint64_t Val) {
       return DIExpression::get(
           VMContext, {dwarf::DW_OP_constu, Val, dwarf::DW_OP_stack_value});
     }
 

llvm/lib/IR/DIBuilder.cpp

DILabel *DIBuilder::createLabel(DIScope *Scope, StringRef Name, DIFile *File,
   }
   return Node;
 }
 
 DIExpression *DIBuilder::createExpression(ArrayRef<uint64_t> Addr) {
   return DIExpression::get(VMContext, Addr);
 }
 
-DIExpression *DIBuilder::createExpression(ArrayRef<int64_t> Signed) {
-  // TODO: Remove the callers of this signed version and delete.
-  SmallVector<uint64_t, 8> Addr(Signed.begin(), Signed.end());
-  return createExpression(Addr);
-}
-
 template <class... Ts>
 static DISubprogram *getSubprogram(bool IsDistinct, Ts &&...Args) {
   if (IsDistinct)
     return DISubprogram::getDistinct(std::forward<Ts>(Args)...);
   return DISubprogram::get(std::forward<Ts>(Args)...);
 }
 
 DISubprogram *DIBuilder::createFunction(

llvm/lib/IR/DebugInfo.cpp

LLVMDIBuilderCreateSubroutineType(LLVMDIBuilderRef Builder,
                                   LLVMDIFlags Flags) {
   auto Elts = unwrap(Builder)->getOrCreateTypeArray({unwrap(ParameterTypes),
                                                      NumParameterTypes});
   return wrap(unwrap(Builder)->createSubroutineType(
     Elts, map_from_llvmDIFlags(Flags)));
 }
 
 LLVMMetadataRef LLVMDIBuilderCreateExpression(LLVMDIBuilderRef Builder,
-                                              int64_t *Addr, size_t Length) {
-  return wrap(unwrap(Builder)->createExpression(ArrayRef<int64_t>(Addr,
-                                                                  Length)));
+                                              uint64_t *Addr, size_t Length) {
+  return wrap(
+      unwrap(Builder)->createExpression(ArrayRef<uint64_t>(Addr, Length)));
 }
 
 LLVMMetadataRef
 LLVMDIBuilderCreateConstantValueExpression(LLVMDIBuilderRef Builder,
-                                           int64_t Value) {
+                                           uint64_t Value) {
   return wrap(unwrap(Builder)->createConstantValueExpression(Value));
 }
 
 LLVMMetadataRef LLVMDIBuilderCreateGlobalVariableExpression(
     LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
     size_t NameLen, const char *Linkage, size_t LinkLen, LLVMMetadataRef File,
     unsigned LineNo, LLVMMetadataRef Ty, LLVMBool LocalToUnit,
     LLVMMetadataRef Expr, LLVMMetadataRef Decl, uint32_t AlignInBits) {