Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "continue", ";" ]

[ "if", "(", "!", "Branch", ".", "Target", "->", "isMBB", "(", ")", ")", "return", "true", ";", "if", "(", "Branch", ".", "Type", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "true", ";", "if", "(", "Branch", ".", "CCMask", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "if", "(", "!", "AllowModify", ")", "{", "TBB", "=", "Branch", ".", "Target", "->", "getMBB", "(", ")", ";", "continue", ";", "}", "while", "(", "std", "::", "next", "(", "I", ")", "!=", "MBB", ".", "end", "(", ")", ")", "std", "::", "next", "(", "I", ")", "->", "eraseFromParent", "(", ")", ";", "Cond", ".", "clear", "(", ")", ";", "FBB", "=", "nullptr", ";", "if", "(", "MBB", ".", "isLayoutSuccessor", "(", "Branch", ".", "Target", "->", "getMBB", "(", ")", ")", ")", "{", "TBB", "=", "nullptr", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "continue", ";", "}", "TBB", "=", "Branch", ".", "Target", "->", "getMBB", "(", ")", ";", "continue", ";", "}", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "FBB", "=", "TBB", ";", "TBB", "=", "Branch", ".", "Target", "->", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "Branch", ".", "CCValid", ")", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "Branch", ".", "CCMask", ")", ")", ";" ]

[ "printImmZeroOperand", "(", "MI", ",", "OpNo", "+", "<NUM_LIT>", ",", "STI", ",", "O", ")", ";" ]

[ "printS34ImmOperand", "(", "MI", ",", "OpNo", ",", "STI", ",", "O", ")", ";", "O", "<<", "'", "(", "'", ";" ]

[ "DecodeStatus", "ThumbDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "const", "MemoryObject", "&", "Region", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "os", ",", "raw_ostream", "&", "cs", ")", "const", "{", "CommentStream", "=", "&", "cs", ";", "uint8_t", "bytes", "[", "<NUM_LIT>", "]", ";", "assert", "(", "(", "STI", ".", "getFeatureBits", "(", ")", "&", "ARM", "::", "ModeThumb", ")", "&&", "<STR_LIT>", "Asked to disassemble in Thumb mode but Subtarget is in ARM mode!", "<STR_LIT>", ")", ";", "if", "(", "Region", ".", "readBytes", "(", "Address", ",", "<NUM_LIT>", ",", "bytes", ")", "==", "-", "<NUM_LIT>", ")", "{", "Size", "=", "<NUM_LIT>", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "uint16_t", "insn16", "=", "(", "bytes", "[", "<NUM_LIT>", "]", "<<", "<NUM_LIT>", ")", "|", "bytes", "[", "<NUM_LIT>", "]", ";", "DecodeStatus", "result", "=", "decodeInstruction", "(", "DecoderTableThumb16", ",", "MI", ",", "insn16", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "<NUM_LIT>", ";", "Check", "(", "result", ",", "AddThumbPredicate", "(", "MI", ")", ")", ";", "return", "result", ";", "}", "MI", ".", "clear", "(", ")", ";", "result", "=", "decodeInstruction", "(", "DecoderTableThumbSBit16", ",", "MI", ",", "insn16", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "result", ")", "{", "Size", "=", "<NUM_LIT>", ";", "bool", "InITBlock", "=", "ITBlock", ".", "instrInITBlock", "(", ")", ";", "Check", "(", "result", ",", "AddThumbPredicate", "(", "MI", ")", ")", ";", "AddThumb1SBit", "(", "MI", ",", "InITBlock", ")", ";", "return", "result", ";", "}", "MI", ".", "clear", "(", ")", ";", "result", "=", "decodeInstruction", "(", "DecoderTableThumb216", ",", "MI", ",", "insn16", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "<NUM_LIT>", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "t2IT", "&&", "ITBlock", ".", "instrInITBlock", "(", ")", ")", "result", "=", "MCDisassembler", "::", "SoftFail", ";", "Check", "(", "result", ",", "AddThumbPredicate", "(", "MI", ")", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "t2IT", ")", "{", "unsigned", "Firstcond", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "unsigned", "Mask", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "ITBlock", ".", "setITState", "(", "Firstcond", ",", "Mask", ")", ";", "}", "return", "result", ";", "}", "if", "(", "Region", ".", "readBytes", "(", "Address", ",", "<NUM_LIT>", ",", "bytes", ")", "==", "-", "<NUM_LIT>", ")", "{", "Size", "=", "<NUM_LIT>", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "uint32_t", "insn32", "=", "(", "bytes", "[", "<NUM_LIT>", "]", "<<", "<NUM_LIT>", ")", "|", "(", "bytes", "[", "<NUM_LIT>", "]", "<<", "<NUM_LIT>", ")", "|", "(", "bytes", "[", "<NUM_LIT>", "]", "<<", "<NUM_LIT>", ")", "|", "(", "bytes", "[", "<NUM_LIT>", "]", "<<", "<NUM_LIT>", ")", ";", "MI", ".", "clear", "(", ")", ";", "result", "=", "decodeInstruction", "(", "DecoderTableThumb32", ",", "MI", ",", "insn32", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "<NUM_LIT>", ";", "bool", "InITBlock", "=", "ITBlock", ".", "instrInITBlock", "(", ")", ";", "Check", "(", "result", ",", "AddThumbPredicate", "(", "MI", ")", ")", ";", "AddThumb1SBit", "(", "MI", ",", "InITBlock", ")", ";", "return", "result", ";", "}", "MI", ".", "clear", "(", ")", ";", "result", "=", "decodeInstruction", "(", "DecoderTableThumb232", ",", "MI", ",", "insn32", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "<NUM_LIT>", ";", "Check", "(", "result", ",", "AddThumbPredicate", "(", "MI", ")", ")", ";", "return", "result", ";", "}", "if", "(", "fieldFromInstruction", "(", "insn32", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "{", "MI", ".", "clear", "(", ")", ";", "result", "=", "decodeInstruction", "(", "DecoderTableVFP32", ",", "MI", ",", "insn32", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "<NUM_LIT>", ";", "UpdateThumbVFPPredicate", "(", "MI", ")", ";", "return", "result", ";", "}", "}", "if", "(", "fieldFromInstruction", "(", "insn32", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "{", "MI", ".", "clear", "(", ")", ";", "result", "=", "decodeInstruction", "(", "DecoderTableNEONDup32", ",", "MI", ",", "insn32", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "<NUM_LIT>", ";", "Check", "(", "result", ",", "AddThumbPredicate", "(", "MI", ")", ")", ";", "return", "result", ";", "}", "}", "if", "(", "fieldFromInstruction", "(", "insn32", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "{", "MI", ".", "clear", "(", ")", ";", "uint32_t", "NEONLdStInsn", "=", "insn32", ";", "NEONLdStInsn", "&=", "<NUM_LIT>", ";", "NEONLdStInsn", "|=", "<NUM_LIT>", ";", "result", "=", "decodeInstruction", "(", "DecoderTableNEONLoadStore32", ",", "MI", ",", "NEONLdStInsn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "<NUM_LIT>", ";", "Check", "(", "result", ",", "AddThumbPredicate", "(", "MI", ")", ")", ";", "return", "result", ";", "}", "}", "if", "(", "fieldFromInstruction", "(", "insn32", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "{", "MI", ".", "clear", "(", ")", ";", "uint32_t", "NEONDataInsn", "=", "insn32", ";", "NEONDataInsn", "&=", "<NUM_LIT>", ";", "NEONDataInsn", "|=", "(", "NEONDataInsn", "&", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "NEONDataInsn", "|=", "<NUM_LIT>", ";", "result", "=", "decodeInstruction", "(", "DecoderTableNEONData32", ",", "MI", ",", "NEONDataInsn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "<NUM_LIT>", ";", "Check", "(", "result", ",", "AddThumbPredicate", "(", "MI", ")", ")", ";", "return", "result", ";", "}", "}", "Size", "=", "<NUM_LIT>", ";", "return", "MCDisassembler", "::", "Fail", ";", "}" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "}" ]

[ "void", "ARMBaseInstrInfo", "::", "saveLROnStack", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "It", ")", "const", "{", "unsigned", "Opc", "=", "Subtarget", ".", "isThumb", "(", ")", "?", "ARM", "::", "t2STR_PRE", ":", "ARM", "::", "STR_PRE_IMM", ";", "int", "Align", "=", "-", "Subtarget", ".", "getStackAlignment", "(", ")", ".", "value", "(", ")", ";", "BuildMI", "(", "MBB", ",", "It", ",", "DebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ",", "ARM", "::", "SP", ")", ".", "addReg", "(", "ARM", "::", "LR", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "ARM", "::", "SP", ")", ".", "addImm", "(", "Align", ")", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";" ]

[ ";" ]

[ "return", "mips_print_operand_punct", "[", "code", "]" ]

[ "if", "(", "Subtarget", "->", "isCallingConvWin64", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ")", ")", "return", "LowerWin64_VASTART", "(", "Op", ",", "DAG", ")", ";" ]

[ "SDValue", "AArch64TargetLowering", "::", "LowerVASTART", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";" ]

[ "LegacyLegalizeActions", "::", "Legal", ")", ";" ]

[ "void", "X86LegalizerInfo", "::", "setLegalizerInfoSSE2", "(", ")", "{", "if", "(", "!", "Subtarget", ".", "hasSSE2", "(", ")", ")", "return", ";", "const", "LLT", "s32", "=", "LLT", "::", "scalar", "(", "<NUM_LIT>", ")", ";", "const", "LLT", "s64", "=", "LLT", "::", "scalar", "(", "<NUM_LIT>", ")", ";", "const", "LLT", "v16s8", "=", "LLT", "::", "fixed_vector", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "const", "LLT", "v8s16", "=", "LLT", "::", "fixed_vector", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "const", "LLT", "v4s32", "=", "LLT", "::", "fixed_vector", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "const", "LLT", "v2s64", "=", "LLT", "::", "fixed_vector", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "const", "LLT", "v32s8", "=", "LLT", "::", "fixed_vector", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "const", "LLT", "v16s16", "=", "LLT", "::", "fixed_vector", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "const", "LLT", "v8s32", "=", "LLT", "::", "fixed_vector", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "const", "LLT", "v4s64", "=", "LLT", "::", "fixed_vector", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "auto", "&", "LegacyInfo", "=", "getLegacyLegalizerInfo", "(", ")", ";", "for", "(", "unsigned", "BinOp", ":", "{", "G_FADD", ",", "G_FSUB", ",", "G_FMUL", ",", "G_FDIV", "}", ")", "for", "(", "auto", "Ty", ":", "{", "s64", ",", "v2s64", "}", ")", "LegacyInfo", ".", "setAction", "(", "{", "BinOp", ",", "Ty", "}", ",", "LegacyLegalizeActions", "::", "Legal", ")", ";", "for", "(", "unsigned", "BinOp", ":", "{", "G_ADD", ",", "G_SUB", "}", ")", "for", "(", "auto", "Ty", ":", "{", "v16s8", ",", "v8s16", ",", "v4s32", ",", "v2s64", "}", ")", "LegacyInfo", ".", "setAction", "(", "{", "BinOp", ",", "Ty", "}", ",", "LegacyLegalizeActions", "::", "Legal", ")", ";", "LegacyInfo", ".", "setAction", "(", "{", "G_MUL", ",", "v8s16", "}", ",", "LegacyLegalizeActions", "::", "Legal", ")", ";", "LegacyInfo", ".", "setAction", "(", "{", "G_FPEXT", ",", "s64", "}", ",", "LegacyLegalizeActions", "::", "Legal", ")", ";", "LegacyInfo", ".", "setAction", "(", "{", "G_FPEXT", ",", "<NUM_LIT>", ",", "s32", "}", ",", "LegacyLegalizeActions", "::", "Legal", ")", ";", "LegacyInfo", ".", "setAction", "(", "{", "G_FPTRUNC", ",", "s32", "}", ",", "LegacyLegalizeActions", "::", "Legal", ")", ";", "LegacyInfo", ".", "setAction", "(", "{", "G_FPTRUNC", ",", "<NUM_LIT>", ",", "s64", "}", "," ]

[ "}", ")" ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "operand_subword", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "TImode", ")", "operands", "[", "<NUM_LIT>", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "operands", "[", "<NUM_LIT>", "]", "=", "gen_rtx_REG", "(", "V2DImode", ",", "REGNO", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")" ]

[ "]", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "EQD", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "plus", ":", "EQD", "(", "zero_extend", ":", "EQD", "(", "match_operand", ":", "EQS0", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "zero_extend", ":", "EQD", "(", "match_operand", ":", "EQS1", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "operands", "[", "<NUM_LIT>", "]", "," ]

[ "(", "match_operand", ":", "V2SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<STR_LIT>", "{", "if", "(", "BYTES_BIG_ENDIAN", ")", "emit_insn", "(", "gen_vec_interleave_highv2si_be", "(", "operands", "[", "<NUM_LIT>", "]", "," ]

[ "if", "(", "!", "BaseT", "::", "getConstantStrideStep", "(", "SE", ",", "Ptr", ")", ")", "return", "<NUM_LIT>", ";" ]

[ "int", "X86TTIImpl", "::", "getAddressComputationCost", "(", "Type", "*", "Ty", ",", "ScalarEvolution", "*", "SE", ",", "const", "SCEV", "*", "Ptr", ")", "{", "unsigned", "NumVectorInstToHideOverhead", "=", "<NUM_LIT>", ";", "if", "(", "Ty", "->", "isVectorTy", "(", ")", "&&", "SE", ")", "{", "if", "(", "!", "BaseT", "::", "isStridedAccess", "(", "Ptr", ")", ")", "return", "NumVectorInstToHideOverhead", ";" ]

[ "(", "SI", "<STR_LIT>", ")", "(", "DI", "<STR_LIT>", ")", "]", ")" ]

[ "(", "define_mode_attr", "stype", "[", "(", "V8QI", "<STR_LIT>", ")", "(", "V16QI", "<STR_LIT>", ")", "(", "V4HI", "<STR_LIT>", ")", "(", "V8HI", "<STR_LIT>", ")", "(", "V2SI", "<STR_LIT>", ")", "(", "V4SI", "<STR_LIT>", ")", "(", "V2DI", "<STR_LIT>", ")", "(", "V4HF", "<STR_LIT>", ")", "(", "V8HF", "<STR_LIT>", ")", "(", "V2SF", "<STR_LIT>", ")", "(", "V4SF", "<STR_LIT>", ")", "(", "V2DF", "<STR_LIT>", ")", "(", "HF", "<STR_LIT>", ")", "(", "SF", "<STR_LIT>", ")", "(", "DF", "<STR_LIT>", ")", "(", "QI", "<STR_LIT>", ")", "(", "HI", "<STR_LIT>", ")" ]

[ "<FIXS>", "emit_insn", "(", "gen_rtx_SET", "(", "high", "[", "<NUM_LIT>", "]", ",", "x", ")", ")", ";", "<FIXE>" ]

[ "x", "=", "gen_rtx_ZERO_EXTEND", "(", "half_mode", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "elsex", "=", "gen_lowpart", "(", "half_mode", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "<BUGS>", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "high", "[", "<NUM_LIT>", "]", ",", "x", ")", ")", ";", "<BUGE>", "emit_insn", "(", "gen_lshr3", "(", "high", "[", "<NUM_LIT>", "]", ",", "high", "[", "<NUM_LIT>", "]", ",", "GEN_INT", "(", "bits", ")", ")", ")", ";", "emit_insn", "(", "gen_and3", "(", "high", "[", "<NUM_LIT>", "]", ",", "high", "[", "<NUM_LIT>", "]", ",", "const1_rtx", ")", ")", ";" ]

[ "S32", ",", "Mad2", ")", ";" ]

[ "auto", "Mad", "=", "B", ".", "buildFMAD", "(", "S32", ",", "CvtHi", ",", "B", ".", "buildFConstant", "(", "S32", ",", "llvm", "::", "bit_cast", "<", "float", ">", "(", "<NUM_LIT>", ")", ")", ",", "CvtLo", ")", ";", "auto", "Rcp", "=", "B", ".", "buildInstr", "(", "AMDGPU", "::", "G_AMDGPU_RCP_IFLAG", ",", "{", "S32", "}", ",", "{", "Mad", "}", ")", ";", "auto", "Mul1", "=", "B", ".", "buildFMul", "(", "S32", ",", "Rcp", ",", "B", ".", "buildFConstant", "(", "S32", ",", "llvm", "::", "bit_cast", "<", "float", ">", "(", "<NUM_LIT>", ")", ")", ")", ";", "auto", "Mul2", "=", "B", ".", "buildFMul", "(", "S32", ",", "Mul1", ",", "B", ".", "buildFConstant", "(", "S32", ",", "llvm", "::", "bit_cast", "<", "float", ">", "(", "<NUM_LIT>", ")", ")", ")", ";", "auto", "Trunc", "=", "B", ".", "buildIntrinsicTrunc", "(", "S32", ",", "Mul2", ")", ";", "auto", "Mad2", "=", "B", ".", "buildFMAD", "(", "S32", ",", "Trunc", ",", "B", ".", "buildFConstant", "(", "S32", ",", "llvm", "::", "bit_cast", "<", "float", ">", "(", "<NUM_LIT>", ")", ")", ",", "Mul1", ")", ";", "auto", "ResultLo", "=", "B", ".", "buildFPTOUI", "(" ]

[ "AddrSpaceCast", ":" ]

[ "switch", "(", "Inst", "->", "getOpcode", "(", ")", ")", "{", "case", "Instruction", "::", "Load", ":", "{", "Type", "*", "VecPtrTy", "=", "VectorTy", "->", "getPointerTo", "(", "AS", ".", "PRIVATE_ADDRESS", ")", ";", "Value", "*", "Ptr", "=", "Inst", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "Value", "*", "Index", "=", "calculateVectorIndex", "(", "Ptr", ",", "GEPVectorIdx", ")", ";", "Value", "*", "BitCast", "=", "Builder", ".", "CreateBitCast", "(", "Alloca", ",", "VecPtrTy", ")", ";", "Value", "*", "VecValue", "=", "Builder", ".", "CreateLoad", "(", "BitCast", ")", ";", "Value", "*", "ExtractElement", "=", "Builder", ".", "CreateExtractElement", "(", "VecValue", ",", "Index", ")", ";", "Inst", "->", "replaceAllUsesWith", "(", "ExtractElement", ")", ";", "Inst", "->", "eraseFromParent", "(", ")", ";", "break", ";", "}", "case", "Instruction", "::", "Store", ":", "{", "Type", "*", "VecPtrTy", "=", "VectorTy", "->", "getPointerTo", "(", "AS", ".", "PRIVATE_ADDRESS", ")", ";", "Value", "*", "Ptr", "=", "Inst", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "Value", "*", "Index", "=", "calculateVectorIndex", "(", "Ptr", ",", "GEPVectorIdx", ")", ";", "Value", "*", "BitCast", "=", "Builder", ".", "CreateBitCast", "(", "Alloca", ",", "VecPtrTy", ")", ";", "Value", "*", "VecValue", "=", "Builder", ".", "CreateLoad", "(", "BitCast", ")", ";", "Value", "*", "NewVecValue", "=", "Builder", ".", "CreateInsertElement", "(", "VecValue", ",", "Inst", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Index", ")", ";", "Builder", ".", "CreateStore", "(", "NewVecValue", ",", "BitCast", ")", ";", "Inst", "->", "eraseFromParent", "(", ")", ";", "break", ";", "}", "case", "Instruction", "::", "BitCast", ":", "case", "Instruction", "::" ]

[ ")", ")" ]

[ "(", "define_predicate", "<STR_LIT>", "(", "match_code", "<STR_LIT>" ]

[ "<STR_LIT>", "<STR_LIT>", ")" ]

[ "(", "and", "(", "eq_attr" ]

[ "<FIXS>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "<FIXE>", "<FIXS>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "<FIXE>" ]

[ "<STR_LIT>", ")", "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "<BUGS>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "<STR_LIT>", ")", "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "<BUGS>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")" ]

[ "<STR_LIT>", "__udivhi3", "<STR_LIT>", ")", ";" ]

[ "static", "void", "h8300_init_libfuncs", "(", "void", ")", "{", "set_optab_libfunc", "(", "smul_optab", ",", "HImode", ",", "<STR_LIT>", "__mulhi3", "<STR_LIT>", ")", ";", "set_optab_libfunc", "(", "sdiv_optab", ",", "HImode", ",", "<STR_LIT>", "__divhi3", "<STR_LIT>", ")", ";", "set_optab_libfunc", "(", "udiv_optab", ",", "HImode", "," ]

[ "::", "<STR_LIT>", ")", "!=", "<NUM_LIT>", ";" ]

[ "return", "(", "STI", ".", "getFeatureBits", "(", ")", "&", "<STR_LIT>" ]

[ "}" ]

[ "case", "MVT", "::", "f32", ":", "Opc", "=", "UseUnscaled", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "RC", "=", "TLI", ".", "getRegClassFor", "(", "VT", ")", ";", "ScaleFactor", "=", "<NUM_LIT>", ";", "break", ";", "case", "MVT", "::", "f64", ":", "Opc", "=", "UseUnscaled", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "RC", "=", "TLI", ".", "getRegClassFor", "(", "VT", ")", ";", "ScaleFactor", "=", "<NUM_LIT>", ";", "break", ";", "}", "if", "(", "!", "UseUnscaled", ")", "{", "int64_t", "Offset", "=", "Addr", ".", "getOffset", "(", ")", ";", "if", "(", "Offset", "&", "(", "ScaleFactor", "-", "<NUM_LIT>", ")", ")", "return", "EmitLoad", "(", "VT", ",", "ResultReg", ",", "Addr", ",", "true", ")", ";", "Addr", ".", "setOffset", "(", "Offset", "/", "ScaleFactor", ")", ";", "}", "if", "(", "!", "SimplifyAddress", "(", "Addr", ",", "VT", ",", "UseUnscaled", "?", "<NUM_LIT>", ":", "ScaleFactor", ",", "UseUnscaled", ")", ")", "return", "false", ";", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "ResultReg", ")", ";", "AddLoadStoreOperands", "(", "Addr", ",", "MIB", ",", "MachineMemOperand", "::", "MOLoad", ",", "UseUnscaled", ")", ";", "if", "(", "VTIsi1", ")", "{", "unsigned", "ANDReg", "=", "createResultReg", "(", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "ANDReg", ")", ".", "addReg", "(", "ResultReg", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ";", "ResultReg", "=", "ANDReg", ";", "}", "return", "true", ";" ]

[ ")" ]

[ "(", "define_memory_constraint", "<STR_LIT>", "<STR_LIT>", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")" ]

[ "void", "RegisterAggr", "::", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "OS", "<<", "'", "{", "'", ";", "for", "(", "auto", "I", ":", "Masks", ")", "OS", "<<", "'", "'", "<<", "PrintReg", "(", "I", ".", "first", ",", "&", "PRI", ".", "getTRI", "(", ")", ")", "<<", "PrintLaneMaskOpt", "(", "I", ".", "second", ")", ";", "OS", "<<", "<STR_LIT>", " }", "<STR_LIT>", ";", "}" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "void", "sh_expand_epilogue", "(", "bool", "sibcall_p", ")", "{", "int", "save_flags", "=", "target_flags", ";", "bool", "fpscr_deferred", "=", "false", ";", "int", "e", "=", "sibcall_p", "?", "-", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "HARD_REG_SET", "live_regs_mask", ";", "int", "d", "=", "calc_live_regs", "(", "&", "live_regs_mask", ")", ";", "int", "save_size", "=", "d", ";", "int", "frame_size", "=", "rounded_frame_size", "(", "d", ")", ";", "if", "(", "frame_pointer_needed", ")", "{", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "output_stack_adjust", "(", "frame_size", ",", "hard_frame_pointer_rtx", ",", "e", ",", "&", "live_regs_mask", ",", "true", ")", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "emit_frame_insn", "(", "GEN_MOV", "(", "stack_pointer_rtx", ",", "hard_frame_pointer_rtx", ")", ")", ";", "}", "else", "if", "(", "frame_size", ")", "{", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "output_stack_adjust", "(", "frame_size", ",", "stack_pointer_rtx", ",", "e", ",", "&", "live_regs_mask", ",", "true", ")", ";", "}", "if", "(", "target_flags", "!=", "save_flags", "&&", "!", "current_function_interrupt", ")", "emit_insn", "(", "gen_toggle_sz", "(", ")", ")", ";", "{", "int", "last_reg", ";", "save_size", "=", "<NUM_LIT>", ";", "if", "(", "TEST_HARD_REG_BIT", "(", "live_regs_mask", ",", "PR_REG", ")", "&&", "!", "sh_cfun_resbank_handler_p", "(", ")", ")", "{", "if", "(", "!", "frame_pointer_needed", ")", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "pop", "(", "PR_REG", ")", ";", "}", "if", "(", "current_function_interrupt", ")", "{", "bool", "use_movml", "=", "false", ";", "if", "(", "TARGET_SH2A", ")", "{", "unsigned", "int", "count", "=", "<NUM_LIT>", ";", "for", "(", "int", "i", "=", "FIRST_BANKED_REG", ";", "i", "<=", "LAST_BANKED_REG", ";", "i", "++", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "live_regs_mask", ",", "i", ")", ")", "count", "++", ";", "else", "break", ";", "if", "(", "count", "==", "LAST_BANKED_REG", "-", "FIRST_BANKED_REG", "+", "<NUM_LIT>", ")", "use_movml", "=", "true", ";", "}", "if", "(", "sh_cfun_resbank_handler_p", "(", ")", ")", ";", "else", "if", "(", "use_movml", ")", "{", "rtx", "sp_reg", "=", "gen_rtx_REG", "(", "SImode", ",", "STACK_POINTER_REGNUM", ")", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "emit_insn", "(", "gen_movml_pop_banked", "(", "sp_reg", ")", ")", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "else", "for", "(", "int", "i", "=", "LAST_BANKED_REG", ";", "i", ">=", "FIRST_BANKED_REG", ";", "i", "--", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "live_regs_mask", ",", "i", ")", ")", "pop", "(", "i", ")", ";", "last_reg", "=", "FIRST_PSEUDO_REGISTER", "-", "LAST_BANKED_REG", "-", "<NUM_LIT>", ";", "}", "else", "last_reg", "=", "FIRST_PSEUDO_REGISTER", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "last_reg", ";", "i", "++", ")", "{", "int", "j", "=", "(", "FIRST_PSEUDO_REGISTER", "-", "<NUM_LIT>", ")", "-", "i", ";", "if", "(", "j", "==", "FPSCR_REG", "&&", "current_function_interrupt", "&&", "TARGET_FMOVD", "&&", "hard_reg_set_intersect_p", "(", "live_regs_mask", ",", "reg_class_contents", "[", "DF_REGS", "]", ")", ")", "fpscr_deferred", "=", "true", ";", "else", "if", "(", "j", "!=", "PR_REG", "&&", "TEST_HARD_REG_BIT", "(", "live_regs_mask", ",", "j", ")", "&&", "!", "(", "sh_cfun_resbank_handler_p", "(", ")", "&&", "(", "(", "j", ">=", "FIRST_GENERAL_REG", "&&", "j", "<", "LAST_GENERAL_REG", ")", "||", "j", "==", "MACH_REG", "||", "j", "==", "MACL_REG", "||", "j", "==", "GBR_REG", ")", ")", ")", "pop", "(", "j", ")", ";", "if", "(", "j", "==", "FIRST_FP_REG", "&&", "fpscr_deferred", ")", "pop", "(", "FPSCR_REG", ")", ";", "}", "}", "if", "(", "target_flags", "!=", "save_flags", "&&", "!", "current_function_interrupt", ")", "emit_insn", "(", "gen_toggle_sz", "(", ")", ")", ";", "target_flags", "=", "save_flags", ";", "output_stack_adjust", "(", "crtl", "->", "args", ".", "pretend_args_size", "+", "save_size", ",", "stack_pointer_rtx", ",", "e", ",", "NULL", ",", "true", ")", ";", "if", "(", "crtl", "->", "calls_eh_return", ")", "emit_insn", "(", "GEN_ADD3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "EH_RETURN_STACKADJ_RTX", ")", ")", ";", "if", "(", "lookup_attribute", "(", "<STR_LIT>", "sp_switch", "<STR_LIT>", ",", "DECL_ATTRIBUTES", "(", "current_function_decl", ")", ")", ")", "emit_insn", "(", "gen_sp_switch_2", "(", ")", ")", ";", "if", "(", "TEST_HARD_REG_BIT", "(", "live_regs_mask", ",", "PR_REG", ")", ")", "emit_use", "(", "gen_rtx_REG", "(", "SImode", ",", "PR_REG", ")", ")", ";", "}" ]

[ "Expand", "code", "for", "the", "function", "epilogue", "." ]

[ "}" ]

[ "int", "elt", "=", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "switch", "(", "which_alternative", ")", "{", "case", "<NUM_LIT>", ":", "case", "<NUM_LIT>", ":", "operands", "[", "<NUM_LIT>", "]", "=", "adjust_address_nv", "(", "operands", "[", "<NUM_LIT>", "]", ",", "SFmode", ",", "elt", "*", "<NUM_LIT>", ")", "return", "<STR_LIT>", "case", "<NUM_LIT>", ":", "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "elt", "*", "<NUM_LIT>", ")", "return", "<STR_LIT>", "default", ":", "gcc_unreachable", "(", ")", "}" ]

[ "if", "(", "std", "::", "count", "(", "std", "::", "begin", "(", "Match", ")", ",", "std", "::", "end", "(", "Match", ")", ",", "Match_MissingFeature", ")", "==", "<NUM_LIT>", ")", "{" ]

[ "if", "(", "NumSuccessfulMatches", ">", "<NUM_LIT>", ")", "{", "char", "MatchChars", "[", "<NUM_LIT>", "]", ";", "unsigned", "NumMatches", "=", "<NUM_LIT>", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "array_lengthof", "(", "Match", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "Match", "[", "I", "]", "==", "Match_Success", ")", "MatchChars", "[", "NumMatches", "++", "]", "=", "Suffixes", "[", "I", "]", ";", "SmallString", "<", "<NUM_LIT>", ">", "Msg", ";", "raw_svector_ostream", "OS", "(", "Msg", ")", ";", "OS", "<<", "<STR_LIT>", "ambiguous instructions require an explicit suffix (could be ", "<STR_LIT>", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumMatches", ";", "++", "i", ")", "{", "if", "(", "i", "!=", "<NUM_LIT>", ")", "OS", "<<", "<STR_LIT>", ", ", "<STR_LIT>", ";", "if", "(", "i", "+", "<NUM_LIT>", "==", "NumMatches", ")", "OS", "<<", "<STR_LIT>", "or ", "<STR_LIT>", ";", "OS", "<<", "<STR_LIT>", "'", "<STR_LIT>", "<<", "Base", "<<", "MatchChars", "[", "i", "]", "<<", "<STR_LIT>", "'", "<STR_LIT>", ";", "}", "OS", "<<", "<STR_LIT>", ")", "<STR_LIT>", ";", "Error", "(", "IDLoc", ",", "OS", ".", "str", "(", ")", ",", "EmptyRange", ",", "MatchingInlineAsm", ")", ";", "return", "true", ";", "}", "if", "(", "std", "::", "count", "(", "std", "::", "begin", "(", "Match", ")", ",", "std", "::", "end", "(", "Match", ")", ",", "Match_MnemonicFail", ")", "==", "<NUM_LIT>", ")", "{", "if", "(", "OriginalError", "==", "Match_MnemonicFail", ")", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "invalid instruction mnemonic '", "<STR_LIT>", "+", "Base", "+", "<STR_LIT>", "'", "<STR_LIT>", ",", "Op", ".", "getLocRange", "(", ")", ",", "MatchingInlineAsm", ")", ";", "if", "(", "OriginalError", "==", "Match_Unsupported", ")", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "unsupported instruction", "<STR_LIT>", ",", "EmptyRange", ",", "MatchingInlineAsm", ")", ";", "assert", "(", "OriginalError", "==", "Match_InvalidOperand", "&&", "<STR_LIT>", "Unexpected error", "<STR_LIT>", ")", ";", "if", "(", "ErrorInfo", "!=", "~", "<NUM_LIT>", "ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "too few operands for instruction", "<STR_LIT>", ",", "EmptyRange", ",", "MatchingInlineAsm", ")", ";", "X86Operand", "&", "Operand", "=", "(", "X86Operand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ";", "if", "(", "Operand", ".", "getStartLoc", "(", ")", ".", "isValid", "(", ")", ")", "{", "SMRange", "OperandRange", "=", "Operand", ".", "getLocRange", "(", ")", ";", "return", "Error", "(", "Operand", ".", "getStartLoc", "(", ")", ",", "<STR_LIT>", "invalid operand for instruction", "<STR_LIT>", ",", "OperandRange", ",", "MatchingInlineAsm", ")", ";", "}", "}", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "invalid operand for instruction", "<STR_LIT>", ",", "EmptyRange", ",", "MatchingInlineAsm", ")", ";", "}", "if", "(", "std", "::", "count", "(", "std", "::", "begin", "(", "Match", ")", ",", "std", "::", "end", "(", "Match", ")", ",", "Match_Unsupported", ")", "==", "<NUM_LIT>", ")", "{", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "unsupported instruction", "<STR_LIT>", ",", "EmptyRange", ",", "MatchingInlineAsm", ")", ";", "}" ]

[ "(", "pc", ")", ")", ")" ]

[ "[", "(", "reg", ":", "CC_FLOAT", "CC_REG", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", "(", "label_ref", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ "<FIXS>", "defm", "V_CMP_LT_I16_t16", ":", "VOPC_Real_t16_gfx11", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";", "defm", "V_CMP_EQ_I16_t16", ":", "VOPC_Real_t16_gfx11", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";", "defm", "V_CMP_LE_I16_t16", ":", "VOPC_Real_t16_gfx11", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";", "defm", "V_CMP_GT_I16_t16", ":", "VOPC_Real_t16_gfx11", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";", "defm", "V_CMP_NE_I16_t16", ":", "VOPC_Real_t16_gfx11", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";", "defm", "V_CMP_GE_I16_t16", ":", "VOPC_Real_t16_gfx11", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";", "defm", "V_CMP_LT_U16_t16", ":", "VOPC_Real_t16_gfx11", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";", "defm", "V_CMP_EQ_U16_t16", ":", "VOPC_Real_t16_gfx11", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";", "defm", "V_CMP_LE_U16_t16", ":", "VOPC_Real_t16_gfx11", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";", "defm", "V_CMP_GT_U16_t16", ":", "VOPC_Real_t16_gfx11", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";", "defm", "V_CMP_NE_U16_t16", ":", "VOPC_Real_t16_gfx11", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";", "defm", "V_CMP_GE_U16_t16", ":", "VOPC_Real_t16_gfx11", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";", "<FIXE>" ]

[ "defm", "V_CMP_NLT_F32", ":", "VOPC_Real_gfx11", "<NUM_LIT>", ">", ";", "defm", "V_CMP_T_F32", ":", "VOPC_Real_with_name_gfx11", "<NUM_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ">", ";", "defm", "V_CMP_T_F64", ":", "VOPC_Real_with_name_gfx11", "<NUM_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ">", ";", "<BUGS>", "defm", "V_CMP_LT_I16", ":", "VOPC_Real_gfx11", "<NUM_LIT>", ">", ";", "defm", "V_CMP_EQ_I16", ":", "VOPC_Real_gfx11", "<NUM_LIT>", ">", ";", "defm", "V_CMP_LE_I16", ":", "VOPC_Real_gfx11", "<NUM_LIT>", ">", ";", "defm", "V_CMP_GT_I16", ":", "VOPC_Real_gfx11", "<NUM_LIT>", ">", ";", "defm", "V_CMP_NE_I16", ":", "VOPC_Real_gfx11", "<NUM_LIT>", ">", ";", "defm", "V_CMP_GE_I16", ":", "VOPC_Real_gfx11", "<NUM_LIT>", ">", ";", "defm", "V_CMP_LT_U16", ":", "VOPC_Real_gfx11", "<NUM_LIT>", ">", ";", "defm", "V_CMP_EQ_U16", ":", "VOPC_Real_gfx11", "<NUM_LIT>", ">", ";", "defm", "V_CMP_LE_U16", ":", "VOPC_Real_gfx11", "<NUM_LIT>", ">", ";", "defm", "V_CMP_GT_U16", ":", "VOPC_Real_gfx11", "<NUM_LIT>", ">", ";", "defm", "V_CMP_NE_U16", ":", "VOPC_Real_gfx11", "<NUM_LIT>", ">", ";", "defm", "V_CMP_GE_U16", ":", "VOPC_Real_gfx11", "<NUM_LIT>", ">", ";", "<BUGE>", "defm", "V_CMP_F_I32", ":", "VOPC_Real_gfx11", "<NUM_LIT>", ">", ";", "defm", "V_CMP_LT_I32", ":", "VOPC_Real_gfx11", "<NUM_LIT>", ">", ";", "defm", "V_CMP_EQ_I32", ":", "VOPC_Real_gfx11", "<NUM_LIT>", ">", ";" ]

[ ")", ";" ]

[ "Waitcnt", "=", "packBits", "(", "Vmcnt", ",", "Waitcnt", ",", "getVmcntBitShiftLo", "(", ")", ",", "getVmcntBitWidthLo", "(", ")", ")", ";", "if", "(", "Version", ".", "Major", "<", "<NUM_LIT>", ")", "return", "Waitcnt", ";", "Vmcnt", ">>=", "getVmcntBitWidthLo", "(" ]

[ "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")" ]

[ "(", "and", "(", "match_code", "<STR_LIT>", ")", "(", "ior", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")" ]

[ "else", "{" ]

[ "int", "predIndex", "=", "MI", "->", "findFirstPredOperandIdx", "(", ")", ";", "if", "(", "predIndex", "!=", "-", "<NUM_LIT>", ")", "{", "MachineOperand", "&", "predImmOperand", "=", "MI", "->", "getOperand", "(", "predIndex", ")", ";", "MachineOperand", "&", "predRegOperand", "=", "MI", "->", "getOperand", "(", "predIndex", "+", "<NUM_LIT>", ")", ";", "predImmOperand", ".", "setImm", "(", "pred", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ")", ";", "predRegOperand", ".", "setReg", "(", "pred", "[", "<NUM_LIT>", "]", ".", "getReg", "(", ")", ")", ";", "}" ]

[ "(", "IfBB", ")", ";" ]

[ "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "MergeBB", ",", "MergeBB", "->", "instr_begin", "(", ")", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "PHI", ")", ",", "DestRegister", ")", ";", "if", "(", "IsUndefIfSource", "&&", "false", ")", "{", "MIB", ".", "addReg", "(", "IfSourceRegister", ",", "RegState", "::", "Undef", ")", ";", "}", "else", "{", "MIB", ".", "addReg", "(", "IfSourceRegister", ")", ";", "}", "MIB", ".", "addMBB" ]

[ "bool", "X86TargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ")", "const", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "LegalFPImmediates", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "Imm", ".", "bitwiseIsEqual", "(", "LegalFPImmediates", "[", "i", "]", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "Returns", "true", "if", "the", "target", "can", "instruction", "select", "the", "specified", "FP", "immediate", "natively", "." ]

[ ")", "]" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "match_operand", ":", "GPI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "GPI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "label_ref", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ ")", ")", ")", "break", ";" ]

[ "if", "(", "isCondBranch", "(", "MI", ")", "||", "isUncondBranch", "(", "MI", ")", ")", "return", "MI", ";", "else", "if", "(", "!", "TII", "->", "isMov", "(", "MI", "->", "getOpcode", "(" ]

[ ">", ",", "GIComplexPatternEquiv", "<", "am_indexed32", ">", ";" ]

[ "def", "gi_am_indexed32", ":", "GIComplexOperandMatcher", "<", "s64", ",", "<STR_LIT>" ]

[ "void", "SIInstrInfo", "::", "legalizeOpWithMove", "(", "MachineInstr", "&", "MI", ",", "unsigned", "OpIdx", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MI", ";", "MachineBasicBlock", "*", "MBB", "=", "MI", ".", "getParent", "(", ")", ";", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpIdx", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MBB", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "static_cast", "<", "const", "SIRegisterInfo", "*", ">", "(", "MRI", ".", "getTargetRegisterInfo", "(", ")", ")", ";", "unsigned", "RCID", "=", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ".", "OpInfo", "[", "OpIdx", "]", ".", "RegClass", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getRegClass", "(", "RCID", ")", ";", "unsigned", "Size", "=", "TRI", "->", "getRegSizeInBits", "(", "*", "RC", ")", ";", "unsigned", "Opcode", "=", "(", "Size", "==", "<NUM_LIT>", ")", "?", "AMDGPU", "::", "V_MOV_B64_PSEUDO", ":", "AMDGPU", "::", "V_MOV_B32_e32", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "Opcode", "=", "AMDGPU", "::", "COPY", ";", "else", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "Opcode", "=", "(", "Size", "==", "<NUM_LIT>", ")", "?", "AMDGPU", "::", "S_MOV_B64", ":", "AMDGPU", "::", "S_MOV_B32", ";", "const", "TargetRegisterClass", "*", "VRC", "=", "RI", ".", "getEquivalentVGPRClass", "(", "RC", ")", ";", "if", "(", "RI", ".", "getCommonSubClass", "(", "&", "AMDGPU", "::", "VReg_64RegClass", ",", "VRC", ")", ")", "VRC", "=", "&", "AMDGPU", "::", "VReg_64RegClass", ";", "else", "VRC", "=", "&", "AMDGPU", "::", "VGPR_32RegClass", ";", "Register", "Reg", "=", "MRI", ".", "createVirtualRegister", "(", "VRC", ")", ";", "DebugLoc", "DL", "=", "MBB", "->", "findDebugLoc", "(", "I", ")", ";", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "Reg", ")", ".", "add", "(", "MO", ")", ";", "MO", ".", "ChangeToRegister", "(", "Reg", ",", "false", ")", ";", "}" ]

[ "Legalize", "the", "OpIndex", "operand", "of", "this", "instruction", "by", "inserting", "a", "MOV", "." ]

[ "(", "void", ")", "adjustFixupValue", "(", "Fixup", ",", "Value", ",", "&", "Asm", ".", "getContext", "(", ")", ")", ";" ]

[ "void", "CJGAsmBackend", "::", "processFixupValue", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCAsmLayout", "&", "Layout", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCFragment", "*", "DF", ",", "const", "MCValue", "&", "Target", ",", "uint64_t", "&", "Value", ",", "bool", "&", "IsResolved", ")", "{", "IsResolved", "=", "true", ";" ]

[ "return", "Res", ">>", "<NUM_LIT>", ";" ]

[ "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "assert", "(", "MO", ".", "isImm", "(", ")", "&&", "<STR_LIT>", "getSimm23Lsl2Encoding expects only an immediate", "<STR_LIT>", ")", ";", "unsigned", "Res", "=", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "assert", "(", "(", "Res", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", ";" ]

[ "}" ]

[ "case", "CONST_DOUBLE", ":", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "case", "MULT", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", "+", "<NUM_LIT>", ")", ";", "return", "true", ";", "case", "DIV", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", "-", "<NUM_LIT>", ")", ";", "return", "true", ";", "default", ":", "return", "false", ";", "}" ]

[ "let", "isExtendable", "=", "<NUM_LIT>", ";" ]

[ "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P0", "]", ";", "let", "Defs", "=", "[", "P0", ",", "PC", "]", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";" ]

[ "break", ";" ]

[ "auto", "&", "HMFI", "=", "*", "MF", ".", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", ";", "const", "HexagonRegisterInfo", "&", "HRI", "=", "*", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "LR", "=", "HRI", ".", "getRARegister", "(", ")", ";", "if", "(", "Op", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "INLINEASM", "||", "HMFI", ".", "hasClobberLR", "(", ")", ")", "return", "Op", ";", "unsigned", "NumOps", "=", "Op", ".", "getNumOperands", "(", ")", ";", "if", "(", "Op", ".", "getOperand", "(", "NumOps", "-", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "Glue", ")", "--", "NumOps", ";", "for", "(", "unsigned", "i", "=", "InlineAsm", "::", "Op_FirstOperand", ";", "i", "!=", "NumOps", ";", ")", "{", "unsigned", "Flags", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "i", ")", ")", "->", "getZExtValue", "(", ")", ";", "unsigned", "NumVals", "=", "InlineAsm", "::", "getNumOperandRegisters", "(", "Flags", ")", ";", "++", "i", ";", "switch", "(", "InlineAsm", "::", "getKind", "(", "Flags", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Bad flags!", "<STR_LIT>", ")", ";", "case", "InlineAsm", "::", "Kind_RegUse", ":", "case", "InlineAsm", "::", "Kind_Imm", ":", "case", "InlineAsm", "::", "Kind_Mem", ":", "i", "+=", "NumVals", ";" ]

[ "(", "a", ",", "b", ")", ";" ]

[ "static", "inline", "_", "_", "ev64_opaque__", "_", "_", "internal_ev_mwhsmfanw", "(", "_", "_", "ev64_opaque__", "a", ",", "_", "_", "ev64_opaque__", "b", ")", "{", "_", "_", "ev64_opaque__", "t", ";", "t", "=", "_", "_", "ev_mwhsmf" ]

[ "<FIXS>", "TREE_TYPE", "(", "type", ")", ",", "subclasses", ",", "bit_offset", ",", "zero_width_bitfields", ")", ";", "<FIXE>" ]

[ "{", "int", "num", ";", "num", "=", "classify_argument", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "type", ")", ")", ",", "<BUGS>", "TREE_TYPE", "(", "type", ")", ",", "subclasses", ",", "bit_offset", ")", ";", "<BUGE>", "if", "(", "!", "num", ")", "return", "<NUM_LIT>", ";" ]

[ "R_SR", ")", ")" ]

[ "(", "call", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "SI" ]

[ ")", ";" ]

[ "FunctionPass", "*", "llvm", "::", "createAlphaJITCodeEmitterPass", "(", "AlphaTargetMachine", "&", "TM", ",", "JITCodeEmitter", "&", "JCE", ")", "{", "return", "new", "AlphaCodeEmitter", "(", "JCE" ]

[ "static", "void", "ix86_expand_vector_init_concat", "(", "machine_mode", "mode", ",", "rtx", "target", ",", "rtx", "*", "ops", ",", "int", "n", ")", "{", "machine_mode", "half_mode", "=", "VOIDmode", ";", "rtx", "half", "[", "<NUM_LIT>", "]", ";", "rtvec", "v", ";", "int", "i", ",", "j", ";", "switch", "(", "n", ")", "{", "case", "<NUM_LIT>", ":", "switch", "(", "mode", ")", "{", "case", "E_V32HFmode", ":", "half_mode", "=", "V16HFmode", ";", "break", ";", "case", "E_V16SImode", ":", "half_mode", "=", "V8SImode", ";", "break", ";", "case", "E_V16SFmode", ":", "half_mode", "=", "V8SFmode", ";", "break", ";", "case", "E_V8DImode", ":", "half_mode", "=", "V4DImode", ";", "break", ";", "case", "E_V8DFmode", ":", "half_mode", "=", "V4DFmode", ";", "break", ";", "case", "E_V16HFmode", ":", "half_mode", "=", "V8HFmode", ";", "break", ";", "case", "E_V8SImode", ":", "half_mode", "=", "V4SImode", ";", "break", ";", "case", "E_V8SFmode", ":", "half_mode", "=", "V4SFmode", ";", "break", ";", "case", "E_V4DImode", ":", "half_mode", "=", "V2DImode", ";", "break", ";", "case", "E_V4DFmode", ":", "half_mode", "=", "V2DFmode", ";", "break", ";", "case", "E_V4SImode", ":", "half_mode", "=", "V2SImode", ";", "break", ";", "case", "E_V4SFmode", ":", "half_mode", "=", "V2SFmode", ";", "break", ";", "case", "E_V2DImode", ":", "half_mode", "=", "DImode", ";", "break", ";", "case", "E_V2SImode", ":", "half_mode", "=", "SImode", ";", "break", ";", "case", "E_V2DFmode", ":", "half_mode", "=", "DFmode", ";", "break", ";", "case", "E_V2SFmode", ":", "half_mode", "=", "SFmode", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "!", "register_operand", "(", "ops", "[", "<NUM_LIT>", "]", ",", "half_mode", ")", ")", "ops", "[", "<NUM_LIT>", "]", "=", "force_reg", "(", "half_mode", ",", "ops", "[", "<NUM_LIT>", "]", ")", ";", "if", "(", "!", "register_operand", "(", "ops", "[", "<NUM_LIT>", "]", ",", "half_mode", ")", ")", "ops", "[", "<NUM_LIT>", "]", "=", "force_reg", "(", "half_mode", ",", "ops", "[", "<NUM_LIT>", "]", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "gen_rtx_VEC_CONCAT", "(", "mode", ",", "ops", "[", "<NUM_LIT>", "]", ",", "ops", "[", "<NUM_LIT>", "]", ")", ")", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "switch", "(", "mode", ")", "{", "case", "E_V4DImode", ":", "half_mode", "=", "V2DImode", ";", "break", ";", "case", "E_V4DFmode", ":", "half_mode", "=", "V2DFmode", ";", "break", ";", "case", "E_V4SImode", ":", "half_mode", "=", "V2SImode", ";", "break", ";", "case", "E_V4SFmode", ":", "half_mode", "=", "V2SFmode", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "goto", "half", ";", "case", "<NUM_LIT>", ":", "switch", "(", "mode", ")", "{", "case", "E_V8DImode", ":", "half_mode", "=", "V4DImode", ";", "break", ";", "case", "E_V8DFmode", ":", "half_mode", "=", "V4DFmode", ";", "break", ";", "case", "E_V8SImode", ":", "half_mode", "=", "V4SImode", ";", "break", ";", "case", "E_V8SFmode", ":", "half_mode", "=", "V4SFmode", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "goto", "half", ";", "case", "<NUM_LIT>", ":", "switch", "(", "mode", ")", "{", "case", "E_V16SImode", ":", "half_mode", "=", "V8SImode", ";", "break", ";", "case", "E_V16SFmode", ":", "half_mode", "=", "V8SFmode", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "goto", "half", ";", "half", ":", "i", "=", "n", "-", "<NUM_LIT>", ";", "for", "(", "j", "=", "<NUM_LIT>", ";", "j", "!=", "-", "<NUM_LIT>", ";", "j", "--", ")", "{", "half", "[", "j", "]", "=", "gen_reg_rtx", "(", "half_mode", ")", ";", "switch", "(", "n", ">>", "<NUM_LIT>", ")", "{", "case", "<NUM_LIT>", ":", "v", "=", "gen_rtvec", "(", "<NUM_LIT>", ",", "ops", "[", "i", "-", "<NUM_LIT>", "]", ",", "ops", "[", "i", "]", ")", ";", "i", "-=", "<NUM_LIT>", ";", "break", ";", "case", "<NUM_LIT>", ":", "v", "=", "gen_rtvec", "(", "<NUM_LIT>", ",", "ops", "[", "i", "-", "<NUM_LIT>", "]", ",", "ops", "[", "i", "-", "<NUM_LIT>", "]", ",", "ops", "[", "i", "-", "<NUM_LIT>", "]", ",", "ops", "[", "i", "]", ")", ";", "i", "-=", "<NUM_LIT>", ";", "break", ";", "case", "<NUM_LIT>", ":", "v", "=", "gen_rtvec", "(", "<NUM_LIT>", ",", "ops", "[", "i", "-", "<NUM_LIT>", "]", ",", "ops", "[", "i", "-", "<NUM_LIT>", "]", ",", "ops", "[", "i", "-", "<NUM_LIT>", "]", ",", "ops", "[", "i", "-", "<NUM_LIT>", "]", ",", "ops", "[", "i", "-", "<NUM_LIT>", "]", ",", "ops", "[", "i", "-", "<NUM_LIT>", "]", ",", "ops", "[", "i", "-", "<NUM_LIT>", "]", ",", "ops", "[", "i", "]", ")", ";", "i", "-=", "<NUM_LIT>", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "ix86_expand_vector_init", "(", "false", ",", "half", "[", "j", "]", ",", "gen_rtx_PARALLEL", "(", "half_mode", ",", "v", ")", ")", ";", "}", "ix86_expand_vector_init_concat", "(", "mode", ",", "target", ",", "half", ",", "<NUM_LIT>", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}" ]

[ "A", "subroutine", "of", "ix86_expand_vector_init_general", ".", "Use", "vector", "concatenate", "to", "handle", "the", "most", "general", "case", ":", "all", "values", "variable", ",", "and", "none", "identical", "." ]

[ ")", ";" ]

[ "unsigned", "CC", "=", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "const", "BasicBlock", "*", "LLVM_BB", "=", "BB", "->", "getBasicBlock", "(", ")", ";", "MachineFunction", "::", "iterator", "It", "=", "++", "BB", "->", "getIterator", "(", ")", ";", "MachineBasicBlock", "*", "ThisMBB", "=", "BB", ";", "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "IfFalseMBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "SinkMBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "F", "->", "insert", "(", "It", ",", "IfFalseMBB", ")", ";", "F", "->", "insert", "(", "It", ",", "SinkMBB", ")", ";", "SinkMBB", "->", "splice", "(", "SinkMBB", "->", "begin", "(", ")", ",", "ThisMBB", ",", "std", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "ThisMBB", "->", "end", "(", ")", ")", ";", "SinkMBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "ThisMBB" ]

[ "<STR_LIT>", "<STR_LIT>", ")" ]

[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPECV_LWPVAL_INTRINSIC", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr" ]

[ "<STR_LIT>", ";" ]

[ "def", "movimm32_shift", ":", "Operand", "<", "i32", ">", "{", "let", "PrintMethod", "=" ]

[ "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "V2SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "vec_merge", ":", "V2SF", "(", "minus", ":", "V2SF", "(", "match_operand", ":", "V2SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V2SF" ]

[ "const", "char", "*", "frv_asm_output_opcode", "(", "FILE", "*", "f", ",", "const", "char", "*", "ptr", ")", "{", "int", "c", ";", "if", "(", "frv_insn_packing_flag", "<=", "<NUM_LIT>", ")", "return", "ptr", ";", "for", "(", ";", "*", "ptr", "&&", "*", "ptr", "!=", "'", "'", "&&", "*", "ptr", "!=", "'", "\\t", "'", ";", ")", "{", "c", "=", "*", "ptr", "++", ";", "if", "(", "c", "==", "'", "%", "'", "&&", "(", "(", "*", "ptr", ">=", "'", "a", "'", "&&", "*", "ptr", "<=", "'", "z", "'", ")", "||", "(", "*", "ptr", ">=", "'", "A", "'", "&&", "*", "ptr", "<=", "'", "Z", "'", ")", ")", ")", "{", "int", "letter", "=", "*", "ptr", "++", ";", "c", "=", "atoi", "(", "ptr", ")", ";", "frv_print_operand", "(", "f", ",", "frv_insn_operands", "[", "c", "]", ",", "letter", ")", ";", "while", "(", "(", "c", "=", "*", "ptr", ")", ">=", "'", "<NUM_LIT>", "'", "&&", "c", "<=", "'", "<NUM_LIT>", "'", ")", "ptr", "++", ";", "}", "else", "fputc", "(", "c", ",", "f", ")", ";", "}", "fprintf", "(", "f", ",", "<STR_LIT>", ".p", "<STR_LIT>", ")", ";", "return", "ptr", ";", "}" ]

[ "The", "following", "function", "is", "used", "to", "add", "assembler", "insn", "code", "suffix", ".p", "if", "it", "is", "necessary", "." ]

[ ":", "InstrItinClass", ";" ]

[ "def", "tc_b857bf4e" ]

[ "<FIXS>", "(", "use", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "CRIS_CC0_REGNUM", ")", ")", "]", "<FIXE>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "neg", ":", "SF", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "<BUGS>", "(", "use", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "CLI", ".", "setDebugLoc", "(", "dl", ")", ".", "setChain", "(", "Chain", ")", ".", "setLibCallee", "(", "TLI", "->", "getLibcallCallingConv", "(", "LC", ")", ",", "Type", "::", "getVoidTy", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "DAG", ".", "getExternalSymbol", "(", "FunctionNames", "[", "AEABILibcall", "]", "[", "AlignVariant", "]", ",", "TLI", "->", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ",", "std", "::", "move", "(", "Args", ")", ")", ".", "setDiscardResult", "(", ")", ";" ]

[ "Args", ".", "push_back", "(", "Entry", ")", ";", "if", "(", "Src", ".", "getValueType", "(", ")", ".", "bitsGT", "(", "MVT", "::", "i32", ")", ")", "Src", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "MVT", "::", "i32", ",", "Src", ")", ";", "else", "if", "(", "Src", ".", "getValueType", "(", ")", ".", "bitsLT", "(", "MVT", "::", "i32", ")", ")", "Src", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "MVT", "::", "i32", ",", "Src", ")", ";", "Entry", ".", "Node", "=", "Src", ";", "Entry", ".", "Ty", "=", "Type", "::", "getInt32Ty", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "IsSExt", "=", "false", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "}", "else", "{", "Entry", ".", "Node", "=", "Src", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Size", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "}", "char", "const", "*", "FunctionNames", "[", "<NUM_LIT>", "]", "[", "<NUM_LIT>", "]", "=", "{", "{", "<STR_LIT>", "__aeabi_memcpy", "<STR_LIT>", ",", "<STR_LIT>", "__aeabi_memcpy4", "<STR_LIT>", ",", "<STR_LIT>", "__aeabi_memcpy8", "<STR_LIT>", "}", ",", "{", "<STR_LIT>", "__aeabi_memmove", "<STR_LIT>", ",", "<STR_LIT>", "__aeabi_memmove4", "<STR_LIT>", ",", "<STR_LIT>", "__aeabi_memmove8", "<STR_LIT>", "}", ",", "{", "<STR_LIT>", "__aeabi_memset", "<STR_LIT>", ",", "<STR_LIT>", "__aeabi_memset4", "<STR_LIT>", ",", "<STR_LIT>", "__aeabi_memset8", "<STR_LIT>", "}", ",", "{", "<STR_LIT>", "__aeabi_memclr", "<STR_LIT>", ",", "<STR_LIT>", "__aeabi_memclr4", "<STR_LIT>", ",", "<STR_LIT>", "__aeabi_memclr8", "<STR_LIT>", "}", "}", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "DAG", ")", ";" ]

[ "let", "opNewValue", "=", "<NUM_LIT>", ";" ]

[ "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "let", "ParserMatchClass", "=", "Imm0_63Operand", ";" ]

[ "def", "tvecshiftL64", ":", "Operand", "<", "i32", ">", ",", "TImmLeaf", "<", "i32", ",", "[", "{", "return", "(", "(", "(", "uint32_t", ")", "Imm", ")", "<", "<NUM_LIT>", ")", ";", "}", "]", ">", "{", "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

[ "<NUM_LIT>", "}", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Ii", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Ii", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Ii", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Pt4", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Pt4", "{", "<NUM_LIT>", "-" ]

[ "}", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>" ]

[ "<FIXS>", "return", "real_hash", "(", "CONST_DOUBLE_REAL_VALUE", "(", "k", ")", ")", "*", "result", ";", "<FIXE>" ]

[ "}", "case", "CONST_DOUBLE", ":", "<BUGS>", "if", "(", "mode", "!=", "VOIDmode", ")", "return", "real_hash", "(", "CONST_DOUBLE_REAL_VALUE", "(", "k", ")", ")", "*", "result", ";", "flen", "=", "<NUM_LIT>", ";", "break", ";", "<BUGE>", "case", "CODE_LABEL", ":", "fidx", "=", "<NUM_LIT>", ";" ]

[ "<NUM_LIT>", "}", "=", "Nt", ";" ]

[ "let", "IClass", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rz", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Mu", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "MajOp", ";", "let", "Inst", "{", "<NUM_LIT>", "-" ]

[ "SectionKind", "::", "getDataRel", "(", ")", ")", ";" ]

[ "void", "Cpu0TargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "SmallDataSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "<STR_LIT>", ".sdata", "<STR_LIT>", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", "," ]

[ "::", "CALL_INDIRECT_v4i32", ":" ]

[ "case", "WebAssembly", "::", "CALL_INDIRECT_I32", ":", "case", "WebAssembly", "::", "CALL_INDIRECT_I64", ":", "case", "WebAssembly", "::", "CALL_INDIRECT_F32", ":", "case", "WebAssembly", "::", "CALL_INDIRECT_F64", ":", "case", "WebAssembly", "::", "CALL_INDIRECT_v16i8", ":", "case", "WebAssembly", "::", "CALL_INDIRECT_v8i16", ":", "case", "WebAssembly" ]

[ "<FIXS>", "isCodeGenOnly", "=", "<NUM_LIT>", ",", "neverHasSideEffects", "=", "<NUM_LIT>", "indef", "MOV32ri64", ":", "Ii32", "<NUM_LIT>", ",", "AddRegFrm", ",", "(", "outs", "GR32", ":", "$", "dst", ")", ",", "(", "ins", "i64i32imm", ":", "$", "src", ")", ",", "<STR_LIT>", ",", "[", "]", ",", "IIC_ALU_NONMEM", ">", ",", "Sched", "[", "WriteALU", "]", ">", ";", "def", "mov64imm32", ":", "ComplexPattern", "i64", ",", "<NUM_LIT>", ",", "<STR_LIT>", ",", "[", "imm", ",", "X86Wrapper", "]", ">", ";", "let", "AddedComplexity", "=", "<NUM_LIT>", "indef", ":", "Pat", "(", "i64", "mov64imm32", ":", "$", "src", ")", ",", "(", "SUBREG_TO_REG", "(", "i64", "<NUM_LIT>", ")", ",", "(", "MOV32ri64", "mov64imm32", ":", "$", "src", ")", ",", "sub_32bit", ")", ">", ";", "<FIXE>" ]

[ "let", "AddedComplexity", "=", "<NUM_LIT>", ",", "isReMaterializable", "=", "<NUM_LIT>", ",", "isAsCheapAsAMove", "=", "<NUM_LIT>", ",", "<BUGS>", "isCodeGenOnly", "=", "<NUM_LIT>", "indef", "MOV64ri64i32", ":", "Ii32", "<NUM_LIT>", ",", "AddRegFrm", ",", "(", "outs", "GR64", ":", "$", "dst", ")", ",", "(", "ins", "i64i32imm", ":", "$", "src", ")", ",", "<STR_LIT>", ",", "[", "(", "set", "GR64", ":", "$", "dst", ",", "i64immZExt32", ":", "$", "src", ")", "]", ",", "IIC_ALU_NONMEM", ">", ",", "Sched", "[", "WriteALU", "]", ">", ";", "<BUGE>", "let", "Uses", "=", "[", "EFLAGS", "]", ",", "Defs", "=", "[", "EFLAGS", "]", ",", "isPseudo", "=", "<NUM_LIT>", ",", "SchedRW", "=", "[", "WriteALU", "]", "in", "{" ]

[ "}" ]

[ "SmallSetVector", "<", "unsigned", ",", "<NUM_LIT>", ">", "TargetRegs", ";", "for", "(", "MCRegAliasIterator", "AI", "(", "TargetReg", ",", "TRI", ",", "true", ")", ";", "AI", ".", "isValid", "(", ")", ";", "++", "AI", ")", "TargetRegs", ".", "insert", "(", "*", "AI", ")", ";", "bool", "Changed", "=", "false", ";", "MachineBasicBlock", "::", "iterator", "LastChange", "=", "MBB", "->", "begin", "(", ")", ";", "unsigned", "SmallestDef", "=", "TargetReg", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", "->", "begin", "(", ")", ",", "E", "=", "MBB", "->", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "MachineInstr", "*", "MI", "=", "&", "*", "I", ";", "++", "I", ";", "if", "(", "MI", "->", "isCopy", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", ")", "{", "unsigned", "DefReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "SrcReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "(", "SrcReg", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "SrcReg", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "!", "MRI", "->", "isReserved", "(", "DefReg", ")", "&&", "(", "TargetReg", "==", "DefReg", "||", "TRI", "->", "isSuperRegister", "(", "DefReg", ",", "TargetReg", ")", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Remove redundant Copy : ", "<STR_LIT>", ")", ";", "DEBUG", "(", "(", "MI", ")", "->", "print", "(", "dbgs", "(", ")", ")", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "Changed", "=", "true", ";", "LastChange", "=", "I", ";", "NumCopiesRemoved", "++", ";", "SmallestDef", "=", "TRI", "->", "isSubRegister", "(", "SmallestDef", ",", "DefReg", ")", "?", "DefReg", ":", "SmallestDef", ";", "continue", ";", "}", "}", "if", "(", "MI", "->", "modifiesRegister", "(", "TargetReg", ",", "TRI", ")", ")", "break", ";", "}", "if", "(", "!", "Changed", ")", "return", "false", ";", "CompBr", "->", "clearRegisterKills", "(", "SmallestDef", ",", "TRI", ")", ";", "if", "(", "none_of", "(", "TargetRegs", ",", "[", "&", "]", "(", "unsigned", "Reg", ")", "{", "return", "MBB", "->", "isLiveIn", "(", "Reg", ")", ";", "}", ")", ")", "MBB", "->", "addLiveIn", "(", "TargetReg", ")", ";", "for", "(", "MachineInstr", "&", "MMI", ":", "make_range", "(", "MBB", "->", "begin", "(", ")", ",", "LastChange", ")", ")", "MMI", ".", "clearRegisterKills", "(", "SmallestDef", ",", "TRI", ")", ";", "return", "true", ";" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rt", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "!", "if", "(", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "AlignSize", ")", ",", "<STR_LIT>", ")", ",", "offset", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ",", "!", "if", "(", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "AlignSize", ")", ",", "<STR_LIT>", ")", ",", "offset", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ",", "!", "if", "(", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "AlignSize", ")", ",", "<STR_LIT>", ")", ",", "offset", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ",", "offset", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ")", ")", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "let", "isPseudo", "=", "<NUM_LIT>", ";" ]

[ "def", "L2_loadrb_zomap", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_17e0d2cd", ",", "TypeMAPPING", ">", "{", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";" ]

[ ")", "{" ]

[ "SUnit", "*", "PPCPostRASchedStrategy", "::", "pickNode", "(", "bool", "&", "IsTopNode" ]

[ "void", "ARMTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ",", "OptimizationRemarkEmitter", "*", "ORE", ")", "{", "UP", ".", "UpperBound", "=", "!", "ST", "->", "hasMVEIntegerOps", "(", ")", "||", "!", "any_of", "(", "*", "L", "->", "getHeader", "(", ")", ",", "[", "]", "(", "Instruction", "&", "I", ")", "{", "return", "isa", "<", "IntrinsicInst", ">", "(", "I", ")", "&&", "cast", "<", "IntrinsicInst", ">", "(", "I", ")", ".", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "get_active_lane_mask", ";", "}", ")", ";", "if", "(", "!", "ST", "->", "isMClass", "(", ")", ")", "return", "BasicTTIImplBase", "::", "getUnrollingPreferences", "(", "L", ",", "SE", ",", "UP", ",", "ORE", ")", ";", "UP", ".", "OptSizeThreshold", "=", "<NUM_LIT>", ";", "UP", ".", "PartialOptSizeThreshold", "=", "<NUM_LIT>", ";", "if", "(", "L", "->", "getHeader", "(", ")", "->", "getParent", "(", ")", "->", "hasOptSize", "(", ")", ")", "return", ";", "SmallVector", "<", "BasicBlock", "*", ",", "<NUM_LIT>", ">", "ExitingBlocks", ";", "L", "->", "getExitingBlocks", "(", "ExitingBlocks", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Loop has:\\n", "<STR_LIT>", "<<", "<STR_LIT>", "Blocks: ", "<STR_LIT>", "<<", "L", "->", "getNumBlocks", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", "<<", "<STR_LIT>", "Exit blocks: ", "<STR_LIT>", "<<", "ExitingBlocks", ".", "size", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "if", "(", "ExitingBlocks", ".", "size", "(", ")", ">", "<NUM_LIT>", ")", "return", ";", "if", "(", "ST", "->", "hasBranchPredictor", "(", ")", "&&", "L", "->", "getNumBlocks", "(", ")", ">", "<NUM_LIT>", ")", "return", ";", "if", "(", "getBooleanLoopAttribute", "(", "L", ",", "<STR_LIT>", "llvm.loop.isvectorized", "<STR_LIT>", ")", ")", "return", ";", "InstructionCost", "Cost", "=", "<NUM_LIT>", ";", "for", "(", "auto", "*", "BB", ":", "L", "->", "getBlocks", "(", ")", ")", "{", "for", "(", "auto", "&", "I", ":", "*", "BB", ")", "{", "if", "(", "I", ".", "getType", "(", ")", "->", "isVectorTy", "(", ")", ")", "return", ";", "if", "(", "isa", "<", "CallInst", ">", "(", "I", ")", "||", "isa", "<", "InvokeInst", ">", "(", "I", ")", ")", "{", "if", "(", "const", "Function", "*", "F", "=", "cast", "<", "CallBase", ">", "(", "I", ")", ".", "getCalledFunction", "(", ")", ")", "{", "if", "(", "!", "isLoweredToCall", "(", "F", ")", ")", "continue", ";", "}", "return", ";", "}", "SmallVector", "<", "const", "Value", "*", ",", "<NUM_LIT>", ">", "Operands", "(", "I", ".", "operand_values", "(", ")", ")", ";", "Cost", "+=", "getInstructionCost", "(", "&", "I", ",", "Operands", ",", "TargetTransformInfo", "::", "TCK_SizeAndLatency", ")", ";", "}", "}", "unsigned", "UnrollCount", "=", "<NUM_LIT>", ";", "if", "(", "ST", "->", "isThumb1Only", "(", ")", ")", "{", "unsigned", "ExitingValues", "=", "<NUM_LIT>", ";", "SmallVector", "<", "BasicBlock", "*", ",", "<NUM_LIT>", ">", "ExitBlocks", ";", "L", "->", "getExitBlocks", "(", "ExitBlocks", ")", ";", "for", "(", "auto", "*", "Exit", ":", "ExitBlocks", ")", "{", "unsigned", "LiveOuts", "=", "count_if", "(", "Exit", "->", "phis", "(", ")", ",", "[", "]", "(", "auto", "&", "PH", ")", "{", "return", "PH", ".", "getNumOperands", "(", ")", "!=", "<NUM_LIT>", "||", "!", "isa", "<", "GetElementPtrInst", ">", "(", "PH", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "}", ")", ";", "ExitingValues", "=", "ExitingValues", "<", "LiveOuts", "?", "LiveOuts", ":", "ExitingValues", ";", "}", "if", "(", "ExitingValues", ")", "UnrollCount", "/", "=", "ExitingValues", ";", "if", "(", "UnrollCount", "<=", "<NUM_LIT>", ")", "return", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Cost of loop: ", "<STR_LIT>", "<<", "Cost", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Default Runtime Unroll Count: ", "<STR_LIT>", "<<", "UnrollCount", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "UP", ".", "Partial", "=", "true", ";", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "UnrollRemainder", "=", "true", ";", "UP", ".", "DefaultUnrollRuntimeCount", "=", "UnrollCount", ";", "UP", ".", "UnrollAndJam", "=", "true", ";", "UP", ".", "UnrollAndJamInnerLoopThreshold", "=", "<NUM_LIT>", ";", "if", "(", "Cost", "<", "<NUM_LIT>", ")", "UP", ".", "Force", "=", "true", ";", "}" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "unrolling", "transformation", "." ]

[ "]", ")" ]

[ "(", "define_int_iterator", "VMAXMIN", "[", "UNSPEC_VMAX", "UNSPEC_VMAX_U", "UNSPEC_VMIN", "UNSPEC_VMIN_U" ]

[ "void", "LEGAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "isPCRel", ")", "const", "{", "unsigned", "NumBytes", "=", "<NUM_LIT>", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "{", "return", ";", "}", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "DataSize", "&&", "<STR_LIT>", "Invalid fixup offset!", "<STR_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "<NUM_LIT>", ")", ")", "&", "<NUM_LIT>", ")", ";", "}", "}" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mem", ":", "SF", "(", "lo_sum", ":", "SI", "(", "match_operand", ":" ]

[ "if", "(", "!", "Check", "(", "S", ",", "DecodetGPRRegisterClass", "(", "Inst", ",", "Rn", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";" ]

[ "DecodeStatus", "S", "=", "MCDisassembler", "::", "Success", ";", "unsigned", "Rn", "=", "fieldFromInstruction32", "(", "Val", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "Rm", "=", "fieldFromInstruction32", "(", "Val", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";" ]

[ "<STR_LIT>" ]

[ "(", "vec_concat", ":", "V16HI", "(", "match_operand", ":", "V8HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V8HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", "(", "vec_select", ":", "V8HI", "(", "vec_concat", ":", "V16HI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", ")", "]", "<STR_LIT>" ]

[ "_", "a", ";" ]

[ "return", "(", "uint64x2_t", ")", "_" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ ",", "_", "_", "m512i", "_", "_", "B", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m512i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_mask_xor_epi64", "(", "_", "_", "m512i", "_", "_", "W", ",", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m512i", "_", "_", "A" ]

[ "bool", "Emitted", "=", "X86FastEmitExtend", "(", "ISD", "::", "ANY_EXTEND", ",", "VA", ".", "getLocVT", "(", ")", ",", "ArgReg", ",", "ArgVT", ",", "ArgReg", ")", ";" ]

[ "break", ";", "}", "if", "(", "IsTailCall", ")", "return", "false", ";", "if", "(", "(", "CC", "==", "CallingConv", "::", "Fast", "&&", "TM", ".", "Options", ".", "GuaranteedTailCallOpt", ")", "||", "CC", "==", "CallingConv", "::", "Tail", ")", "return", "false", ";", "if", "(", "IsVarArg", "&&", "IsWin64", ")", "return", "false", ";", "if", "(", "CLI", ".", "CS", "&&", "CLI", ".", "CS", "->", "hasInAllocaArgument", "(", ")", ")", "return", "false", ";", "for", "(", "auto", "Flag", ":", "CLI", ".", "OutFlags", ")", "if", "(", "Flag", ".", "isSwiftError", "(", ")", ")", "return", "false", ";", "SmallVector", "<", "MVT", ",", "<NUM_LIT>", ">", "OutVTs", ";", "SmallVector", "<", "unsigned", ",", "<NUM_LIT>", ">", "ArgRegs", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ",", "e", "=", "OutVals", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "Value", "*", "&", "Val", "=", "OutVals", "[", "i", "]", ";", "ISD", "::", "ArgFlagsTy", "Flags", "=", "OutFlags", "[", "i", "]", ";", "if", "(", "auto", "*", "CI", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "Val", ")", ")", "{", "if", "(", "CI", "->", "getBitWidth", "(", ")", "<", "<NUM_LIT>", ")", "{", "if", "(", "Flags", ".", "isSExt", "(", ")", ")", "Val", "=", "ConstantExpr", "::", "getSExt", "(", "CI", ",", "Type", "::", "getInt32Ty", "(", "CI", "->", "getContext", "(", ")", ")", ")", ";", "else", "Val", "=", "ConstantExpr", "::", "getZExt", "(", "CI", ",", "Type", "::", "getInt32Ty", "(", "CI", "->", "getContext", "(", ")", ")", ")", ";", "}", "}", "MVT", "VT", ";", "auto", "*", "TI", "=", "dyn_cast", "<", "TruncInst", ">", "(", "Val", ")", ";", "unsigned", "ResultReg", ";", "if", "(", "TI", "&&", "TI", "->", "getType", "(", ")", "->", "isIntegerTy", "(", "<NUM_LIT>", ")", "&&", "CLI", ".", "CS", "&&", "(", "TI", "->", "getParent", "(", ")", "==", "CLI", ".", "CS", "->", "getInstruction", "(", ")", "->", "getParent", "(", ")", ")", "&&", "TI", "->", "hasOneUse", "(", ")", ")", "{", "Value", "*", "PrevVal", "=", "TI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "ResultReg", "=", "getRegForValue", "(", "PrevVal", ")", ";", "if", "(", "!", "ResultReg", ")", "return", "false", ";", "if", "(", "!", "isTypeLegal", "(", "PrevVal", "->", "getType", "(", ")", ",", "VT", ")", ")", "return", "false", ";", "ResultReg", "=", "fastEmit_ri", "(", "VT", ",", "VT", ",", "ISD", "::", "AND", ",", "ResultReg", ",", "hasTrivialKill", "(", "PrevVal", ")", ",", "<NUM_LIT>", ")", ";", "}", "else", "{", "if", "(", "!", "isTypeLegal", "(", "Val", "->", "getType", "(", ")", ",", "VT", ")", "||", "(", "VT", ".", "isVector", "(", ")", "&&", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", ")", ")", "return", "false", ";", "ResultReg", "=", "getRegForValue", "(", "Val", ")", ";", "}", "if", "(", "!", "ResultReg", ")", "return", "false", ";", "ArgRegs", ".", "push_back", "(", "ResultReg", ")", ";", "OutVTs", ".", "push_back", "(", "VT", ")", ";", "}", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CC", ",", "IsVarArg", ",", "*", "FuncInfo", ".", "MF", ",", "ArgLocs", ",", "CLI", ".", "RetTy", "->", "getContext", "(", ")", ")", ";", "if", "(", "IsWin64", ")", "CCInfo", ".", "AllocateStack", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "CCInfo", ".", "AnalyzeCallOperands", "(", "OutVTs", ",", "OutFlags", ",", "CC_X86", ")", ";", "unsigned", "NumBytes", "=", "CCInfo", ".", "getAlignedCallFrameSize", "(", ")", ";", "unsigned", "AdjStackDown", "=", "TII", ".", "getCallFrameSetupOpcode", "(", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "AdjStackDown", ")", ")", ".", "addImm", "(", "NumBytes", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "const", "X86RegisterInfo", "*", "RegInfo", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "const", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "const", "Value", "*", "ArgVal", "=", "OutVals", "[", "VA", ".", "getValNo", "(", ")", "]", ";", "MVT", "ArgVT", "=", "OutVTs", "[", "VA", ".", "getValNo", "(", ")", "]", ";", "if", "(", "ArgVT", "==", "MVT", "::", "x86mmx", ")", "return", "false", ";", "unsigned", "ArgReg", "=", "ArgRegs", "[", "VA", ".", "getValNo", "(", ")", "]", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "SExt", ":", "{", "assert", "(", "VA", ".", "getLocVT", "(", ")", ".", "isInteger", "(", ")", "&&", "!", "VA", ".", "getLocVT", "(", ")", ".", "isVector", "(", ")", "&&", "<STR_LIT>", "Unexpected extend", "<STR_LIT>", ")", ";", "if", "(", "ArgVT", "==", "MVT", "::", "i1", ")", "return", "false", ";", "bool", "Emitted", "=", "X86FastEmitExtend", "(", "ISD", "::", "SIGN_EXTEND", ",", "VA", ".", "getLocVT", "(", ")", ",", "ArgReg", ",", "ArgVT", ",", "ArgReg", ")", ";", "assert", "(", "Emitted", "&&", "<STR_LIT>", "Failed to emit a sext!", "<STR_LIT>", ")", ";", "(", "void", ")", "Emitted", ";", "ArgVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "break", ";", "}", "case", "CCValAssign", "::", "ZExt", ":", "{", "assert", "(", "VA", ".", "getLocVT", "(", ")", ".", "isInteger", "(", ")", "&&", "!", "VA", ".", "getLocVT", "(", ")", ".", "isVector", "(", ")", "&&", "<STR_LIT>", "Unexpected extend", "<STR_LIT>", ")", ";", "if", "(", "ArgVT", "==", "MVT", "::", "i1", ")", "{", "ArgReg", "=", "fastEmitZExtFromI1", "(", "MVT", "::", "i8", ",", "ArgReg", ",", "false", ")", ";", "ArgVT", "=", "MVT", "::", "i8", ";", "if", "(", "ArgReg", "==", "<NUM_LIT>", ")", "return", "false", ";", "}", "bool", "Emitted", "=", "X86FastEmitExtend", "(", "ISD", "::", "ZERO_EXTEND", ",", "VA", ".", "getLocVT", "(", ")", ",", "ArgReg", ",", "ArgVT", ",", "ArgReg", ")", ";", "assert", "(", "Emitted", "&&", "<STR_LIT>", "Failed to emit a zext!", "<STR_LIT>", ")", ";", "(", "void", ")", "Emitted", ";", "ArgVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "break", ";", "}", "case", "CCValAssign", "::", "AExt", ":", "{", "assert", "(", "VA", ".", "getLocVT", "(", ")", ".", "isInteger", "(", ")", "&&", "!", "VA", ".", "getLocVT", "(", ")", ".", "isVector", "(", ")", "&&", "<STR_LIT>", "Unexpected extend", "<STR_LIT>", ")", ";" ]

[ "return", "true", ";" ]

[ "SDValue", "Ptr", ",", "VAddr", ",", "Offen", ",", "Idxen", ",", "Addr64", ";", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "Subtarget", "->", "getInstrInfo", "(", ")", ")", ";", "SelectMUBUF", "(", "Addr", ",", "Ptr", ",", "VAddr", ",", "SOffset", ",", "Offset", ",", "Offen", ",", "Idxen", ",", "Addr64", ",", "GLC", ",", "SLC", ",", "TFE", ")", ";", "if", "(", "!", "cast", "<", "ConstantSDNode", ">", "(", "Offen", ")", "->", "getSExtValue", "(", ")", "&&", "!", "cast", "<", "ConstantSDNode", ">", "(", "Idxen", ")", "->", "getSExtValue", "(", ")", "&&", "!", "cast", "<", "ConstantSDNode", ">", "(", "Addr64", ")", "->", "getSExtValue", "(", ")", ")", "{", "uint64_t", "Rsrc", "=", "TII", "->", "getDefaultRsrcDataFormat", "(", ")", "|", "APInt", "::", "getAllOnesValue", "(", "<NUM_LIT>", ")", ".", "getZExtValue", "(", ")", ";", "SDLoc", "DL", "(", "Addr", ")", ";", "const", "SITargetLowering", "&", "Lowering", "=", "*", "static_cast", "<", "const", "SITargetLowering", "*", ">", "(", "getTargetLowering", "(", ")", ")", ";", "SRsrc", "=", "SDValue", "(", "Lowering", ".", "buildRSRC", "(", "*", "CurDAG", ",", "DL", ",", "Ptr", ",", "<NUM_LIT>", ",", "Rsrc", ")", ",", "<NUM_LIT>", ")", ";" ]

[ "ValueList", "&", "rhs", ")", ":" ]

[ "BinOpChain", "(", "Instruction", "*", "I", ",", "ValueList", "&", "lhs", "," ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "AbsoluteSet", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "isExtended", "=", "<NUM_LIT>", ";", "let", "DecoderNamespace", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")" ]

[ "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<FIXS>", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", "<FIXE>" ]

[ "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", "<BUGE>", "<STR_LIT>", ")", "(", "define_bypass", "<NUM_LIT>", "<STR_LIT>" ]

[ "<STR_LIT>", ")" ]

[ "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", ")" ]

[ ")" ]

[ "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>" ]

[ "<STR_LIT>", ")", "]", ")" ]

[ "(", "define_mode_iterator", "VF2_AVX512VL", "[", "V8DF", "(", "V4DF", "<STR_LIT>", ")", "(", "V2DF" ]

[ "TargetRegistry", "::", "RegisterMCCodeEmitter", "(", "getTheGBZ80Target", "(", ")", ",", "createGBZ80MCCodeEmitter", ")", ";" ]

[ "TargetRegistry", "::", "RegisterMCInstrInfo", "(", "getTheGBZ80Target", "(", ")", ",", "createGBZ80MCInstrInfo", ")", ";", "TargetRegistry", "::", "RegisterMCRegInfo", "(", "getTheGBZ80Target", "(", ")", ",", "createGBZ80MCRegisterInfo", ")", ";", "TargetRegistry", "::", "RegisterMCSubtargetInfo", "(", "getTheGBZ80Target", "(", ")", ",", "createGBZ80MCSubtargetInfo", ")", ";", "TargetRegistry", "::", "RegisterMCInstPrinter", "(", "getTheGBZ80Target", "(", ")", ",", "createGBZ80MCInstPrinter", ")", ";" ]

[ "<STR_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "prefersSlot3", "=", "<NUM_LIT>", ";", "let", "Constraints", "=" ]

[ "<FIXS>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "fix", ":", "SI", "(", "fix", ":", "SF", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<FIXE>", "<FIXS>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "fix", ":", "SI", "(", "fix", ":", "DF", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<FIXE>" ]

[ ")", "(", "define_expand", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "fix", ":", "SI", "(", "fix", ":", "SF", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<STR_LIT>", ")", "(", "define_expand", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "fix", ":", "SI", "(", "fix", ":", "DF", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "def", ":", "Pat", "<", "(", "i40", "imm32Signed", ":", "$", "val", ")", ",", "(", "SET_imm16_abl", "(", "LO16", "imm", ":", "$", "val", ")", ",", "(", "MOV_imm16_abh", "(", "HI16", "imm", ":", "$", "val", ")", ")", ")", ">", ";" ]

[ "}", "]", ">", ";", "def", "HI16", ":", "SDNodeXForm", "<", "imm", ",", "[", "{", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "(", "unsigned", ")", "N", "-", ">", "getZExtValue", "(", ")", ">", ">", "<NUM_LIT>", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i40", ")", ";", "}", "]", ">", ";" ]

[ "return", "-", "<NUM_LIT>", ";" ]

[ "int64_t", "AMDGPUAsmParser", "::", "parseDPPCtrlSel", "(", "StringRef", "Ctrl", ")", "{", "using", "namespace", "AMDGPU", "::", "DPP", ";", "int64_t", "Val", ";", "SMLoc", "Loc", "=", "getLoc", "(", ")", ";", "if", "(", "getParser", "(", ")", ".", "parseAbsoluteExpression", "(", "Val", ")", ")", "return", "-", "<NUM_LIT>", ";", "struct", "DppCtrlCheck", "{", "int64_t", "Ctrl", ";", "int", "Lo", ";", "int", "Hi", ";", "}", ";", "DppCtrlCheck", "Check", "=", "StringSwitch", "<", "DppCtrlCheck", ">", "(", "Ctrl", ")", ".", "Case", "(", "<STR_LIT>", "wave_shl", "<STR_LIT>", ",", "{", "DppCtrl", "::", "WAVE_SHL1", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ".", "Case", "(", "<STR_LIT>", "wave_rol", "<STR_LIT>", ",", "{", "DppCtrl", "::", "WAVE_ROL1", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ".", "Case", "(", "<STR_LIT>", "wave_shr", "<STR_LIT>", ",", "{", "DppCtrl", "::", "WAVE_SHR1", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ".", "Case", "(", "<STR_LIT>", "wave_ror", "<STR_LIT>", ",", "{", "DppCtrl", "::", "WAVE_ROR1", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ".", "Case", "(", "<STR_LIT>", "row_shl", "<STR_LIT>", ",", "{", "DppCtrl", "::", "ROW_SHL0", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ".", "Case", "(", "<STR_LIT>", "row_shr", "<STR_LIT>", ",", "{", "DppCtrl", "::", "ROW_SHR0", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ".", "Case", "(", "<STR_LIT>", "row_ror", "<STR_LIT>", ",", "{", "DppCtrl", "::", "ROW_ROR0", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ".", "Case", "(", "<STR_LIT>", "row_share", "<STR_LIT>", ",", "{", "DppCtrl", "::", "ROW_SHARE_FIRST", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ".", "Case", "(", "<STR_LIT>", "row_xmask", "<STR_LIT>", ",", "{", "DppCtrl", "::", "ROW_XMASK_FIRST", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ".", "Case", "(", "<STR_LIT>", "row_newbcast", "<STR_LIT>", ",", "{", "DppCtrl", "::", "ROW_NEWBCAST_FIRST", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ".", "Default", "(", "{", "-", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ";", "bool", "Valid", ";", "if", "(", "Check", ".", "Ctrl", "==", "-", "<NUM_LIT>", ")", "{", "Valid", "=", "(", "Ctrl", "==", "<STR_LIT>", "row_bcast", "<STR_LIT>", "&&", "(", "Val", "==", "<NUM_LIT>", "||", "Val", "==", "<NUM_LIT>", ")", ")", ";", "Val", "=", "(", "Val", "==", "<NUM_LIT>", ")", "?", "DppCtrl", "::", "BCAST15", ":", "DppCtrl", "::", "BCAST31", ";", "}", "else", "{", "Valid", "=", "Check", ".", "Lo", "<=", "Val", "&&", "Val", "<=", "Check", ".", "Hi", ";", "Val", "=", "(", "Check", ".", "Lo", "==", "Check", ".", "Hi", ")", "?", "Check", ".", "Ctrl", ":", "(", "Check", ".", "Ctrl", "|", "Val", ")", ";", "}", "if", "(", "!", "Valid", ")", "{", "Error", "(", "Loc", ",", "Twine", "(", "<STR_LIT>", "invalid ", "<STR_LIT>", ",", "Ctrl", ")", "+", "Twine", "(", "<STR_LIT>", " value", "<STR_LIT>", ")", ")", ";" ]

[ "let", "hasNewValue", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ ")" ]

[ "(", "and", "(", "match_code", "<STR_LIT>" ]

[ "]", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V32QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "V32QI", "[", "(", "match_operand", ":", "V32QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_LASX_XVMSKNZ", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "(", "truncate", ":", "SI", "(", "lshiftrt", ":", "DI", "(", "mult", ":", "DI", "(", "zero_extend", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", ")" ]

[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<FIXS>", "warning", "(", "<NUM_LIT>", ",", "<STR_LIT>", "%qs is not supported on little endian systems", "<STR_LIT>", ",", "<STR_LIT>", "-mmultiple", "<STR_LIT>", ")", ";", "<FIXE>", "<FIXS>", "warning", "(", "<NUM_LIT>", ",", "<STR_LIT>", "%qs is not supported on little endian systems", "<STR_LIT>", ",", "<STR_LIT>", "-mstring", "<STR_LIT>", ")", ";", "<FIXE>" ]

[ "{", "rs6000_isa_flags", "&=", "~", "OPTION_MASK_MULTIPLE", ";", "if", "(", "(", "rs6000_isa_flags_explicit", "&", "OPTION_MASK_MULTIPLE", ")", "!=", "<NUM_LIT>", ")", "<BUGS>", "warning", "(", "<NUM_LIT>", ",", "<STR_LIT>", "-mmultiple is not supported on little endian systems", "<STR_LIT>", ")", ";", "<BUGE>", "}", "if", "(", "TARGET_STRING", ")", "{", "rs6000_isa_flags", "&=", "~", "OPTION_MASK_STRING", ";", "if", "(", "(", "rs6000_isa_flags_explicit", "&", "OPTION_MASK_STRING", ")", "!=", "<NUM_LIT>", ")", "<BUGS>", "warning", "(", "<NUM_LIT>", ",", "<STR_LIT>", "-mstring is not supported on little endian systems", "<STR_LIT>", ")", ";", "<BUGE>", "}", "}" ]

[ "unsigned", "HexagonMCCodeEmitter", "::", "getMachineOpValue", "(", "MCInst", "const", "&", "MI", ",", "MCOperand", "const", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "MCSubtargetInfo", "const", "&", "STI", ")", "const", "{", "size_t", "OperandNumber", "=", "~", "<NUM_LIT>", "U", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "n", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "<", "n", ";", "++", "i", ")", "if", "(", "&", "MI", ".", "getOperand", "(", "i", ")", "==", "&", "MO", ")", "{", "OperandNumber", "=", "i", ";", "break", ";", "}", "assert", "(", "(", "OperandNumber", "!=", "~", "<NUM_LIT>", "U", ")", "&&", "<STR_LIT>", "Operand not found", "<STR_LIT>", ")", ";", "if", "(", "HexagonMCInstrInfo", "::", "isNewValue", "(", "MCII", ",", "MI", ")", "&&", "&", "MO", "==", "&", "MI", ".", "getOperand", "(", "HexagonMCInstrInfo", "::", "getNewValueOp", "(", "MCII", ",", "MI", ")", ")", ")", "{", "MCOperand", "const", "&", "MCO", "=", "MI", ".", "getOperand", "(", "HexagonMCInstrInfo", "::", "getNewValueOp", "(", "MCII", ",", "MI", ")", ")", ";", "unsigned", "SOffset", "=", "<NUM_LIT>", ";", "unsigned", "VOffset", "=", "<NUM_LIT>", ";", "unsigned", "Register", "=", "MCO", ".", "getReg", "(", ")", ";", "unsigned", "Register1", ";", "unsigned", "Register2", ";", "auto", "Instructions", "=", "HexagonMCInstrInfo", "::", "bundleInstructions", "(", "*", "*", "CurrentBundle", ")", ";", "auto", "i", "=", "Instructions", ".", "begin", "(", ")", "+", "*", "CurrentIndex", "-", "<NUM_LIT>", ";", "for", "(", ";", ";", "--", "i", ")", "{", "assert", "(", "i", "!=", "Instructions", ".", "begin", "(", ")", "-", "<NUM_LIT>", "&&", "<STR_LIT>", "Couldn't find producer", "<STR_LIT>", ")", ";", "MCInst", "const", "&", "Inst", "=", "*", "i", "->", "getInst", "(", ")", ";", "if", "(", "HexagonMCInstrInfo", "::", "isImmext", "(", "Inst", ")", ")", "continue", ";", "++", "SOffset", ";", "if", "(", "HexagonMCInstrInfo", "::", "isVector", "(", "MCII", ",", "Inst", ")", ")", "++", "VOffset", ";", "Register1", "=", "HexagonMCInstrInfo", "::", "hasNewValue", "(", "MCII", ",", "Inst", ")", "?", "HexagonMCInstrInfo", "::", "getNewValueOperand", "(", "MCII", ",", "Inst", ")", ".", "getReg", "(", ")", ":", "static_cast", "<", "unsigned", ">", "(", "Hexagon", "::", "NoRegister", ")", ";", "Register2", "=", "HexagonMCInstrInfo", "::", "hasNewValue2", "(", "MCII", ",", "Inst", ")", "?", "HexagonMCInstrInfo", "::", "getNewValueOperand2", "(", "MCII", ",", "Inst", ")", ".", "getReg", "(", ")", ":", "static_cast", "<", "unsigned", ">", "(", "Hexagon", "::", "NoRegister", ")", ";", "if", "(", "!", "RegisterMatches", "(", "Register", ",", "Register1", ",", "Register2", ")", ")", "continue", ";", "if", "(", "!", "HexagonMCInstrInfo", "::", "isPredicated", "(", "MCII", ",", "Inst", ")", ")", "break", ";", "assert", "(", "HexagonMCInstrInfo", "::", "isPredicated", "(", "MCII", ",", "MI", ")", "&&", "<STR_LIT>", "Unpredicated consumer depending on predicated producer", "<STR_LIT>", ")", ";", "if", "(", "HexagonMCInstrInfo", "::", "isPredicatedTrue", "(", "MCII", ",", "Inst", ")", "==", "HexagonMCInstrInfo", "::", "isPredicatedTrue", "(", "MCII", ",", "MI", ")", ")", "break", ";", "}", "unsigned", "Offset", "=", "HexagonMCInstrInfo", "::", "isVector", "(", "MCII", ",", "MI", ")", "?", "VOffset", ":", "SOffset", ";", "Offset", "<<=", "<NUM_LIT>", ";", "Offset", "|=", "HexagonMCInstrInfo", "::", "SubregisterBit", "(", "Register", ",", "Register1", ",", "Register2", ")", ";", "return", "Offset", ";", "}", "assert", "(", "!", "MO", ".", "isImm", "(", ")", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "HexagonMCInstrInfo", "::", "isSubInstruction", "(", "MI", ")", "||", "llvm", "::", "HexagonMCInstrInfo", "::", "getType", "(", "MCII", ",", "MI", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "HexagonMCInstrInfo", "::", "getDuplexRegisterNumbering", "(", "Reg", ")", ";", "return", "MCT", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "Reg", ")", ";", "}", "return", "getExprOpValue", "(", "MI", ",", "MO", ",", "MO", ".", "getExpr", "(", ")", ",", "Fixups", ",", "STI", ")", ";", "}" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opcode", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Q", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "U", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "size", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "size2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ ")", "]", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "X87MODEF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "absneg", ":", "X87MODEF", "(", "match_operand", ":", "X87MODEF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

[ "Node", ",", "ResNode", ")", ";" ]

[ "if", "(", "!", "Node", ")", "continue", ";", "SDNode", "*", "ResNode", "=", "Lowering", ".", "PostISelFolding", "(", "Node", ",", "*", "CurDAG", ")", ";", "if", "(", "ResNode", "!=", "Node", ")", "ReplaceUses", "(" ]