reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

 6535       static_cast<AArch64Operand&>(*Operands[OpIdx]).addLogicalImmOperands<int32_t>(Inst, 1);
 6562       static_cast<AArch64Operand&>(*Operands[OpIdx]).addLogicalImmNotOperands<int32_t>(Inst, 1);
 9120     DiagnosticPredicate DP(Operand.isLogicalImm<int32_t>());
 9129     DiagnosticPredicate DP(Operand.isLogicalImm<int32_t>());
 9582     DiagnosticPredicate DP(Operand.isSVEAddSubImm<int32_t>());
 9618     DiagnosticPredicate DP(Operand.isSVECpyImm<int32_t>());
11019     DiagnosticPredicate DP(Operand.isLogicalImm<int32_t>());
11035     DiagnosticPredicate DP(Operand.isSVEPreferredLogicalImm<int32_t>());
11067     DiagnosticPredicate DP(Operand.isLogicalImm<int32_t>());

12542     printImm8OptLsl<int32_t>(MI, 1, STI, O);
12918     printImm8OptLsl<int32_t>(MI, 3, STI, O);
13408     printLogicalImm<int32_t>(MI, 2, STI, O);
13436     printImm8OptLsl<int32_t>(MI, 2, STI, O);
26798     printLogicalImm<int32_t>(MI, OpIdx, STI, OS);
26843     printImm8OptLsl<int32_t>(MI, OpIdx, STI, OS);
26852     printSVELogicalImm<int32_t>(MI, OpIdx, STI, OS);
26981     return AArch64_AM::isSVEMaskOfIdenticalElements<int32_t>(Val);
27005     return AArch64_AM::isSVEMaskOfIdenticalElements<int32_t>(Val) &&

13521     printImm8OptLsl<int32_t>(MI, 1, STI, O);
13797     printImm8OptLsl<int32_t>(MI, 3, STI, O);
14246     printLogicalImm<int32_t>(MI, 2, STI, O);
14274     printImm8OptLsl<int32_t>(MI, 2, STI, O);
27514     printLogicalImm<int32_t>(MI, OpIdx, STI, OS);
27559     printImm8OptLsl<int32_t>(MI, OpIdx, STI, OS);
27568     printSVELogicalImm<int32_t>(MI, OpIdx, STI, OS);
27697     return AArch64_AM::isSVEMaskOfIdenticalElements<int32_t>(Val);
27721     return AArch64_AM::isSVEMaskOfIdenticalElements<int32_t>(Val) &&

114681   return Imm64 >= std::numeric_limits<int32_t>::min() &&
114682          Imm64 <= std::numeric_limits<int32_t>::max();

  386   return AArch64_AM::isSVEAddSubImm<int32_t>(Imm);
  414   return AArch64_AM::isSVECpyImm<int32_t>(Imm);
  530   return Imm64 >= std::numeric_limits<int32_t>::min() &&
  531          Imm64 <= std::numeric_limits<int32_t>::max();

54103     int32_t v = N->getZExtValue();

72555   int32_t V = N->getSExtValue();
72556   int32_t VecSize = HRI->getSpillSize(Hexagon::HvxVRRegClass);
72560   int32_t L = Log2_32(VecSize);
72973   int32_t NV = -N->getSExtValue();
73022   int32_t Imm = N->getSExtValue();
73051   int32_t imm = N->getSExtValue();
73088   int32_t V = N->getSExtValue();
73095   int32_t V = N->getSExtValue();
73102   int32_t V = N->getSExtValue();
73116    int32_t Imm = N->getSExtValue();
73123    int32_t Imm = N->getSExtValue();
73144 int32_t V = 64 - N->getSExtValue();return CurDAG->getTargetConstant(V, SDLoc(N), MVT::i32);
73154 int32_t V = 32 - N->getSExtValue();return CurDAG->getTargetConstant(V, SDLoc(N), MVT::i32);

  506 	auto V0 = PC.read<int32_t>();
  515 	OS << "\t" << PC.read<int32_t>() << " "<< "\n";
  519 bool emitConstSint32(int32_t, const SourceInfo &);
  522 bool ByteCodeEmitter::emitConstSint32(int32_t A0,const SourceInfo &L) {
  523 	return emitOp<int32_t>(OP_ConstSint32, A0, L);
  527 bool EvalEmitter::emitConstSint32(int32_t A0,const SourceInfo &L) {
 6001 	auto V0 = PC.read<int32_t>();
 6010 	OS << "\t" << PC.read<int32_t>() << " "<< "\n";
 6014 bool emitJf(int32_t, const SourceInfo &);
 6017 bool ByteCodeEmitter::emitJf(int32_t A0,const SourceInfo &L) {
 6018 	return emitOp<int32_t>(OP_Jf, A0, L);
 6026 	auto V0 = PC.read<int32_t>();
 6035 	OS << "\t" << PC.read<int32_t>() << " "<< "\n";
 6039 bool emitJmp(int32_t, const SourceInfo &);
 6042 bool ByteCodeEmitter::emitJmp(int32_t A0,const SourceInfo &L) {
 6043 	return emitOp<int32_t>(OP_Jmp, A0, L);
 6051 	auto V0 = PC.read<int32_t>();
 6060 	OS << "\t" << PC.read<int32_t>() << " "<< "\n";
 6064 bool emitJt(int32_t, const SourceInfo &);
 6067 bool ByteCodeEmitter::emitJt(int32_t A0,const SourceInfo &L) {
 6068 	return emitOp<int32_t>(OP_Jt, A0, L);

 3415 template <> int32_t PyLongAsT<int32_t>(PyObject *obj) {
 3415 template <> int32_t PyLongAsT<int32_t>(PyObject *obj) {
19078   int32_t result;
19712   int32_t *arg3 = (int32_t *) 0 ;
19740       arg3 = (int32_t *) malloc(size * sizeof(int32_t));
20082   int32_t *arg2 = (int32_t *) 0 ;
20102       arg2 = (int32_t *) malloc(size * sizeof(int32_t));
78535   int32_t result;
79163   int32_t arg2 ;
79206   int32_t result;
79236   int32_t arg2 ;
79271   int32_t arg2 ;
79315   int32_t arg2 ;
79350   int32_t arg2 ;
79394   int32_t arg2 ;
79429   int32_t arg2 ;
79476   int32_t result;
79499   int32_t arg2 ;
79506   int32_t result;

 1800   int32_t exactLogBase2() const {

  388   InterleaveGroup(InstTy *Instr, int32_t Stride, Align Alignment)
  407   bool insertMember(InstTy *Instr, int32_t Index, Align NewAlign) {
  409     Optional<int32_t> MaybeKey = checkedAdd(Index, SmallestKey);
  412     int32_t Key = *MaybeKey;
  427       Optional<int32_t> MaybeLargestIndex = checkedSub(LargestKey, Key);
  448     int32_t Key = SmallestKey + Index;
  499   DenseMap<int32_t, InstTy *> Members;
  500   int32_t SmallestKey = 0;
  501   int32_t LargestKey = 0;

   33 const int32_t MaxNumberOfSections16 = 65279;
   67   int32_t NumberOfSections;
  190   int32_t SectionNumber;
  196 enum SymbolSectionNumber : int32_t {
  722 inline bool isReservedSectionNumber(int32_t SectionNumber) {

   32 using Elf32_Sword = int32_t;
   38 using Elf64_Sword = int32_t;

  950   int32_t r_address;
  968   int32_t r_value;
 1598   int32_t fpu_reserved[2];

   77     int32_t Int32;
   79     int32_t Float32;

  216   int32_t TimeStamp;
  218   int32_t NumberOfSymbolTableEntries;
  233   int32_t Flags;

 2000   int32_t getConstantFPSplatPow2ToLog2Int(BitVector *UndefElements,

   93   int32_t CodeOffset;
   98   Line(int32_t CodeOffset, uint32_t StartLine, uint32_t EndLine,
  103   Line(int32_t CodeOffset, LineInfo LineInf, ColumnInfo ColumnInf)
  110   int32_t getCodeOffset() const { return CodeOffset; }

   59 Error consume(BinaryStreamReader &Reader, int32_t &Item);

  165   int32_t S1 = 0;
  241   static int32_t DecodeSignedOperand(uint32_t Operand) {
  247   static int32_t DecodeSignedOperand(ArrayRef<uint8_t> &Annotations) {
  588   int32_t Offset = 0;
  890   int32_t Offset = 0;

  184                        TypeIndex ArgumentList, int32_t ThisPointerAdjustment)
  198   int32_t getThisPointerAdjustment() const { return ThisPointerAdjustment; }
  207   int32_t ThisPointerAdjustment;
  729   OneMethodRecord(TypeIndex Type, MemberAttributes Attrs, int32_t VFTableOffset,
  734                   MethodOptions Options, int32_t VFTableOffset, StringRef Name)
  742   int32_t getVFTableOffset() const { return VFTableOffset; }
  752   int32_t VFTableOffset;

  121     int32_t getMaxLineIncrementForSpecialOpcode() const {

  164   virtual int32_t getOffset() const = 0;
  165   virtual int32_t getThisAdjust() const = 0;
  166   virtual int32_t getVirtualBasePointerOffset() const = 0;

   56   std::array<int32_t, IPHR_HASH + 1> BucketMap;

  138   int32_t getOffset() const override;
  139   int32_t getThisAdjust() const override;
  140   int32_t getVirtualBasePointerOffset() const override;

   48   int32_t getThisAdjust() const override;

  416   explicit Variant(int32_t V) : Type(PDB_VariantType::Int32) {
  455     int32_t Int32;

  450     int32_t VBPtrOffset = 0;
  451     int32_t VBOffsetOffset = 0;
  452     int32_t VtordispOffset = 0;
  570   int32_t VBPtrOffset = 0;

  194       : public rpc::Function<CallIntVoid, int32_t(JITTargetAddress Addr)> {
  202       : public rpc::Function<CallMain, int32_t(JITTargetAddress Addr,

  157   Expected<int32_t> handleCallIntVoid(JITTargetAddress Addr) {
  170   Expected<int32_t> handleCallMain(JITTargetAddress Addr,

   69   static constexpr int32_t ScaleShift = 8;

  322   int32_t getSectionNumber() const {
  520   int32_t getNumber(bool IsBigObj) const {
  985   std::error_code getSection(int32_t index, const coff_section *&Res) const;

   87   using Sword = packed<int32_t>;
  350                                            int64_t, int32_t>::type;

  136   const char* checkSegAndOffsets(int32_t SegIndex, uint64_t SegOffset,
  140   StringRef segmentName(int32_t SegIndex);
  141   StringRef sectionName(int32_t SegIndex, uint64_t SegOffset);
  152     int32_t SegmentIndex;
  154   const SectionInfo &findSection(int32_t SegIndex, uint64_t SegOffset);
  157   int32_t MaxSegIndex;
  172   int32_t segmentIndex() const;
  195   int32_t SegmentIndex = -1;
  218   int32_t segmentIndex() const;
  247   int32_t  SegmentIndex = -1;
  419   const char *BindEntryCheckSegAndOffsets(int32_t SegIndex, uint64_t SegOffset,
  432   const char *RebaseEntryCheckSegAndOffsets(int32_t SegIndex,
  443   StringRef BindRebaseSegmentName(int32_t SegIndex) const {

  143     int32_t getOffset() const {
  147       return read<int32_t>(P + SmallConstantOffset);

  297   int32_t getTimeStamp() const;
  306   int32_t getRawNumberOfSymbolTableEntries32() const;
  323   int32_t getSectionFlags(DataRefImpl Sec) const;

  111   int32_t Addend;

   25   int32_t TimeStamp;
   27   int32_t NumberOfSymTableEntries;

   77 enum : int32_t {
  102 enum : int32_t {
  128 enum : int32_t {
  137 enum : int32_t {

  281     detail::packed_endian_specific_integral<int32_t, little, unaligned>;
  295     detail::packed_endian_specific_integral<int32_t, little, aligned>;
  309     detail::packed_endian_specific_integral<int32_t, big, unaligned>;
  323     detail::packed_endian_specific_integral<int32_t, big, aligned>;
  337     detail::packed_endian_specific_integral<int32_t, native, unaligned>;

  745 template <unsigned B> constexpr inline int32_t SignExtend32(uint32_t X) {
  753 inline int32_t SignExtend32(uint32_t X, unsigned B) {

   36 const int32_t MaxScale = 16383;
   39 const int32_t MinScale = -16382;
  188 inline std::pair<int32_t, int> getLgImpl(DigitsT Digits, int16_t Scale) {
  195   int32_t LocalFloor = sizeof(Digits) * 8 - countLeadingZeros(Digits) - 1;
  198   int32_t Floor = Scale + LocalFloor;
  213 template <class DigitsT> int32_t getLg(DigitsT Digits, int16_t Scale) {
  222 template <class DigitsT> int32_t getLgFloor(DigitsT Digits, int16_t Scale) {
  232 template <class DigitsT> int32_t getLgCeiling(DigitsT Digits, int16_t Scale) {
  262   int32_t lgL = getLgFloor(LDigits, LScale), lgR = getLgFloor(RDigits, RScale);
  299   int32_t ScaleDiff = int32_t(LScale) - RScale;
  307   int32_t ShiftL = std::min<int32_t>(countLeadingZeros(LDigits), ScaleDiff);
  307   int32_t ShiftL = std::min<int32_t>(countLeadingZeros(LDigits), ScaleDiff);
  310   int32_t ShiftR = ScaleDiff - ShiftL;
  553   int32_t lg() const { return ScaledNumbers::getLg(Digits, Scale); }
  558   int32_t lgFloor() const { return ScaledNumbers::getLgFloor(Digits, Scale); }
  563   int32_t lgCeiling() const {
  633   void shiftLeft(int32_t Shift);
  634   void shiftRight(int32_t Shift);
  700   static ScaledNumber adjustToWidth(uint64_t N, int32_t Shift) {
  808   int32_t Scales = int32_t(Scale) + int32_t(X.Scale);
  808   int32_t Scales = int32_t(Scale) + int32_t(X.Scale);
  808   int32_t Scales = int32_t(Scale) + int32_t(X.Scale);
  825   int32_t Scales = int32_t(Scale) - int32_t(X.Scale);
  825   int32_t Scales = int32_t(Scale) - int32_t(X.Scale);
  825   int32_t Scales = int32_t(Scale) - int32_t(X.Scale);
  833 template <class DigitsT> void ScaledNumber<DigitsT>::shiftLeft(int32_t Shift) {
  843   int32_t ScaleShift = std::min(Shift, ScaledNumbers::MaxScale - Scale);
  863 template <class DigitsT> void ScaledNumber<DigitsT>::shiftRight(int32_t Shift) {
  873   int32_t ScaleShift = std::min(Shift, Scale - ScaledNumbers::MinScale);

  182   void printNumber(StringRef Label, int32_t Value) {

 1220   static void output(const int32_t &, void *, raw_ostream &);
 1221   static StringRef input(StringRef, void *, int32_t &);

   55     int32_t NumberOfInlines = 0;
   58     int32_t NumberOfRealInlines = 0;

   30     int32_t ThreadID;
   36   using Index = DenseMap<std::pair<uint64_t, int32_t>, std::vector<Block>>;

  207   int32_t Size = 0;
  223   int32_t size() const { return Size; }
  236   int32_t Size = 0;
  237   int32_t Delta = 0;
  246   explicit CustomEventRecordV5(int32_t S, int32_t D, std::string P)
  246   explicit CustomEventRecordV5(int32_t S, int32_t D, std::string P)
  251   int32_t size() const { return Size; }
  252   int32_t delta() const { return Delta; }
  263   int32_t Size = 0;
  264   int32_t Delta = 0;
  274   explicit TypedEventRecord(int32_t S, int32_t D, uint16_t E, std::string P)
  274   explicit TypedEventRecord(int32_t S, int32_t D, uint16_t E, std::string P)
  279   int32_t size() const { return Size; }
  280   int32_t delta() const { return Delta; }
  314   int32_t PID = 0;
  322   explicit PIDRecord(int32_t P)
  327   int32_t pid() const { return PID; }
  337   int32_t TID = 0;
  345   explicit NewBufferRecord(int32_t T)
  350   int32_t tid() const { return TID; }
  374   int32_t FuncId;
  383   explicit FunctionRecord(RecordTypes K, int32_t F, uint32_t D)
  389   int32_t functionId() const { return FuncId; }

   26   int32_t PID = 0;
   27   int32_t TID = 0;

   56   int32_t FuncId;
   74   using FunctionAddressMap = std::unordered_map<int32_t, uint64_t>;
   75   using FunctionAddressReverseMap = std::unordered_map<uint64_t, int32_t>;
   90   Optional<int32_t> getFunctionId(uint64_t Addr) const;
   93   Optional<uint64_t> getFunctionAddr(int32_t FuncId) const;

   55   using FuncID = int32_t;

   83   int32_t FuncId;

   35   int32_t FuncId;

   99     int32_t Bits = (*M + 1).exactLogBase2();

   54     return readInt<int32_t>(Obj);

  733   case dwarf::DW_FORM_block4: return Size + sizeof(int32_t);
  784   case dwarf::DW_FORM_block4: return Size + sizeof(int32_t);

 2589         sizeof(int32_t) + // Offset of CU in the .debug_info section
 2597         offsetToAlignment(sizeof(int32_t) + ContentSize, Align(TupleSize));

   82   unsigned Offset = sizeof(int32_t) +      // Length of Unit Info

 1370   const int32_t NumVecElements = CI->getSExtValue();

  260            sizeof(int32_t) + // Offset Into Abbrev. Section

 9490 int32_t

 3633     int32_t Off = C->getSExtValue();

  287   } else if (Value >= std::numeric_limits<int32_t>::min()) {
  336   } else if (Value >= std::numeric_limits<int32_t>::min()) {
  339     if (auto EC = Writer->writeInteger<int32_t>(Value))

   72     int32_t N;
  139 Error llvm::codeview::consume(BinaryStreamReader &Reader, int32_t &Item) {

  872       int32_t LineOffset =

   54   int32_t CompressedBucketIndex = GlobalsTable.BucketMap[ExpandedBucketIndex];

  368 int32_t NativeRawSymbol::getOffset() const {
  372 int32_t NativeRawSymbol::getThisAdjust() const {
  376 int32_t NativeRawSymbol::getVirtualBasePointerOffset() const {

  168 int32_t NativeTypeFunctionSig::getThisAdjust() const {

  657         if (Value < std::numeric_limits<int32_t>::min() ||
  658             Value > std::numeric_limits<int32_t>::max())

  492       if (Value < std::numeric_limits<int32_t>::min() ||
  493           Value > std::numeric_limits<int32_t>::max())
  510       if (Value < std::numeric_limits<int32_t>::min() ||
  511           Value > std::numeric_limits<int32_t>::max())
  522       if (Value < std::numeric_limits<int32_t>::min() ||
  523           Value > std::numeric_limits<int32_t>::max())
  539         if (Value < std::numeric_limits<int32_t>::min() ||
  540             Value > std::numeric_limits<int32_t>::max())

   31 static void or32le(void *P, int32_t V) { write32le(P, read32le(P) | V); }
  308     int32_t TruncOffset = (RealOffset & 0xFFFFFFFF);
  341                                           uint32_t Type, int32_t Addend) {
  489                                           uint32_t Type, int32_t Addend) {
  535     int32_t RelValue = static_cast<int32_t>(Value - FinalAddress - 8);

   37                             uint32_t Value, uint32_t Type, int32_t Addend);
   49                             uint32_t Value, uint32_t Type, int32_t Addend);

  306                                                   int32_t Addend) {

   32                                 uint32_t Value, uint32_t Type, int32_t Addend);

  495     if (Offset < std::numeric_limits<int32_t>::min() ||
  496         Offset > std::numeric_limits<int32_t>::max())

  633   int32_t BytesMod = CodeWords * 4 - TotalCodeBytes;

  197 static void writePatchableSLEB(raw_pwrite_stream &Stream, int32_t X,

  107   int32_t Flags;
  383     W.write<int32_t>(0);
  475   W.write<int32_t>(0);
  479   W.write<int32_t>(SymbolTableEntryCount);
  512     W.write<int32_t>(Sec->Flags);
  552   int32_t SectionIndex = 1;

  171   int32_t SectionNumber = Symb.getSectionNumber();
  191   int32_t SectionNumber = Symb.getSectionNumber();
  958 std::error_code COFFObjectFile::getSection(int32_t Index,

 3387 int32_t MachORebaseEntry::segmentIndex() const { return SegmentIndex; }
 3942 int32_t MachOBindEntry::segmentIndex() const { return SegmentIndex; }
 4031 const char * BindRebaseSegInfo::checkSegAndOffsets(int32_t SegIndex,
 4064 StringRef BindRebaseSegInfo::segmentName(int32_t SegIndex) {
 4075                                      int32_t SegIndex, uint64_t SegOffset) {
 4090 StringRef BindRebaseSegInfo::sectionName(int32_t SegIndex,

   85 static int32_t readFloat32(WasmObjectFile::ReadContext &Ctx) {
   88   int32_t Result = 0;
  140 static int32_t readVarint32(WasmObjectFile::ReadContext &Ctx) {

  445 int32_t XCOFFObjectFile::getTimeStamp() const {
  458 int32_t XCOFFObjectFile::getRawNumberOfSymbolTableEntries32() const {
  533 int32_t XCOFFObjectFile::getSectionFlags(DataRefImpl Sec) const {

  955   int32_t Num = Val;
  984 void ScalarTraits<int32_t>::output(const int32_t &Val, void *,
  989 StringRef ScalarTraits<int32_t>::input(StringRef Scalar, void *, int32_t &Val) {

 3961       int32_t Offset = LocMemOffset + BEAlign;
 9596   int32_t Bits = IntBits == 64 ? 64 : 32;
 9597   int32_t C = BV->getConstantFPSplatPow2ToLog2Int(&UndefElements, Bits + 1);
 9655   int32_t IntBits = IntTy.getSizeInBits();
 9660   int32_t FloatBits = FloatTy.getSizeInBits();
 9670   int32_t C = BV->getConstantFPSplatPow2ToLog2Int(&UndefElements, FloatBits + 1);

   89     int32_t Imm;
   90     RegImm(MCPhysReg Reg, int32_t Imm) : Reg(Reg), Imm(Imm) {}
  197         int32_t KnownImm = PredI.getOperand(2).getImm();
  198         int32_t Shift = PredI.getOperand(3).getImm();

  369   int32_t Exp = (Imm.lshr(10).getSExtValue() & 0x1f) - 15;  // -14 to 15
  370   int32_t Mantissa = Imm.getZExtValue() & 0x3ff;  // 10 bits
  395   int32_t Exp = (Imm.lshr(23).getSExtValue() & 0xff) - 127;  // -126 to 127
  788   auto S = bit_cast<std::array<int32_t, 2>>(Imm);
  792   if (isSVEMaskOfIdenticalElements<int32_t>(Imm) && isSVECpyImm<int32_t>(S[0]))
  792   if (isSVEMaskOfIdenticalElements<int32_t>(Imm) && isSVECpyImm<int32_t>(S[0]))

  602 int32_t AMDGPUAsmPrinter::SIFunctionResourceInfo::getTotalNumSGPRs(
  608 int32_t AMDGPUAsmPrinter::SIFunctionResourceInfo::getTotalNumVGPRs(
  691   int32_t MaxVGPR = -1;
  692   int32_t MaxAGPR = -1;
  693   int32_t MaxSGPR = -1;

   45     int32_t NumVGPR = 0;
   46     int32_t NumAGPR = 0;
   47     int32_t NumExplicitSGPR = 0;
   54     int32_t getTotalNumSGPRs(const GCNSubtarget &ST) const;
   55     int32_t getTotalNumVGPRs(const GCNSubtarget &ST) const;

 4028         return constantFoldBFE<int32_t>(DAG,

  649   int32_t call_convention;

  293         std::numeric_limits<int32_t>::max())
  299         std::numeric_limits<int32_t>::min())

  390   int32_t SImm = static_cast<int32_t>(Imm);

  518   int32_t Imm;
  870 static bool evalBinaryInstruction(unsigned Opcode, int32_t &Result,
 1005     int32_t NewImm;
 1028   int32_t Src1Val = static_cast<int32_t>(Src1->getImm());

 2760   int32_t FPDiff = 0;
 2820       int32_t Offset = LocMemOffset;

  117   int32_t NumVGPRsMax;
  118   int32_t NumSGPRsMax;
  268   int32_t getMaxVGPR() const { return VgprUB; }
  269   int32_t getMaxSGPR() const { return SgprUB; }
  359   int32_t VgprUB = 0;
  360   int32_t SgprUB = 0;

 2850     int32_t Trunc = static_cast<int32_t>(Imm);

  234                            int32_t NewOffset) const;
  236   MachineOperand createRegOrImm(int32_t Val, MachineInstr &MI) const;
  237   Optional<int32_t> extractConstOffset(const MachineOperand &Op) const;
 1355 SILoadStoreOptimizer::createRegOrImm(int32_t Val, MachineInstr &MI) const {
 1431                                                int32_t NewOffset) const {
 1436 Optional<int32_t>

  160                                int32_t &ReverseImm) {
  164   ReverseImm = reverseBits<int32_t>(static_cast<int32_t>(Src.getImm()));
  581           int32_t ReverseImm;
  673           int32_t ReverseImm;

 1156 bool isInlinableLiteral32(int32_t Literal, bool HasInv2Pi) {
 1201 bool isInlinableLiteralV216(int32_t Literal, bool HasInv2Pi) {

  624 bool isInlinableLiteral32(int32_t Literal, bool HasInv2Pi);
  630 bool isInlinableLiteralV216(int32_t Literal, bool HasInv2Pi);

  106     int32_t RHSC = RHS->getSExtValue();
  135     int32_t RHSC = RHS->getSExtValue();

 1342         int32_t NumBytes = AFI->getFramePtrSpillOffset();

 2388   int32_t ImmValue = cast<ConstantSDNode>(N->getOperand(3))->getZExtValue();
 2412     int32_t ImmValue = cast<ConstantSDNode>(N->getOperand(3))->getZExtValue();

11483       int32_t imm = C->getSExtValue();
13503   int32_t C = BV->getConstantFPSplatPow2ToLog2Int(&UndefElements, 33);
13561   int32_t C = BV->getConstantFPSplatPow2ToLog2Int(&UndefElements, 33);

  159         int32_t Enc = ARM_AM::getSOImmVal(MCOp.getImm());

 1361     int32_t Value = -(int32_t)CE->getValue();
 1369     int32_t Value = -(int32_t)CE->getValue();
 1435            (Val == std::numeric_limits<int32_t>::min());
 1528     return (Val == std::numeric_limits<int32_t>::min()) ||
 1549            Val == std::numeric_limits<int32_t>::min();
 1563            Val == std::numeric_limits<int32_t>::min();
 1579       Val == std::numeric_limits<int32_t>::min();
 1595            Val == std::numeric_limits<int32_t>::min();
 1694            Val == std::numeric_limits<int32_t>::min();
 1729     return (Val == std::numeric_limits<int32_t>::min()) ||
 1823     return (Val == std::numeric_limits<int32_t>::min()) ||
 1850            (Val == std::numeric_limits<int32_t>::min());
 1865            (Val == std::numeric_limits<int32_t>::min());
 1874            (Val == std::numeric_limits<int32_t>::min());
 2737     int32_t Imm = Memory.OffsetImm->getValue();
 2809     int32_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() : 0;
 2813       if (Val == std::numeric_limits<int32_t>::min()) Val = 0;
 2831     int32_t Val = CE->getValue();
 2834     if (Val == std::numeric_limits<int32_t>::min()) Val = 0;
 2853     int32_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() : 0;
 2857       if (Val == std::numeric_limits<int32_t>::min()) Val = 0;
 2873       int32_t Val =
 2882     int32_t Val = CE->getValue();
 2885     if (Val == std::numeric_limits<int32_t>::min()) Val = 0;
 2904     int32_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() / 4 : 0;
 2907     if (Val == std::numeric_limits<int32_t>::min()) Val = 0;
 2926     int32_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() / 2 : 0;
 2929     if (Val == std::numeric_limits<int32_t>::min()) Val = 0;
 2971     int32_t Val = Memory.OffsetImm ? Memory.OffsetImm->getValue() / 4 : 0;
 3096     if (Imm == std::numeric_limits<int32_t>::min()) Imm = 0;
 3107     if (Imm == std::numeric_limits<int32_t>::min()) Imm = 0;
 5512     int32_t Val = CE->getValue();
 5514       Val = std::numeric_limits<int32_t>::min();
 5762     int32_t Val = CE->getValue();
 5764       CE = MCConstantExpr::create(std::numeric_limits<int32_t>::min(),
 6060         int32_t Val = CE->getValue();
 6062           ImmVal = MCConstantExpr::create(std::numeric_limits<int32_t>::min(),

  701 static bool tryAddingSymbolicOperand(uint64_t Address, int32_t Value,

  655     int32_t Exp = (Imm.lshr(10).getSExtValue() & 0x1f) - 15;  // -14 to 15
  681     int32_t Exp = (Imm.lshr(23).getSExtValue() & 0xff) - 127;  // -126 to 127

  361   int32_t OffImm = (int32_t)MO1.getImm();
  742   int32_t lsb = countTrailingZeros(v);
  743   int32_t width = (32 - countLeadingZeros(v)) - lsb;
 1044   int32_t OffImm = (int32_t)MO.getImm() << scale;
 1189   int32_t OffImm = (int32_t)MO2.getImm();
 1213   int32_t OffImm = (int32_t)MO2.getImm();
 1242   int32_t OffImm = (int32_t)MO2.getImm();
 1277   int32_t OffImm = (int32_t)MO1.getImm();
 1292   int32_t OffImm = (int32_t)MO1.getImm();
 1389   int32_t Rotated = ARM_AM::rotr32(Bits, Rot);

  605   int32_t SImm = MO1.getImm();
  645 static int32_t encodeThumbBLOffset(int32_t offset) {
  645 static int32_t encodeThumbBLOffset(int32_t offset) {
  877   int32_t Val = MO.getImm();
 1008       int32_t Offset = MO.getImm();
 1043   int32_t Imm = MI.getOperand(OpIdx).getImm();
 1091     int32_t Imm = M1.getImm();
 1624   int32_t tmp = (int32_t)MO2.getImm();
 1644   int32_t tmp = (int32_t)MO1.getImm();

  145   int32_t Val;      ///< Enum member value

  257     int32_t V = cast<MCConstantExpr>(HE->getExpr())->getValue();

 2120     int32_t Imm = MI->getOperand(2).getImm();

   42 static int32_t adjustUp(int32_t V, uint8_t A, uint8_t O) {
   42 static int32_t adjustUp(int32_t V, uint8_t A, uint8_t O) {
   44   int32_t U = (V & -A) + O;
   48 static int32_t adjustDown(int32_t V, uint8_t A, uint8_t O) {
   48 static int32_t adjustDown(int32_t V, uint8_t A, uint8_t O) {
   50   int32_t U = (V & -A) + O;
   59     int32_t Min = INT_MIN, Max = INT_MAX;
   64     OffsetRange(int32_t L, int32_t H, uint8_t A, uint8_t O = 0)
   64     OffsetRange(int32_t L, int32_t H, uint8_t A, uint8_t O = 0)
   84     OffsetRange &shift(int32_t S) {
   90     OffsetRange &extendBy(int32_t D) {
  102     bool contains(int32_t V) const {
  126       int32_t MaxEnd;
  159     void nodesWith(Node *N, int32_t P, bool CheckA,
  180       int32_t Balance = height(N->Right) - height(N->Left);
  361       int32_t Offset;
  365       ExtValue(const ExtRoot &ER, int32_t Off) : ExtRoot(ER), Offset(Off) {}
  406                           Register ExtR, int32_t &Diff);
  609 void RangeTree::nodesWith(Node *N, int32_t P, bool CheckA,
 1080   int32_t Min = -alignDown((1<<S)-1, A);
 1084   int32_t Off = MI.getOperand(OffP).getImm();
 1085   int32_t Max = Off >= 0 ? 0 : -Off;
 1120   int32_t Min = -alignDown((1<<S)-1, A);
 1121   int32_t Max = 0;  // Force non-negative offsets.
 1285       int32_t D = alignDown(32767, Ranges[I-Begin].Align); // XXX hardcoded
 1329   std::map<int32_t, CandData> CandMap;
 1354   std::set<int32_t> CandSet;
 1373     using CMap = std::map<int32_t,unsigned>;
 1394     int32_t Best = BestIt->first;
 1701       Register ExtR, int32_t &Diff) {
 1721     int32_t D = isInt<16>(Diff) ? Diff : (Diff > 0 ? 32767 : -32768);
 1838   int32_t Diff = EV.Offset - DefV.Offset;

 2241     int32_t V32;
 2909           int32_t Hi = V >> 32;
 2910           int32_t Lo = V & 0xFFFFFFFFLL;

   70   int32_t Inc = cast<ConstantSDNode>(Offset.getNode())->getSExtValue();
  469   int32_t Inc = cast<ConstantSDNode>(Offset.getNode())->getSExtValue();
  579   int32_t ShlConst = cast<ConstantSDNode>(Shl_1)->getSExtValue();
  586       int32_t ValConst = C->getSExtValue() << ShlConst;
  607         int32_t ValConst = 1 << (ShlConst + C2->getSExtValue());
 1334     int32_t V = cast<const ConstantSDNode>(N)->getZExtValue();

  570   int32_t V = cast<ConstantSDNode>(Offset.getNode())->getSExtValue();
 2157       int32_t V = (Consts[0]->getZExtValue() & 0xFF) |

   92         int32_t LowWord = (ImmValue & 0xFFFFFFFF);
   93         int32_t HighWord = (ImmValue >> 32) & 0xFFFFFFFF;

   99     int32_t profit(const MachineInstr *MI) const;
  100     int32_t profit(unsigned Reg) const;
  308 static inline int32_t profitImm(unsigned Imm) {
  309   int32_t P = 0;
  315 int32_t HexagonSplitDoubleRegs::profit(const MachineInstr *MI) const {
  347       int32_t Prof1 = Op1.isImm() ? profitImm(Op1.getImm()) : 0;
  348       int32_t Prof2 = Op2.isImm() ? profitImm(Op2.getImm()) : 0;
  402 int32_t HexagonSplitDoubleRegs::profit(unsigned Reg) const {
  424   int32_t TotalP = 0;
  428     int32_t P = profit(DefI);
  460       int32_t P = profit(UseI);

  108       int32_t Imm = CN->getSExtValue();

  893   int32_t HighestOne = -1;
  928   int32_t InstrRequired = 2 * NonzeroEntries - 1;

 4931   int32_t ImmValue = Inst.getOperand(2).getImm();

 2202   int32_t BranchOffset = (SignExtend32<16>(Offset) * 4) + 4;
 2211   int32_t BranchOffset = (SignExtend32<16>(Offset) * 2);
 2229   int32_t BranchOffset = SignExtend32<21>(Offset) * 4 + 4;
 2239   int32_t BranchOffset = SignExtend32<21>(Offset) * 4 + 4;
 2249   int32_t BranchOffset = SignExtend32<26>(Offset) * 4 + 4;
 2259   int32_t BranchOffset = SignExtend32<8>(Offset << 1);
 2268   int32_t BranchOffset = SignExtend32<11>(Offset << 1);
 2277   int32_t BranchOffset = SignExtend32<16>(Offset) * 2 + 4;
 2286   int32_t BranchOffset = SignExtend32<27>(Offset << 1);
 2356   int32_t Imm = SignExtend32<Bits>(Value) * ScaleBy;
 2388   int32_t DecodedValue;
 2404   int32_t DecodedValues[] = {128, 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64,

  190 void MipsTargetStreamer::emitRI(unsigned Opcode, unsigned Reg0, int32_t Imm,

  342   int32_t lo = Imm & 0xFFFF;

  635     int32_t Log2 = ImmValue.exactLogBase2();
  722     int32_t Log2 = (~ImmValue).exactLogBase2();

  502     int32_t Log2IfPositive = (Mask->getAPIntValue() + 1).exactLogBase2();

  125   void emitRI(unsigned Opcode, unsigned Reg0, int32_t Imm, SMLoc IDLoc,

 1772   int32_t *vp = (int32_t *)&val;
 1773   for (unsigned i = 0; i < sizeof(int32_t); ++i) {

   67   int32_t Offset = SignExtend32<24>(Imm);

  410   int32_t Imm = SignExtend32<32>((unsigned)MI->getOperand(OpNo).getImm() << 2);

 8458   int32_t SextVal= (int32_t(SplatBits << (32-SplatBitSize)) >>

  828                                       std::numeric_limits<int32_t>::min(),

  525   int32_t ImmValue = RawImmValue;

  565   int32_t NumOperands;

  617   int32_t ImmVal = (int32_t)DefMI.getOperand(1).getImm();

 1239   int32_t d32;

  624   int32_t                       displacement;

   66     int32_t Disp;

 3950       int32_t Offset = VA.getLocMemOffset()+FPDiff;

  374   int32_t HighOffset = alignTo(Offset, 4);
  375   int32_t LowOffset = HighOffset - 4;

 1863     int32_t ExactLogBase2 = C2->exactLogBase2();

 1208   int32_t logScale = Scale.exactLogBase2();
 1271         int32_t Amt = cast<ConstantInt>(BO->getOperand(1))->

  902   int32_t UnknownCountInEdge = 0;
  903   int32_t UnknownCountOutEdge = 0;

  520     int32_t IncOrCmpUses = User->getNumUses();

   70 static std::string getStatString(const char *Msg, int32_t Fraction, int32_t All,
   70 static std::string getStatString(const char *Msg, int32_t Fraction, int32_t All,
   89   int32_t InlinedImportedFunctionsCount = 0;
   90   int32_t InlinedNotImportedFunctionsCount = 0;
   92   int32_t InlinedImportedFunctionsToImportingModuleCount = 0;
   93   int32_t InlinedNotImportedFunctionsToImportingModuleCount = 0;

   36 Optional<int32_t> InstrumentationMap::getFunctionId(uint64_t Addr) const {
   43 Optional<uint64_t> InstrumentationMap::getFunctionAddr(int32_t FuncId) const {
  132   int32_t FuncId = 1;

   83   int32_t FuncId;

  111   R.Size = E.getSigned(&OffsetPtr, sizeof(int32_t));
  185   R.Size = E.getSigned(&OffsetPtr, sizeof(int32_t));
  199   R.Delta = E.getSigned(&OffsetPtr, sizeof(int32_t));
  249   R.Size = E.getSigned(&OffsetPtr, sizeof(int32_t));
  263   R.Delta = E.getSigned(&OffsetPtr, sizeof(int32_t));
  356   R.TID = E.getSigned(&OffsetPtr, sizeof(int32_t));

  120       Record.FuncId = Reader.getSigned(&OffsetPtr, sizeof(int32_t));
  157       int32_t FuncId = Reader.getSigned(&OffsetPtr, sizeof(int32_t));
  157       int32_t FuncId = Reader.getSigned(&OffsetPtr, sizeof(int32_t));

   52 extern int __xray_set_handler(void (*entry)(int32_t, XRayEntryType));
   63 extern int __xray_set_handler_arg1(void (*entry)(int32_t, XRayEntryType,
  105 extern XRayPatchingStatus __xray_patch_function(int32_t FuncId);
  109 extern XRayPatchingStatus __xray_unpatch_function(int32_t FuncId);
  114 extern uintptr_t __xray_function_address(int32_t FuncId);

  187   void (*handle_arg0)(int32_t, XRayEntryType);

   89   int32_t FuncId = 0;
  115   int32_t FuncId = 0;

   44 typedef int32_t srep_t;

   95     p += sizeof(int32_t);

   48   int32_t FuncId;
  158 void InMemoryRawLog(int32_t FuncId, XRayEntryType Type,
  255 void InMemoryRawLogWithArg(int32_t FuncId, XRayEntryType Type, uint64_t Arg1,
  300 void basicLoggingHandleArg0RealTSC(int32_t FuncId,
  305 void basicLoggingHandleArg0EmulateTSC(int32_t FuncId, XRayEntryType Type)
  319 void basicLoggingHandleArg1RealTSC(int32_t FuncId, XRayEntryType Type,
  324 void basicLoggingHandleArg1EmulateTSC(int32_t FuncId, XRayEntryType Type,
  462 void basicLoggingHandleArg0Empty(int32_t, XRayEntryType) XRAY_NEVER_INSTRUMENT {

   31 void basicLoggingHandleArg0RealTSC(int32_t FuncId, XRayEntryType Entry);
   32 void basicLoggingHandleArg0EmulateTSC(int32_t FuncId, XRayEntryType Entry);
   33 void basicLoggingHandleArg1RealTSC(int32_t FuncId, XRayEntryType Entry,
   35 void basicLoggingHandleArg1EmulateTSC(int32_t FuncId, XRayEntryType Entry,

   51   constexpr int32_t mask(int32_t FuncId) const XRAY_NEVER_INSTRUMENT {
   51   constexpr int32_t mask(int32_t FuncId) const XRAY_NEVER_INSTRUMENT {
  181   bool rewindRecords(int32_t FuncId, uint64_t TSC,
  244   bool functionEnter(int32_t FuncId, uint64_t TSC,
  268   bool functionTailExit(int32_t FuncId, uint64_t TSC,
  293   bool functionEnterArg(int32_t FuncId, uint64_t TSC, uint16_t CPU,
  310   bool functionExit(int32_t FuncId, uint64_t TSC,
  334                    int32_t EventSize) XRAY_NEVER_INSTRUMENT {
  348                   const void *Event, int32_t EventSize) XRAY_NEVER_INSTRUMENT {

  129   bool writeFunction(FunctionRecordKind Kind, int32_t FuncId, int32_t Delta) {
  129   bool writeFunction(FunctionRecordKind Kind, int32_t FuncId, int32_t Delta) {
  139   bool writeFunctionWithArg(FunctionRecordKind Kind, int32_t FuncId,
  140                             int32_t Delta, uint64_t Arg) {
  167   bool writeCustomEvent(int32_t Delta, const void *Event, int32_t EventSize) {
  167   bool writeCustomEvent(int32_t Delta, const void *Event, int32_t EventSize) {
  192   bool writeTypedEvent(int32_t Delta, uint16_t EventType, const void *Event,
  193                        int32_t EventSize) {

  495 void fdrLoggingHandleArg0(int32_t FuncId,
  525 void fdrLoggingHandleArg1(int32_t FuncId, XRayEntryType Entry,
  567       static_cast<std::size_t>(std::numeric_limits<int32_t>::max())) {
  572                  std::numeric_limits<int32_t>::max());
  580   int32_t ReducedEventSize = static_cast<int32_t>(EventSize);
  597       static_cast<std::size_t>(std::numeric_limits<int32_t>::max())) {
  602                  std::numeric_limits<int32_t>::max());
  610   int32_t ReducedEventSize = static_cast<int32_t>(EventSize);

   31 void fdrLoggingHandleArg0(int32_t FuncId, XRayEntryType Entry);
   32 void fdrLoggingHandleArg1(int32_t FuncId, XRayEntryType Entry, uint64_t Arg1);

  100     int32_t FId;
  116     int32_t FId;
  358   void enterFunction(const int32_t FId, uint64_t TSC,
  417   void exitFunction(int32_t FId, uint64_t TSC,

  150                int32_t FuncId) XRAY_NEVER_INSTRUMENT {
  178 XRayPatchingStatus patchFunction(int32_t FuncId,
  312 XRayPatchingStatus mprotectAndPatchFunction(int32_t FuncId,
  371 int __xray_set_handler(void (*entry)(int32_t,
  439 XRayPatchingStatus __xray_patch_function(int32_t FuncId) XRAY_NEVER_INSTRUMENT {
  444 __xray_unpatch_function(int32_t FuncId) XRAY_NEVER_INSTRUMENT {
  448 int __xray_set_handler_arg1(void (*entry)(int32_t, XRayEntryType, uint64_t)) {
  463 uintptr_t __xray_function_address(int32_t FuncId) XRAY_NEVER_INSTRUMENT {

  149 using PathArray = Array<int32_t>;
  211     constexpr int32_t SentinelFId = 0;

  271 void profilingHandleArg0(int32_t FuncId,
  310 void profilingHandleArg1(int32_t FuncId, XRayEntryType Entry,

  127 static constexpr int64_t MinOffset{std::numeric_limits<int32_t>::min()};
  128 static constexpr int64_t MaxOffset{std::numeric_limits<int32_t>::max()};

   86   int32_t flags; // Flags associated with the entry, e.g. 'link'.
   87   int32_t reserved; // Reserved, to be used by the runtime library.
  101   int32_t NumDeviceImages;           // Number of device types supported
  145 void __tgt_target_data_begin(int64_t device_id, int32_t arg_num,
  148 void __tgt_target_data_begin_nowait(int64_t device_id, int32_t arg_num,
  151                                     int32_t depNum, void *depList,
  152                                     int32_t noAliasDepNum,
  158 void __tgt_target_data_end(int64_t device_id, int32_t arg_num, void **args_base,
  160 void __tgt_target_data_end_nowait(int64_t device_id, int32_t arg_num,
  163                                   int32_t depNum, void *depList,
  164                                   int32_t noAliasDepNum, void *noAliasDepList);
  167 void __tgt_target_data_update(int64_t device_id, int32_t arg_num,
  170 void __tgt_target_data_update_nowait(int64_t device_id, int32_t arg_num,
  173                                      int32_t depNum, void *depList,
  174                                      int32_t noAliasDepNum,
  183 int __tgt_target(int64_t device_id, void *host_ptr, int32_t arg_num,
  186 int __tgt_target_nowait(int64_t device_id, void *host_ptr, int32_t arg_num,
  188                         int64_t *arg_types, int32_t depNum, void *depList,
  189                         int32_t noAliasDepNum, void *noAliasDepList);
  191 int __tgt_target_teams(int64_t device_id, void *host_ptr, int32_t arg_num,
  193                        int64_t *arg_types, int32_t num_teams,
  194                        int32_t thread_limit);
  196                               int32_t arg_num, void **args_base, void **args,
  198                               int32_t num_teams, int32_t thread_limit,
  198                               int32_t num_teams, int32_t thread_limit,
  199                               int32_t depNum, void *depList,
  200                               int32_t noAliasDepNum, void *noAliasDepList);

  310   int32_t rc = RTL->init_device(RTLDeviceID);
  317 int32_t DeviceTy::initOnce() {
  341 int32_t DeviceTy::data_submit(void *TgtPtrBegin, void *HstPtrBegin,
  347 int32_t DeviceTy::data_retrieve(void *HstPtrBegin, void *TgtPtrBegin,
  353 int32_t DeviceTy::run_region(void *TgtEntryPtr, void **TgtVarsPtr,
  354     ptrdiff_t *TgtOffsets, int32_t TgtVarsSize) {
  360 int32_t DeviceTy::run_team_region(void *TgtEntryPtr, void **TgtVarsPtr,
  361     ptrdiff_t *TgtOffsets, int32_t TgtVarsSize, int32_t NumTeams,
  361     ptrdiff_t *TgtOffsets, int32_t TgtVarsSize, int32_t NumTeams,
  362     int32_t ThreadLimit, uint64_t LoopTripCount) {

   84   int32_t DeviceID;
   86   int32_t RTLDeviceID;
  101   std::map<int32_t, uint64_t> LoopTripCnt;
  146   int32_t initOnce();
  149   int32_t data_submit(void *TgtPtrBegin, void *HstPtrBegin, int64_t Size);
  150   int32_t data_retrieve(void *HstPtrBegin, void *TgtPtrBegin, int64_t Size);
  152   int32_t run_region(void *TgtEntryPtr, void **TgtVarsPtr,
  153       ptrdiff_t *TgtOffsets, int32_t TgtVarsSize);
  154   int32_t run_team_region(void *TgtEntryPtr, void **TgtVarsPtr,
  155       ptrdiff_t *TgtOffsets, int32_t TgtVarsSize, int32_t NumTeams,
  155       ptrdiff_t *TgtOffsets, int32_t TgtVarsSize, int32_t NumTeams,
  156       int32_t ThreadLimit, uint64_t LoopTripCount);

   92 EXTERN void __tgt_target_data_begin(int64_t device_id, int32_t arg_num,
  126 EXTERN void __tgt_target_data_begin_nowait(int64_t device_id, int32_t arg_num,
  128     int32_t depNum, void *depList, int32_t noAliasDepNum,
  128     int32_t depNum, void *depList, int32_t noAliasDepNum,
  140 EXTERN void __tgt_target_data_end(int64_t device_id, int32_t arg_num,
  179 EXTERN void __tgt_target_data_end_nowait(int64_t device_id, int32_t arg_num,
  181     int32_t depNum, void *depList, int32_t noAliasDepNum,
  181     int32_t depNum, void *depList, int32_t noAliasDepNum,
  190 EXTERN void __tgt_target_data_update(int64_t device_id, int32_t arg_num,
  213     int64_t device_id, int32_t arg_num, void **args_base, void **args,
  214     int64_t *arg_sizes, int64_t *arg_types, int32_t depNum, void *depList,
  215     int32_t noAliasDepNum, void *noAliasDepList) {
  223 EXTERN int __tgt_target(int64_t device_id, void *host_ptr, int32_t arg_num,
  254     int32_t arg_num, void **args_base, void **args, int64_t *arg_sizes,
  255     int64_t *arg_types, int32_t depNum, void *depList, int32_t noAliasDepNum,
  255     int64_t *arg_types, int32_t depNum, void *depList, int32_t noAliasDepNum,
  265     int32_t arg_num, void **args_base, void **args, int64_t *arg_sizes,
  266     int64_t *arg_types, int32_t team_num, int32_t thread_limit) {
  266     int64_t *arg_types, int32_t team_num, int32_t thread_limit) {
  297     int32_t arg_num, void **args_base, void **args, int64_t *arg_sizes,
  298     int64_t *arg_types, int32_t team_num, int32_t thread_limit, int32_t depNum,
  298     int64_t *arg_types, int32_t team_num, int32_t thread_limit, int32_t depNum,
  298     int64_t *arg_types, int32_t team_num, int32_t thread_limit, int32_t depNum,
  299     void *depList, int32_t noAliasDepNum, void *noAliasDepList) {

   66   int32_t device_id = Device.DeviceID;
  208 static int32_t member_of(int64_t type) {
  213 int target_data_begin(DeviceTy &Device, int32_t arg_num,
  216   for (int32_t i = 0; i < arg_num; ++i) {
  303           int32_t parent_idx = member_of(arg_types[i]);
  346 int target_data_end(DeviceTy &Device, int32_t arg_num, void **args_base,
  349   for (int32_t i = arg_num - 1; i >= 0; --i) {
  404             int32_t parent_idx = member_of(arg_types[i]);
  479 int target_data_update(DeviceTy &Device, int32_t arg_num,
  482   for (int32_t i = 0; i < arg_num; ++i) {
  580 int target(int64_t device_id, void *host_ptr, int32_t arg_num,
  582     int32_t team_num, int32_t thread_limit, int IsTeamConstruct) {
  582     int32_t team_num, int32_t thread_limit, int IsTeamConstruct) {
  651   for (int32_t i = 0; i < arg_num; ++i) {

   20 extern int target_data_begin(DeviceTy &Device, int32_t arg_num,
   23 extern int target_data_end(DeviceTy &Device, int32_t arg_num, void **args_base,
   26 extern int target_data_update(DeviceTy &Device, int32_t arg_num,
   29 extern int target(int64_t device_id, void *host_ptr, int32_t arg_num,
   31     int32_t team_num, int32_t thread_limit, int IsTeamConstruct);
   31     int32_t team_num, int32_t thread_limit, int IsTeamConstruct);
   85 int32_t __kmpc_omp_taskwait(void *loc_ref, int32_t gtid) __attribute__((weak));
   85 int32_t __kmpc_omp_taskwait(void *loc_ref, int32_t gtid) __attribute__((weak));
   86 int32_t __kmpc_global_thread_num(void *) __attribute__((weak));

  152   for (int32_t i = 0; i < RTL.NumberOfDevices; ++i) {
  167   for (int32_t i = 0; i < RTL->NumberOfDevices; ++i) {
  239   for (int32_t i = 0; i < desc->NumDeviceImages; ++i) {
  263         for (int32_t device_id = 0; device_id < R.NumberOfDevices;
  325   for (int32_t i = 0; i < desc->NumDeviceImages; ++i) {
  350       for (int32_t i = 0; i < FoundRTL->NumberOfDevices; ++i) {

   27   typedef int32_t(is_valid_binary_ty)(void *);
   28   typedef int32_t(number_of_devices_ty)();
   29   typedef int32_t(init_device_ty)(int32_t);
   29   typedef int32_t(init_device_ty)(int32_t);
   30   typedef __tgt_target_table *(load_binary_ty)(int32_t, void *);
   31   typedef void *(data_alloc_ty)(int32_t, int64_t, void *);
   32   typedef int32_t(data_submit_ty)(int32_t, void *, void *, int64_t);
   32   typedef int32_t(data_submit_ty)(int32_t, void *, void *, int64_t);
   33   typedef int32_t(data_retrieve_ty)(int32_t, void *, void *, int64_t);
   33   typedef int32_t(data_retrieve_ty)(int32_t, void *, void *, int64_t);
   34   typedef int32_t(data_delete_ty)(int32_t, void *);
   34   typedef int32_t(data_delete_ty)(int32_t, void *);
   35   typedef int32_t(run_region_ty)(int32_t, void *, void **, ptrdiff_t *,
   35   typedef int32_t(run_region_ty)(int32_t, void *, void **, ptrdiff_t *,
   36                                  int32_t);
   37   typedef int32_t(run_team_region_ty)(int32_t, void *, void **, ptrdiff_t *,
   37   typedef int32_t(run_team_region_ty)(int32_t, void *, void **, ptrdiff_t *,
   38                                       int32_t, int32_t, int32_t, uint64_t);
   38                                       int32_t, int32_t, int32_t, uint64_t);
   38                                       int32_t, int32_t, int32_t, uint64_t);
   41   int32_t Idx;                     // RTL index, index is the number of devices
   45   int32_t NumberOfDevices;         // Number of devices this RTL deals with.

  223                                       uint32_t NVOffset, int32_t VBPtrOffset,
  227       const CXXRecordDecl *Derived, uint32_t NVOffset, int32_t VBPtrOffset,

  232 inline ValueType ValueType::getValueType<int32_t>() {
  601         return Vs.reduceLiteralT(as<int32_t>());

  583             printLiteralT(&E->as<int32_t>(), SS);

  124       int32_t VtordispOffset;
  128       int32_t VBPtrOffset;
  131       int32_t VBOffsetOffset;

   96       void *Location = Code.data() + Reloc - sizeof(int32_t);
   97       const int32_t Offset = Target - static_cast<int64_t>(Reloc);
   98       endian::write<int32_t, endianness::native, 1>(Location, Offset);
  104 int32_t ByteCodeEmitter::getOffset(LabelTy Label) {
  106   const int64_t Position = Code.size() + sizeof(Opcode) + sizeof(int32_t);

   97   int32_t getOffset(LabelTy Label);

   48 template <> struct Repr<32, true> { using Type = int32_t; };

   82 static bool Jmp(InterpState &S, CodePtr &PC, int32_t Offset) {
   87 static bool Jt(InterpState &S, CodePtr &PC, int32_t Offset) {
   94 static bool Jf(InterpState &S, CodePtr &PC, int32_t Offset) {

   29   CodePtr &operator+=(int32_t Offset) {
   34   int32_t operator-(const CodePtr &RHS) const {

  163                               int32_t VBPtrOffset, uint32_t VBIndex,
  168                                         uint32_t NVOffset, int32_t VBPtrOffset,
 3187     uint32_t NVOffset, int32_t VBPtrOffset, uint32_t VBIndex,
 3231     const CXXRecordDecl *Derived, uint32_t NVOffset, int32_t VBPtrOffset,

 2559     int32_t Offset = 0;

 1257   int32_t FlagsForOwnership(Qualifiers::ObjCLifetime Ownership) {
 3198     int32_t word = 0;

 4017     llvm::Constant *ID, llvm::Constant *Addr, uint64_t Size, int32_t Flags,

  225                                   uint64_t Size, int32_t Flags,

 1836                                               uint64_t Size, int32_t,

   98                           uint64_t Size, int32_t Flags,

  581                                        int32_t VBPtrOffset,
  582                                        int32_t VBTableOffset,
  751                                    int32_t VBPtrOffset = -1,
 2190     int32_t IntSize = CGF.getIntSize().getQuantity();
 3654   int32_t VBPtrOffset = -1;
 4002                                                   int32_t VBPtrOffset,
 4130       int32_t VBPtrOffset = -1;

 3031     int32_t Min = A.IsSigned ? -(1 << (A.BitWidth - 1)) : 0;
 3032     int32_t Max = (1 << (A.IsSigned ? A.BitWidth - 1 : A.BitWidth)) - 1;
 6046     if (Result > std::numeric_limits<int32_t>::max())
 6048              << std::numeric_limits<int32_t>::max() << Arg->getSourceRange();

 3354   int32_t NumArgs = getFunctionOrMethodNumParams(D);
 3373     int32_t ArgIdx;

  335         sizeof(int32_t) + // Size of contents (w/o this field
  337         sizeof(int32_t) + // Offset of CU in the .debug_info section

   61 static void add32(uint8_t *p, int32_t v) { write32le(p, read32le(p) + v); }
  162 static void applyBranch20T(uint8_t *off, int32_t v) {
  172 void applyBranch24T(uint8_t *off, int32_t v) {

  671 void applyBranch24T(uint8_t *off, int32_t v);

  571       int32_t ord;

  311   int32_t sectionNumber = sym.getSectionNumber();
  353   int32_t sectionNumber = sym.getSectionNumber();
  606   int32_t sectionNumber = sym.getSectionNumber();

   41                 int32_t index, unsigned relOff) const override;
  216                        uint64_t pltEntryAddr, int32_t index,
  278 static void or32le(uint8_t *p, int32_t v) { write32le(p, read32le(p) | v); }
  571                 int32_t index, unsigned relOff) const override;
  631                              uint64_t pltEntryAddr, int32_t index,

   38                 int32_t index, unsigned relOff) const override;
  218                          uint64_t pltEntryAddr, int32_t index,
  234                    uint64_t pltEntryAddr, int32_t index,

   37                 int32_t index, unsigned relOff) const override;
  203 static void or32le(uint8_t *p, int32_t v) { write32le(p, read32le(p) | v); }
  306                        uint64_t pltEntryAddr, int32_t index,

   36                 int32_t index, unsigned relOff) const override;
  310                           uint64_t pltEntryAddr, int32_t index,

   35     int32_t index, unsigned relOff) const override {

  204                 int32_t index, unsigned relOff) const override;
  671                      uint64_t pltEntryAddr, int32_t index,
  673   int32_t offset = pltHeaderSize + index * pltEntrySize;
 1039   int32_t firstInstr = read32(loc + 4);
 1070   int32_t stackFrameSize = (hiImm * 65536) + loImm;
 1078   int32_t adjustedStackFrameSize =

   31                 int32_t index, unsigned relOff) const override;
  166                      uint64_t pltEntryAddr, int32_t index,

   30                 int32_t index, unsigned relOff) const override;
  128                        uint64_t pltEntryAddr, int32_t index,

   37                 int32_t index, unsigned relOff) const override;
  217                    uint64_t pltEntryAddr, int32_t index,
  419                 int32_t index, unsigned relOff) const override;
  428                 int32_t index, unsigned relOff) const override;
  463                             uint64_t pltEntryAddr, int32_t index,
  521                               uint64_t pltEntryAddr, int32_t index,

   37                 int32_t index, unsigned relOff) const override;
  159                       uint64_t pltEntryAddr, int32_t index,
  587                 int32_t index, unsigned relOff) const override;
  596                 int32_t index, unsigned relOff) const override;
  632                          uint64_t pltEntryAddr, int32_t index,
  675                              uint64_t pltEntryAddr, int32_t index,

  239   int32_t splitStackAdjustSize;

 1207 void DynamicSection<ELFT>::add(int32_t tag, std::function<uint64_t()> fn) {
 1212 void DynamicSection<ELFT>::addInt(int32_t tag, uint64_t val) {
 1217 void DynamicSection<ELFT>::addInSec(int32_t tag, InputSection *sec) {
 1222 void DynamicSection<ELFT>::addInSecRelative(int32_t tag, InputSection *sec) {
 1229 void DynamicSection<ELFT>::addOutSec(int32_t tag, OutputSection *sec) {
 1234 void DynamicSection<ELFT>::addSize(int32_t tag, OutputSection *sec) {
 1239 void DynamicSection<ELFT>::addSym(int32_t tag, Symbol *sym) {
 1502   for (std::pair<int32_t, std::function<uint64_t()>> &kv : entries) {
 1529                                              int32_t dynamicTag,
 1530                                              int32_t sizeDynamicTag)

  466   std::vector<std::pair<int32_t, std::function<uint64_t()>>> entries;
  475   void add(int32_t tag, std::function<uint64_t()> fn);
  476   void addInt(int32_t tag, uint64_t val);
  477   void addInSec(int32_t tag, InputSection *sec);
  478   void addInSecRelative(int32_t tag, InputSection *sec);
  479   void addOutSec(int32_t tag, OutputSection *sec);
  480   void addSize(int32_t tag, OutputSection *sec);
  481   void addSym(int32_t tag, Symbol *sym);
  488   RelocationBaseSection(StringRef name, uint32_t type, int32_t dynamicTag,
  489                         int32_t sizeDynamicTag);
  502   int32_t dynamicTag, sizeDynamicTag;

   45                         uint64_t pltEntryAddr, int32_t index,

  130 int32_t ArchHandler::readS32(const uint8_t *addr, bool isBig) {

  239     int32_t             addend;
  246     int32_t             addend;
  314   static int32_t  readS32(const uint8_t *addr, bool isBig);

  185   static int32_t getDisplacementFromThumbBranch(uint32_t instruction, uint32_t);
  186   static int32_t getDisplacementFromArmBranch(uint32_t instruction);
  190   static uint32_t setDisplacementInArmBranch(uint32_t instr, int32_t disp,
  193                                                int32_t disp, bool targetThumb);
  356 int32_t ArchHandler_arm::getDisplacementFromArmBranch(uint32_t instruction) {
  358   int32_t displacement = (instruction & 0x00FFFFFF) << 2;
  369                                                      int32_t displacement,
  398 int32_t ArchHandler_arm::getDisplacementFromThumbBranch(uint32_t instruction,
  410   int32_t sdis = dis;
  411   int32_t result = s ? (sdis | 0xFE000000) : sdis;
  425                                                        int32_t displacement,
  533   int32_t displacement;
  913   int32_t displacement;
 1077   int32_t displacement;

  229   static uint32_t setDisplacementInBranch26(uint32_t instr, int32_t disp);
  335                                                       int32_t displacement) {
  594   int32_t displacement;

  994   int32_t res = read32(addr, isBig);
 1150       int32_t funcDelta = read32(frameData + PersonalityFunctionField, isBig);

  105   int32_t off = outputOffset - getInputSectionOffset();
  150   int32_t off = outputOffset - getInputSectionOffset();

   60   int32_t outputOffset = 0;
  110   int32_t outputSegmentOffset = 0;

   96   llvm::DenseMap<WasmSignature, int32_t> typeIndices;

   75 void writeSleb128(raw_ostream &os, int32_t number, const Twine &msg) {
  120 void writeI32Const(raw_ostream &os, int32_t number, const Twine &msg) {
  125 void writeI64Const(raw_ostream &os, int32_t number, const Twine &msg) {

   23 void writeSleb128(raw_ostream &os, int32_t number, const Twine &msg);
   39 void writeI32Const(raw_ostream &os, int32_t number, const Twine &msg);
   41 void writeI64Const(raw_ostream &os, int32_t number, const Twine &msg);

   62   int32_t GetSignedInt32(lldb::SBError &error, lldb::offset_t offset);
  109                                                 int32_t *array,
  125   bool SetDataFromSInt32Array(int32_t *array, size_t array_len);

   33   const char *GetSignalAsCString(int32_t signo) const;
   35   int32_t GetSignalNumberFromName(const char *name) const;
   37   bool GetShouldSuppress(int32_t signo) const;
   39   bool SetShouldSuppress(int32_t signo, bool value);
   41   bool GetShouldStop(int32_t signo) const;
   43   bool SetShouldStop(int32_t signo, bool value);
   45   bool GetShouldNotify(int32_t signo) const;
   47   bool SetShouldNotify(int32_t signo, bool value);
   49   int32_t GetNumSignals() const;
   51   int32_t GetSignalAtIndex(int32_t index) const;
   51   int32_t GetSignalAtIndex(int32_t index) const;

   41   int32_t GetHardwareIndex();

  117                     int32_t ignore = 0, bool one_shot = false,

  234         int32_t signed_data32; // signed immediate data
  310     void SetISAAndImmediateSigned(uint32_t isa, int32_t data) {

  955                                           int32_t synthetic_index);

   67   int32_t m_byte_offset;
   85                    int32_t byte_offset, uint32_t bitfield_bit_size,

   82                                   int32_t synthetic_index) override;

   39                                   int32_t synthetic_index) override;

   34                               int32_t byte_offset, uint32_t bitfield_bit_size,
   45                                   int32_t synthetic_index) override;

   42                                   int32_t synthetic_index);

   52                                   int32_t synthetic_index) override;
   89                                   int32_t synthetic_index) override;

   22 typedef int32_t dw_sleb128_t;

  100                                            int32_t num_resumes);

  103                                 int32_t &port, Status *error_ptr);

   23 int32_t ToSInt32(const char *s, int32_t fail_value = 0, int base = 0,
   23 int32_t ToSInt32(const char *s, int32_t fail_value = 0, int base = 0,

   27                               int32_t fail_value, Status &error);

  152   void Dump(Stream *s, lldb::addr_t base_addr, int32_t depth,

  756       uint32_t &child_byte_size, int32_t &child_byte_offset,

  300       int32_t &child_byte_offset, uint32_t &child_bitfield_bit_size,

   95     int32_t data_align;
  142                                int32_t data_align, lldb::offset_t &offset,

  332       uint32_t &child_byte_size, int32_t &child_byte_offset,

  108       void SetAtCFAPlusOffset(int32_t offset) {
  113       void SetIsCFAPlusOffset(int32_t offset) {
  118       void SetAtAFAPlusOffset(int32_t offset) {
  123       void SetIsAFAPlusOffset(int32_t offset) {
  141       int32_t GetOffset() const {
  187         int32_t offset;
  218       void SetRaSearch(int32_t offset) {
  227       void SetIsRegisterPlusOffset(uint32_t reg_num, int32_t offset) {
  258       int32_t GetOffset() const {
  269       void IncOffset(int32_t delta) {
  274       void SetOffset(int32_t offset) {
  311           int32_t offset;
  319         int32_t ra_search_offset;
  348     bool SetRegisterLocationToAtCFAPlusOffset(uint32_t reg_num, int32_t offset,
  351     bool SetRegisterLocationToIsCFAPlusOffset(uint32_t reg_num, int32_t offset,

  635   virtual int32_t GetResumeCountForLaunchInfo(ProcessLaunchInfo &launch_info) {

  590   int32_t m_iteration_count = 1;

   32   const char *GetSignalAsCString(int32_t signo) const;
   34   bool SignalIsValid(int32_t signo) const;
   36   int32_t GetSignalNumberFromName(const char *name) const;
   38   const char *GetSignalInfo(int32_t signo, bool &should_suppress,
   41   bool GetShouldSuppress(int32_t signo) const;
   43   bool SetShouldSuppress(int32_t signo, bool value);
   47   bool GetShouldStop(int32_t signo) const;
   49   bool SetShouldStop(int32_t signo, bool value);
   52   bool GetShouldNotify(int32_t signo) const;
   54   bool SetShouldNotify(int32_t signo, bool value);
   61   int32_t GetFirstSignalNumber() const;
   63   int32_t GetNextSignalNumber(int32_t current_signal) const;
   63   int32_t GetNextSignalNumber(int32_t current_signal) const;
   65   int32_t GetNumSignals() const;
   67   int32_t GetSignalAtIndex(int32_t index) const;
   67   int32_t GetSignalAtIndex(int32_t index) const;
   91   std::vector<int32_t> GetFilteredSignals(llvm::Optional<bool> should_suppress,
  112   typedef std::map<int32_t, Signal> collection;

  284   Stream &operator<<(int32_t sval);

   75   int32_t GetS32(int32_t fail_value, int base = 0);
   75   int32_t GetS32(int32_t fail_value, int base = 0);

   88 typedef int32_t break_id_t;
   89 typedef int32_t watch_id_t;

  279 int32_t SBData::GetSignedInt32(lldb::SBError &error, lldb::offset_t offset) {
  283   int32_t value = 0;
  475                                                int32_t *array,
  484   size_t data_len = array_len * sizeof(int32_t);
  606 bool SBData::SetDataFromSInt32Array(int32_t *array, size_t array_len) {
  615   size_t data_len = array_len * sizeof(int32_t);

   70 const char *SBUnixSignals::GetSignalAsCString(int32_t signo) const {
   80 int32_t SBUnixSignals::GetSignalNumberFromName(const char *name) const {
   90 bool SBUnixSignals::GetShouldSuppress(int32_t signo) const {
  100 bool SBUnixSignals::SetShouldSuppress(int32_t signo, bool value) {
  112 bool SBUnixSignals::GetShouldStop(int32_t signo) const {
  122 bool SBUnixSignals::SetShouldStop(int32_t signo, bool value) {
  134 bool SBUnixSignals::GetShouldNotify(int32_t signo) const {
  144 bool SBUnixSignals::SetShouldNotify(int32_t signo, bool value) {
  156 int32_t SBUnixSignals::GetNumSignals() const {
  165 int32_t SBUnixSignals::GetSignalAtIndex(int32_t index) const {
  165 int32_t SBUnixSignals::GetSignalAtIndex(int32_t index) const {

   98 int32_t SBWatchpoint::GetHardwareIndex() {
  101   int32_t hw_index = -1;

  134                                      int32_t ignore, bool one_shot, 
  242   int32_t ignore_count = 0;

  250         int32_t offset = 0;
  274     llvm::Optional<int32_t> relative_frame_offset;

 1335   void PrintSignal(Stream &str, int32_t signo, const char *sig_name,
 1358         int32_t signo = signals_sp->GetSignalNumberFromName(
 1366       int32_t signo = signals_sp->GetFirstSignalNumber();
 1422         int32_t signo = signals_sp->GetSignalNumberFromName(arg.c_str());
 1446           int32_t signo = signals_sp->GetFirstSignalNumber();

  263         int32_t input_count = 0;
 1747     int32_t m_line_offset;
 1792       int32_t line = (int32_t)m_options.m_line_num;

   58 static int32_t WithRSAIndex(llvm::StringRef Arg) {
   88   int32_t idx;

   53   int32_t v = (int16_t)half;

  641                                              int32_t synthetic_index) {
  648   int32_t child_byte_offset = 0;
 2835     int32_t child_byte_offset = 0;

   31     ConstString name, uint64_t byte_size, int32_t byte_offset,

  259     size_t idx, bool synthetic_array_member, int32_t synthetic_index) {

   48     size_t idx, bool synthetic_array_member, int32_t synthetic_index) {

   26     ConstString name, uint32_t byte_size, int32_t byte_offset,
   60     size_t idx, bool synthetic_array_member, int32_t synthetic_index) {

   49     size_t idx, bool synthetic_array_member, int32_t synthetic_index) {
   61   int32_t child_byte_offset = 0;

   90     size_t idx, bool synthetic_array_member, int32_t synthetic_index) {
  178     size_t idx, bool synthetic_array_member, int32_t synthetic_index) {

  246     bool first_arg_is_full_shell_command, int32_t num_resumes) {

  178   int32_t port = INT32_MIN;
  283                                int32_t &port, Status *error_ptr) {

   16 int32_t ToSInt32(const char *s, int32_t fail_value, int base,
   16 int32_t ToSInt32(const char *s, int32_t fail_value, int base,

  148   int32_t port = INT32_MIN;
  184   int32_t port = INT32_MIN;

   66   int32_t port = INT32_MIN;

   49                                       int32_t fail_value, Status &error) {

   81     int32_t result;

  108   int32_t idx = 0;

 1838   const int32_t ptr_size = 4;

 2003   const int32_t ptr_size = 8;

 1046   const int32_t ptr_size = 4;

 1952   const int32_t ptr_size = 4;

 1975   const int32_t ptr_size = 8;

  776   const int32_t ptr_size = 4;

  900   const int32_t ptr_size = 4;

  553   int32_t m_src_offs = 0;
  554   int32_t m_dst_offs = 0;
  844   bool ExtractFromRegs(int32_t offs, uint32_t size, void *buf) {
  904     int32_t child_offs;
 1002   const int32_t ptr_size = 8;

 1039   const int32_t ptr_size = 8;

 1745   const int32_t ptr_size = 8;

   47 static int32_t GetLocalEntryOffset(const Symbol &sym) {
   62   int32_t loffs = GetLocalEntryOffset(func);

 1978     int32_t reg_value = ReadCoreReg(Rm, &success);
 2034     int32_t imm32; // PC-relative offset
 2826     int32_t imm32; // PC-relative offset
 3986     int32_t offset = 0;
 4037       int32_t offset = addr_byte_size * BitCount(registers);
 4103     int32_t offset = 0;
 4242     int32_t offset = 0;
 4354     int32_t offset = 0;
 4665     int32_t offset = 0;
 4786     int32_t offset = 0;
 4933     int32_t offset = 0;
 5057     int32_t offset = 0;
 5271       int32_t offset = address - base_address;
 5411     int32_t offset = 0;
 5853     int32_t val1 = ReadCoreReg(Rn, &success);
 5932     int32_t val1 = ReadCoreReg(Rn, &success);
 5937     int32_t val2 = ReadCoreReg(Rm, &success);

 1141   int32_t offset = llvm::SignExtend64<21>(Bits32(opcode, 23, 5) << 2);

 1240   int32_t address;
 1302   int32_t imm, address;
 1752   int32_t imm5 = insn.getOperand(0).getImm();
 1761   int32_t src_opd_val =
 1766   int32_t ra_val =
 1771   int32_t result = src_opd_val + imm5;
 1792 static int IsAdd64bitOverflow(int32_t a, int32_t b) {
 1792 static int IsAdd64bitOverflow(int32_t a, int32_t b) {
 1793   int32_t r = (uint32_t)a + (uint32_t)b;
 1805   int32_t offset, pc, target = 0, rs_val, rt_val;
 1854   int32_t offset, pc, target = 0, rs_val, rt_val;
 1933   int32_t offset, pc, target = 0;
 1934   int32_t rs_val;
 2002   int32_t offset, pc, target = 0;
 2003   int32_t rs_val;
 2052   int32_t offset, pc, target = 0;
 2053   int32_t rs_val;
 2105   int32_t offset, pc, target = 0;
 2106   int32_t rs_val;
 2164   int32_t offset, pc, target;
 2191   int32_t target = 0;
 2215   int32_t offset = insn.getOperand(1).getImm();
 2217   int32_t pc =
 2222   int32_t rs_val = (int32_t)ReadRegisterUnsigned(
 2377   int32_t pc = 0, rs_val = 0;
 2413   int32_t offset, pc, target;
 2444   int32_t offset, pc, target;
 2475   int32_t offset, pc, target;
 2588   int32_t target, offset, pc, rt_val;
 2626   int32_t target, offset, rt_val;
 2679   int32_t pc, offset, target = 0;
 2717   int32_t target, pc, offset;
 2753   int32_t target, pc, offset;
 2795   int32_t pc, offset, target = 0;
 2880   int32_t target = 0;
 2885   int32_t offset = insn.getOperand(1).getImm();
 2887   int32_t pc =
 2947   int32_t target = 0;
 2954   int32_t offset = insn.getOperand(1).getImm();
 2956   int32_t pc =
 2982   int32_t imm, address;
 3015   int32_t address, index_address;

  241   int32_t ids = llvm::SignExtend32<16>(ds << 2);
  284   int32_t ids = llvm::SignExtend32<16>(ds << 2);
  376   int32_t si_val = llvm::SignExtend32<16>(si);

  111     int32_t child_byte_offset = 0;

  312     int32_t child_byte_offset = 0;

  343   int32_t max_offset = INT32_MIN;
  349     int32_t cur_offset = ivar.m_offset;

  123       int32_t m_offset;

  750     {eFormatDecimal, eFormatVectorOfSInt32, sizeof(int32_t)},

   45 typedef int32_t elf_sword;

  359   int32_t GetCFAFrameOffset() const;
  375   int32_t cfa_frame_offset = GetCFAFrameOffset();
  395   int32_t rsp_frame_offset = 0;
  420 int32_t EHProgramRange::GetCFAFrameOffset() const {
  421   int32_t result = 0;

  219 int32_t
  221   int32_t resume_count = 0;

   47   int32_t GetResumeCountForLaunchInfo(ProcessLaunchInfo &launch_info) override;

 1237 int32_t

   61   int32_t GetResumeCountForLaunchInfo(

  188 int32_t
  190   int32_t resume_count = 0;

   47   int32_t GetResumeCountForLaunchInfo(ProcessLaunchInfo &launch_info) override;

 1908 lldb::addr_t RegisterContextLLDB::GetReturnAddressHint(int32_t plan_offset) {

  204   lldb::addr_t GetReturnAddressHint(int32_t plan_offset);

   62   int32_t fpvalid;        // True if FPU is being used.
   69   int32_t signal;         // Signal causing core dump.
   70   int32_t reserved;       // Unused.

   53   int32_t fpvalid; // True if FPU is being used.
   54   int32_t pad0;
   63   int32_t reserved;     // Unused.
   64   int32_t pad1;

   35   int32_t si_signo;
   36   int32_t si_code;
   37   int32_t si_errno;
   71   int32_t si_signo;
   72   int32_t si_code;
   73   int32_t si_errno;
  103   int32_t pr_pid;
  104   int32_t pr_ppid;
  105   int32_t pr_pgrp;
  106   int32_t pr_sid;

 2904   int32_t result = response.GetS32(-2);
 3971     llvm::ArrayRef<int32_t> signals) {

  442   Status SendSignalsToIgnore(llvm::ArrayRef<int32_t> signals);

 5029           int32_t index_id = AssignIndexIDToThread(thread_id);

   15                                   const int32_t byte_size,

   29                      const lldb_private::Declaration &decl, int32_t byte_size)
   52   int32_t m_byte_size;
   68             const int32_t byte_size, UniqueDWARFASTType &entry) const;
   87             const lldb_private::Declaration &decl, const int32_t byte_size,

  132     llvm::codeview::RegisterId reg, llvm::Optional<int32_t> relative_offset,
  167     llvm::codeview::RegisterId reg, int32_t offset, lldb::ModuleSP module) {
  179     llvm::StringRef fpo_program, int32_t offset, lldb::ModuleSP module) {

   31                                              int32_t offset,
   34                                                 int32_t offset,

  114           int32_t offset = symbol.getOffset();
  141     int32_t offset = symbol.getOffset();

  450         const int32_t offset = addr - m_initial_sp;

  802     int32_t rel32 = extract_4_signed (m_cur_insn + opcode_size);
  880 int32_t x86AssemblyInspectionEngine::extract_4_signed(uint8_t *b) {
  881   int32_t v = 0;

  129   int32_t extract_4_signed(uint8_t *b);

  131   int32_t vsp = 0;
  132   std::vector<std::pair<uint32_t, int32_t>>

   58 void Block::Dump(Stream *s, addr_t base_addr, int32_t depth,

  307                               int32_t &bit_offset) {
 6567     uint32_t &child_byte_size, int32_t &child_byte_offset,
 6588   int32_t bit_offset;

  841     int32_t offset = mode == UNWIND_X86_64_MODE_STACK_IND
 1106     int32_t offset =

  602     int32_t &child_byte_offset, uint32_t &child_bitfield_bit_size,

  625   int32_t data_align = cie->data_align;
  818                                                  int32_t data_align,
  833       int32_t op_offset = (int32_t)m_cfi_data.GetULEB128(&offset) * data_align;
  850       int32_t op_offset = (int32_t)m_cfi_data.GetULEB128(&offset) * data_align;
  900       int32_t op_offset = (int32_t)m_cfi_data.GetULEB128(&offset);
  921       int32_t op_offset = (int32_t)m_cfi_data.GetULEB128(&offset);
  962       int32_t op_offset = (int32_t)m_cfi_data.GetSLEB128(&offset) * data_align;
  976       int32_t op_offset = (int32_t)m_cfi_data.GetSLEB128(&offset) * data_align;
  986       int32_t op_offset = (int32_t)m_cfi_data.GetSLEB128(&offset) * data_align;

  278                                                            int32_t offset,
  290                                                            int32_t offset,

 1507                              int32_t elem_idx) {
 1520   int32_t print_idx = 0;

  143 bool UnixSignals::SignalIsValid(int32_t signo) const {
  155 int32_t UnixSignals::GetSignalNumberFromName(const char *name) const {
  167   const int32_t signo =
  174 int32_t UnixSignals::GetFirstSignalNumber() const {
  181 int32_t UnixSignals::GetNextSignalNumber(int32_t current_signal) const {
  181 int32_t UnixSignals::GetNextSignalNumber(int32_t current_signal) const {
  195 const char *UnixSignals::GetSignalInfo(int32_t signo, bool &should_suppress,
  228   const int32_t signo = GetSignalNumberFromName(signal_name);
  252   const int32_t signo = GetSignalNumberFromName(signal_name);
  276   const int32_t signo = GetSignalNumberFromName(signal_name);
  282 int32_t UnixSignals::GetNumSignals() const { return m_signals.size(); }
  284 int32_t UnixSignals::GetSignalAtIndex(int32_t index) const {
  284 int32_t UnixSignals::GetSignalAtIndex(int32_t index) const {
  294 std::vector<int32_t>
  298   std::vector<int32_t> result;
  299   for (int32_t signo = GetFirstSignalNumber();

  582     int32_t lsbcount = bitfield_bit_offset;
  600     int32_t lsbcount = bitfield_bit_offset;

  200 Stream &Stream::operator<<(int32_t sval) {

  109 int32_t StringExtractor::GetS32(int32_t fail_value, int base) {
  109 int32_t StringExtractor::GetS32(int32_t fail_value, int base) {
  114     int32_t result = static_cast<int32_t>(::strtol(cstr, &end, base));

   99     int32_t port = INT32_MIN;

   27   int32_t port;

   30 void ExpectEqArrays(llvm::ArrayRef<int32_t> expected,
   31                     llvm::ArrayRef<int32_t> observed, const char *file,
   60   int32_t signo = 4;
   77   int32_t signo = 8;
  109   std::vector<int32_t> expected = {2, 4, 8, 16};

  301   s << std::numeric_limits<int32_t>::max() << " ";

  152     int32_t VirtualBasePointerOffset;

  139       int32_t Index = SD->getNumber(IsBigObj);

  701         int32_t AuxNumber = asd->getNumber(Symbol->isBigObj());

 1700       for (j = 0; j < 4 * sizeof(int32_t) && i + j < size;
 1701            j += sizeof(int32_t)) {
 1702         if (i + j + sizeof(int32_t) <= size) {
 1704           memcpy(&long_word, sect + i + j, sizeof(int32_t));
 2901       int32_t offset = value - (r_value - pair_r_value);
 3634   int32_t version;
 3635   int32_t info;
 3636   int32_t instance_size;
 3660   int32_t ivar_offset;
 3664   int32_t ivar_count;
 3670   int32_t method_count;
 3683   int32_t count;
 3699   int32_t count;
 4392   int32_t i;
 4683   int32_t i;
 4812   int32_t i;
 5506   int32_t i;

  411     int32_t Size;

  680   int32_t LineOffset = 0;

   70   int32_t SignedNum = Number;

   72   int32_t NotMask;
   76   IntWithNotMask(RCInt Value, int32_t NotMask = 0) : Value(Value), NotMask(NotMask) {}

 1435 getSectionName(const llvm::object::COFFObjectFile *Obj, int32_t SectionNumber,
 1523       int32_t AuxNumber = Aux->getNumber(Symbol.isBigObj());

   70   int32_t TimeStamp = Obj.getTimeStamp();
   97     int32_t SymTabEntries = Obj.getRawNumberOfSymbolTableEntries32();

   20 std::string FuncIdConversionHelper::SymbolOrNumber(int32_t FuncId) const {
   53 std::string FuncIdConversionHelper::FileLineAndColumn(int32_t FuncId) const {

   25   using FunctionAddressMap = std::unordered_map<int32_t, uint64_t>;
   31   mutable llvm::DenseMap<int32_t, std::string> CachedNames;
   41   std::string SymbolOrNumber(int32_t FuncId) const;
   44   std::string FileLineAndColumn(int32_t FuncId) const;

   32   int32_t FuncId;
   63   llvm::DenseMap<int32_t, TrieNode<T> *> LeftCalleesByFuncId;

  261 using TupleType = std::tuple<int32_t, uint64_t, ResultRow>;

   30   typedef std::map<int32_t, std::vector<uint64_t>> FunctionLatencyMap;
   34   typedef std::vector<std::pair<int32_t, uint64_t>> FunctionStack;
   47   void recordLatency(int32_t FuncId, uint64_t Latency) {

  213     StackTrieNode *Parent, int32_t FuncId, uint32_t TId,
  243 void writeTraceViewerRecord(uint16_t Version, raw_ostream &OS, int32_t FuncId,

  377   StringMap<int32_t> VertexNo;

   75     int32_t FuncId;
   83   class GraphT : public Graph<FunctionStats, CallStats, int32_t> {

  333   StackTrieNode *createTrieNode(uint32_t ThreadId, int32_t FuncId,
  343   StackTrieNode *findRootNode(uint32_t ThreadId, int32_t FuncId) {

  258   int32_t AuxNumber = ObjSD->getNumber(IsBigObj);

    6 extern int isl_sioimath_decode(isl_sioimath val, int32_t *small, mp_int *big);
    8 extern int isl_sioimath_decode_small(isl_sioimath val, int32_t *small);
   10 extern isl_sioimath isl_sioimath_encode_small(int32_t val);
   14 extern int32_t isl_sioimath_get_small(isl_sioimath val);
   33 extern void isl_sioimath_set_small(isl_sioimath_ptr ptr, int32_t val);
   34 extern void isl_sioimath_set_int32(isl_sioimath_ptr ptr, int32_t val);
   84 static uint32_t isl_sioimath_smallgcd(int32_t lhs, int32_t rhs)
   84 static uint32_t isl_sioimath_smallgcd(int32_t lhs, int32_t rhs)
  106 	int32_t lhssmall, rhssmall;
  128 	int32_t lhssmall, rhssmall;
  172 	int32_t small;
  201 	int32_t small;

  117 inline int32_t isl_sioimath_get_small(isl_sioimath val)
  136 inline int isl_sioimath_decode_small(isl_sioimath val, int32_t *small)
  152 inline isl_sioimath isl_sioimath_encode_small(int32_t val)
  251 	int32_t small;
  340 inline void isl_sioimath_set_small(isl_sioimath_ptr ptr, int32_t val)
  349 inline void isl_sioimath_set_int32(isl_sioimath_ptr ptr, int32_t val)
  377 	int32_t small;
  592 	int32_t smalllhs;
  615 	int32_t smalllhs;
  635 	int32_t smalllhs, smallrhs;
  656 	int32_t smalllhs, smallrhs;
  677 	int32_t smalllhs, smallrhs;
  699 	int32_t smalllhs;
  716 	int32_t smalllhs;
  736 	int32_t smalllhs;
  758 	int32_t smalllhs;
  859 	int32_t lhssmall, rhssmall;
  880 	int32_t lhssmall;
  906 	int32_t lhssmall, rhssmall;
  908 	int32_t q;
  937 	int32_t lhssmall, q;
  961 	int32_t lhssmall, rhssmall;
  962 	int32_t q;
  991 	int32_t lhssmall, q;
 1017 	int32_t r;
 1042 	int32_t small;
 1058 	int32_t lhssmall, rhssmall;
 1080 	int32_t lhssmall;
 1096 	int32_t lhssmall, rhssmall;
 1118 	int32_t lhssmall, rhssmall;
 1147 	int32_t small;
 1178 	int32_t small;
 1181 		return sizeof(int32_t) * CHAR_BIT - 1;

  637   int32_t S32;
  823   int32_t S32;

   53   int32_t Mem1 = 3;
   57   int32_t Mem2 = 4;
   79   int32_t Mem1 = 3;
   82   int32_t Mem2 = 4;
  105   int32_t Mem1 = 3;
  122   int32_t Mem1 = 3;

  360   int32_t *usable  = (int32_t *) raw;

   58   int32_t (*FPtr)(int32_t) = (int32_t (*)(int32_t))(intptr_t)ptr;
   58   int32_t (*FPtr)(int32_t) = (int32_t (*)(int32_t))(intptr_t)ptr;
  209   int32_t initialNum = 7;
  233   int32_t(*FuncPtr)() = (int32_t(*)())FBPtr;

   98   int32_t initialNum = 7;
  111   int32_t(*FuncPtr)() = (int32_t(*)())rgvPtr;
  165   int32_t innerRetVal= 5;
  189   int32_t(*FuncPtr)() = (int32_t(*)())ptr;

  130                                     int32_t InitialValue) {

  124   class IntInt : public Function<IntInt, int32_t(int32_t)> {
  124   class IntInt : public Function<IntInt, int32_t(int32_t)> {
  136                                           int32_t, uint32_t, int64_t, uint64_t,
  374     Error handler(std::function<Error(Expected<int32_t>)> SendResult,
  375              int32_t X) {

   25   int32_t BigAsHost = 0x00010203;
   27   int32_t LittleAsHost = 0x02030400;
   75   endian::writeAtBitAlignment<int32_t, big, unaligned>(bigval, (int)0xffffaaaa,
   87   endian::writeAtBitAlignment<int32_t, little, unaligned>(littleval,
  101   endian::writeAtBitAlignment<int32_t, big, unaligned>(bigval2, (int)0xffffffff,
  113   endian::writeAtBitAlignment<int32_t, little, unaligned>(littleval2,
  168   endian::write<int32_t, big, unaligned>(data, -1362446643);
  173   endian::write<int32_t, big, unaligned>(data + 1, -1362446643);
  179   endian::write<int32_t, little, unaligned>(data, -1362446643);
  184   endian::write<int32_t, little, unaligned>(data + 1, -1362446643);

   60     int32_t original_int32 = static_cast<int32_t>(value);
  177   int32_t value = 0x44332211;

  336   int32_t         s32;
 2084   std::vector<int32_t> seq;
 2102   std::vector<int32_t> seq;

  929   typedef atomic<int32_t>		atomic_int32_t;

   36 typedef	int32_t  Elf32_Sword;
   38 typedef	int32_t  Elf64_Sword;

  127 	int32_t *(*x_inline) (XDR *__xdrs, u_int __len);
  131 	bool_t (*x_getint32) (XDR *__xdrs, int32_t *__ip);
  133 	bool_t (*x_putint32) (XDR *__xdrs, const int32_t *__ip);
  300 extern bool_t xdr_int32_t (XDR *__xdrs, int32_t *__ip) __THROW;

  425     int32_t *fptr;		/* Front pointer.  */
  426     int32_t *rptr;		/* Rear pointer.  */
  427     int32_t *state;		/* Array of state values.  */
  431     int32_t *end_ptr;		/* Pointer behind state table.  */
  435 		     int32_t *__restrict __result) __THROW __nonnull ((1, 2));

   39     int32_t ll_time;
   75   int32_t ut_session;		/* Session ID, used for windowing.  */
   78     int32_t tv_sec;		/* Seconds.  */
   79     int32_t tv_usec;		/* Microseconds.  */
   86   int32_t ut_addr_v6[4];	/* Internet address of remote host.  */

   27 bool ParseInt32(const std::string& src_text, const char* str, int32_t* value) {
   41   const int32_t result = static_cast<int32_t>(long_value);
  105 int32_t Int32FromEnv(const char* flag, int32_t default_value) {
  105 int32_t Int32FromEnv(const char* flag, int32_t default_value) {
  113   int32_t result = default_value;
  173 bool ParseInt32Flag(const char* str, const char* flag, int32_t* value) {

   29 bool ParseInt32(const std::string& src_text, const char* str, int32_t* value);
   34 int32_t Int32FromEnv(const char* flag, int32_t default_val);
   34 int32_t Int32FromEnv(const char* flag, int32_t default_val);
   54 bool ParseInt32Flag(const char* str, const char* flag, int32_t* value);