Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "let", "Constraints", "=", "cstr", ";" ]

[ "field", "bits", "<", "<NUM_LIT>", ">", "Unpredictable", "=", "<NUM_LIT>", ";", "field", "bits", "<", "<NUM_LIT>", ">", "SoftFail", "=", "Unpredictable", ";", "let", "Namespace", "=", "<STR_LIT>", ";", "Format", "F", "=", "f", ";", "bits", "<", "<NUM_LIT>", ">", "Form", "=", "F", ".", "Value", ";", "let", "Pattern", "=", "[", "]", ";" ]

[ "}" ]

[ "_", "_", "arm_vsubq_x", "(", "float32x4_t", "_", "_", "a", ",", "float32_t", "_", "_", "b", ",", "mve_pred16_t", "_", "_", "p", ")", "{", "return", "_", "_", "arm_vsubq_x_n_f32", "(", "_", "_", "a", ",", "_", "_", "b", ",", "_", "_", "p", ")", ";" ]

[ "Ptr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "PtrVT", ",", "Ptr", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "PtrVT", ")", ")", ";" ]

[ "SDValue", "Val", "=", "Nd", ".", "getValue", "(", ")", ",", "Ptr", "=", "Nd", ".", "getBasePtr", "(", ")", ",", "Chain", "=", "Nd", ".", "getChain", "(", ")", ";", "EVT", "PtrVT", "=", "Ptr", ".", "getValueType", "(", ")", ";", "SDValue", "Lo", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "i32", ",", "Val", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "Hi", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "i32", ",", "Val", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "if", "(", "!", "Subtarget", "->", "isLittle", "(", ")", ")", "std", "::", "swap", "(", "Lo", ",", "Hi", ")", ";", "Chain", "=", "DAG", ".", "getStore", "(", "Chain", ",", "DL", ",", "Lo", ",", "Ptr", ",", "MachinePointerInfo", "(", ")", ",", "Nd", ".", "isVolatile", "(", ")", ",", "Nd", ".", "isNonTemporal", "(", ")", ",", "Nd", ".", "getAlignment", "(", ")", ",", "Nd", ".", "getTBAAInfo", "(", ")", ")", ";" ]

[ "EndBB", "=", "EndBB1", ";" ]

[ "BasicBlock", "*", "ElseBB1", "=", "BasicBlock", "::", "Create", "(", "C", ",", "<STR_LIT>", "if.else1", "<STR_LIT>", ",", "F", ")", ";", "BasicBlock", "*", "EndBB1", "=", "BasicBlock", "::", "Create", "(", "C", ",", "<STR_LIT>", "if.end", "<STR_LIT>", ",", "F", ")", ";", "Value", "*", "ThrewCmp", "=", "IRB", ".", "CreateICmpNE", "(", "Threw", ",", "getAddrSizeInt", "(", "M", ",", "<NUM_LIT>", ")", ")", ";", "Value", "*", "ThrewValue", "=", "IRB", ".", "CreateLoad", "(", "IRB", ".", "getInt32Ty", "(", ")", ",", "ThrewValueGV", ",", "ThrewValueGV", "->", "getName", "(", ")", "+", "<STR_LIT>", ".val", "<STR_LIT>", ")", ";", "Value", "*", "ThrewValueCmp", "=", "IRB", ".", "CreateICmpNE", "(", "ThrewValue", ",", "IRB", ".", "getInt32", "(", "<NUM_LIT>", ")", ")", ";", "Value", "*", "Cmp1", "=", "IRB", ".", "CreateAnd", "(", "ThrewCmp", ",", "ThrewValueCmp", ",", "<STR_LIT>", "cmp1", "<STR_LIT>", ")", ";", "IRB", ".", "CreateCondBr", "(", "Cmp1", ",", "ThenBB1", ",", "ElseBB1", ")", ";", "IRB", ".", "SetInsertPoint", "(", "ThenBB1", ")", ";", "BasicBlock", "*", "ThenBB2", "=", "BasicBlock", "::", "Create", "(", "C", ",", "<STR_LIT>", "if.then2", "<STR_LIT>", ",", "F", ")", ";", "BasicBlock", "*", "EndBB2", "=", "BasicBlock", "::", "Create", "(", "C", ",", "<STR_LIT>", "if.end2", "<STR_LIT>", ",", "F", ")", ";", "Value", "*", "ThrewPtr", "=", "IRB", ".", "CreateIntToPtr", "(", "Threw", ",", "getAddrPtrType", "(", "M", ")", ",", "Threw", "->", "getName", "(", ")", "+", "<STR_LIT>", ".p", "<STR_LIT>", ")", ";", "Value", "*", "LoadedThrew", "=", "IRB", ".", "CreateLoad", "(", "getAddrIntType", "(", "M", ")", ",", "ThrewPtr", ",", "ThrewPtr", "->", "getName", "(", ")", "+", "<STR_LIT>", ".loaded", "<STR_LIT>", ")", ";", "Value", "*", "ThenLabel", "=", "IRB", ".", "CreateCall", "(", "TestSetjmpF", ",", "{", "LoadedThrew", ",", "SetjmpTable", ",", "SetjmpTableSize", "}", ",", "<STR_LIT>", "label", "<STR_LIT>", ")", ";", "Value", "*", "Cmp2", "=", "IRB", ".", "CreateICmpEQ", "(", "ThenLabel", ",", "IRB", ".", "getInt32", "(", "<NUM_LIT>", ")", ")", ";", "IRB", ".", "CreateCondBr", "(", "Cmp2", ",", "ThenBB2", ",", "EndBB2", ")", ";", "IRB", ".", "SetInsertPoint", "(", "ThenBB2", ")", ";", "IRB", ".", "CreateCall", "(", "EmLongjmpF", ",", "{", "Threw", ",", "ThrewValue", "}", ")", ";", "IRB", ".", "CreateUnreachable", "(", ")", ";", "IRB", ".", "SetInsertPoint", "(", "EndBB2", ")", ";", "IRB", ".", "CreateCall", "(", "SetTempRet0F", ",", "ThrewValue", ")", ";", "IRB", ".", "CreateBr", "(", "EndBB1", ")", ";", "IRB", ".", "SetInsertPoint", "(", "ElseBB1", ")", ";", "IRB", ".", "CreateBr", "(", "EndBB1", ")", ";", "IRB", ".", "SetInsertPoint", "(", "EndBB1", ")", ";", "PHINode", "*", "LabelPHI", "=", "IRB", ".", "CreatePHI", "(", "IRB", ".", "getInt32Ty", "(", ")", ",", "<NUM_LIT>", ",", "<STR_LIT>", "label", "<STR_LIT>", ")", ";", "LabelPHI", "->", "addIncoming", "(", "ThenLabel", ",", "EndBB2", ")", ";", "LabelPHI", "->", "addIncoming", "(", "IRB", ".", "getInt32", "(", "-", "<NUM_LIT>", ")", ",", "ElseBB1", ")", ";", "Label", "=", "LabelPHI", ";" ]

[ "return", "false", ";" ]

[ "if", "(", "TARGET_SHMEDIA", ")" ]

[ "return", "nullptr", ";" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "break", ";", "TARGET_NODE_CASE", "(", "Lo", ")", "TARGET_NODE_CASE", "(", "Hi", ")", "TARGET_NODE_CASE", "(", "GETFUNPLT", ")", "TARGET_NODE_CASE", "(", "GETTLSADDR", ")", "TARGET_NODE_CASE", "(", "CALL", ")", "TARGET_NODE_CASE", "(", "RET_FLAG", ")", "TARGET_NODE_CASE", "(", "GLOBAL_BASE_REG", ")", "}" ]

[ ")", ";" ]

[ "SmallVector", "<", "ISD", "::", "InputArg", ",", "<NUM_LIT>", ">", "&", "Ins", "=", "CLI", ".", "Ins", ";", "SDValue", "Chain", "=", "CLI", ".", "Chain", ";", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "bool", "&", "isTailCall", "=", "CLI", ".", "IsTailCall", ";", "CallingConv", "::", "ID", "CallConv", "=", "CLI", ".", "CallConv", ";", "bool", "isVarArg", "=", "CLI", ".", "IsVarArg", ";", "bool", "IsStructRet", "=", "(", "Outs", ".", "empty", "(", ")", ")", "?", "false", ":", "Outs", "[", "<NUM_LIT>", "]", ".", "Flags", ".", "isSRet", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "NumNamedVarArgParams", "=", "-", "<NUM_LIT>", ";", "if", "(", "GlobalAddressSDNode", "*", "GA", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "{", "const", "Function", "*", "CalleeFn", "=", "NULL", ";", "Callee", "=", "DAG", ".", "getTargetGlobalAddress", "(", "GA", "->", "getGlobal", "(", ")", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "if", "(", "(", "CalleeFn", "=", "dyn_cast", "<", "Function", ">", "(", "GA", "->", "getGlobal", "(", ")", ")", ")", ")", "{", "if", "(", "CalleeFn", "->", "isVarArg", "(", ")", "&&", "CalleeFn", "->", "getFunctionType", "(", ")", "->", "getNumParams", "(", ")", "!=", "<NUM_LIT>", ")", "{", "NumNamedVarArgParams", "=", "CalleeFn", "->", "getFunctionType", "(", ")", "->", "getNumParams", "(", ")", ";", "}", "}", "}", "if", "(", "NumNamedVarArgParams", ">", "<NUM_LIT>", ")", "CCInfo", ".", "AnalyzeCallOperands", "(", "Outs", ",", "CC_Hexagon_VarArg", ")", ";", "else", "CCInfo", ".", "AnalyzeCallOperands", "(", "Outs", ",", "CC_Hexagon", ")", ";", "if", "(", "isTailCall", ")", "{", "bool", "StructAttrFlag", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ";", "isTailCall", "=", "IsEligibleForTailCallOptimization", "(", "Callee", ",", "CallConv", ",", "isVarArg", ",", "IsStructRet", ",", "StructAttrFlag", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "DAG", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "if", "(", "VA", ".", "isMemLoc", "(", ")", ")", "{", "isTailCall", "=", "false", ";", "break", ";", "}", "}", "if", "(", "isTailCall", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Eligible for Tail Call\\n", "<STR_LIT>", ")", ";", "}", "else", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Argument must be passed on stack. Not eligible for Tail Call\\n", "<STR_LIT>", ")", ";", "}", "}", "unsigned", "NumBytes", "=", "CCInfo", ".", "getNextStackOffset", "(", ")", ";", "SmallVector", "<", "std", "::", "pair", "<", "unsigned", ",", "SDValue", ">", ",", "<NUM_LIT>", ">", "RegsToPass", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "MemOpChains", ";", "SDValue", "StackPtr", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "TM", ".", "getRegisterInfo", "(", ")", "->", "getStackRegister", "(", ")", ",", "getPointerTy", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "SDValue", "Arg", "=", "OutVals", "[", "i", "]", ";", "ISD", "::", "ArgFlagsTy", "Flags", "=", "Outs", "[", "i", "]", ".", "Flags", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown loc info!", "<STR_LIT>", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "SExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SIGN_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "case", "CCValAssign", "::", "ZExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "case", "CCValAssign", "::", "AExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "}", "if", "(", "VA", ".", "isMemLoc", "(", ")", ")", "{", "unsigned", "LocMemOffset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "SDValue", "PtrOff", "=", "DAG", ".", "getConstant", "(", "LocMemOffset", ",", "StackPtr", ".", "getValueType", "(", ")", ")", ";", "PtrOff", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "MVT", "::", "i32", ",", "StackPtr", ",", "PtrOff", ")", ";", "if", "(", "Flags", ".", "isByVal", "(", ")", ")", "{", "MemOpChains", ".", "push_back", "(", "CreateCopyOfByValArgument", "(", "Arg", ",", "PtrOff", ",", "Chain", ",", "Flags", ",", "DAG", ",", "dl", ")", ")", ";", "}", "else", "{", "MemOpChains", ".", "push_back", "(", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "Arg", ",", "PtrOff", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ")", ";", "}", "continue", ";", "}", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "VA", ".", "getLocReg", "(", ")", ",", "Arg", ")", ")", ";", "}", "}", "if", "(", "!", "MemOpChains", ".", "empty", "(", ")", ")", "{", "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "dl", ",", "MVT", "::", "Other", ",", "&", "MemOpChains", "[", "<NUM_LIT>", "]", ",", "MemOpChains", ".", "size", "(", ")", ")", ";", "}", "if", "(", "!", "isTailCall", ")", "Chain", "=", "DAG", ".", "getCALLSEQ_START", "(", "Chain", ",", "DAG", ".", "getConstant", "(", "NumBytes", ",", "getPointerTy", "(", ")", ",", "true", ")", ")", ";", "SDValue", "InFlag", ";", "if", "(", "!", "isTailCall", ")", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "RegsToPass", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "RegsToPass", "[", "i", "]", ".", "first", ",", "RegsToPass", "[", "i", "]", ".", "second", ",", "InFlag", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "}", "}", "if", "(", "isTailCall", ")", "{", "InFlag", "=", "SDValue", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "RegsToPass", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "RegsToPass", "[", "i", "]", ".", "first", ",", "RegsToPass", "[", "i", "]", ".", "second", ",", "InFlag", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ "switch", "(", "Opc", ")", "{", "default", ":", "return", "<NUM_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<NUM_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ ";" ]

[ "++", "count", ";", "mask", "&=", "~", "(", "mask", "&", "-", "mask", ")", ";", "}", "return", "count" ]

[ "cls", ";" ]

[ "class", "BinaryRRD", "<", "string", "mnemonic", ",", "bits", "<", "<NUM_LIT>", ">", "opcode", ",", "SDPatternOperator", "operator", ",", "RegisterOperand", "cls1", ",", "RegisterOperand", "cls2", ">", ":", "InstRRD", "<", "opcode", ",", "(", "outs", "cls1", ":", "$", "R1", ")", ",", "(", "ins", "cls2", ":", "$", "R3", ",", "cls2", ":", "$", "R2", ")", ",", "mnemonic", "#", "<STR_LIT>", ",", "[", "(", "set", "cls1", ":", "$", "R1", ",", "(", "operator", "cls2", ":", "$", "R3", ",", "cls2", ":", "$", "R2", ")", ")", "]", ">", "{", "let", "OpKey", "=", "mnemonic", "#" ]

[ "<FIXS>", "emitSIBByte", "(", "SS", ",", "IndexRegNo", ",", "<NUM_LIT>", ",", "OS", ")", ";", "<FIXE>", "<FIXS>", "emitSIBByte", "(", "SS", ",", "IndexRegNo", ",", "getX86RegNum", "(", "Base", ")", ",", "OS", ")", ";", "<FIXE>", "<FIXS>", "emitImmediate", "(", "Disp", ",", "MI", ".", "getLoc", "(", ")", ",", "<NUM_LIT>", ",", "FK_Data_1", ",", "StartByte", ",", "OS", ",", "Fixups", ",", "<FIXE>", "<FIXS>", "StartByte", ",", "OS", ",", "Fixups", ")", ";", "<FIXE>", "<FIXS>", "bool", "X86MCCodeEmitter", "::", "emitPrefixImpl", "(", "unsigned", "&", "CurOp", ",", "const", "MCInst", "&", "MI", ",", "<FIXE>" ]

[ "IndexRegNo", "=", "getX86RegNum", "(", "IndexReg", ")", ";", "else", "IndexRegNo", "=", "<NUM_LIT>", ";", "<BUGS>", "emitSIBByte", "(", "SS", ",", "IndexRegNo", ",", "<NUM_LIT>", ",", "CurByte", ",", "OS", ")", ";", "<BUGE>", "}", "else", "{", "unsigned", "IndexRegNo", ";", "if", "(", "IndexReg", ".", "getReg", "(", ")", ")", "IndexRegNo", "=", "getX86RegNum", "(", "IndexReg", ")", ";", "elseIndexRegNo", "=", "<NUM_LIT>", ";", "<BUGS>", "emitSIBByte", "(", "SS", ",", "IndexRegNo", ",", "getX86RegNum", "(", "Base", ")", ",", "CurByte", ",", "OS", ")", ";", "<BUGE>", "}", "if", "(", "ForceDisp8", ")", "<BUGS>", "emitImmediate", "(", "Disp", ",", "MI", ".", "getLoc", "(", ")", ",", "<NUM_LIT>", ",", "FK_Data_1", ",", "CurByte", ",", "OS", ",", "Fixups", ",", "<BUGE>", "ImmOffset", ")", ";", "else", "if", "(", "ForceDisp32", "||", "Disp", ".", "getImm", "(", ")", "!=", "<NUM_LIT>", ")", "emitImmediate", "(", "Disp", ",", "MI", ".", "getLoc", "(", ")", ",", "<NUM_LIT>", ",", "MCFixupKind", "(", "X86", "::", "reloc_signed_4byte", ")", ",", "<BUGS>", "CurByte", ",", "OS", ",", "Fixups", ")", ";", "<BUGE>", "}", "<BUGS>", "bool", "X86MCCodeEmitter", "::", "emitPrefixImpl", "(", "unsigned", "&", "CurOp", ",", "unsigned", "&", "CurByte", ",", "const", "MCInst", "&", "MI", ",", "<BUGE>", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "OS", ")", "const", "{", "uint64_t", "TSFlags", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ".", "TSFlags", ";" ]

[ "<FIXS>", "(", "define_insn", "<STR_LIT>", "<FIXE>", "<FIXS>", "(", "unspec", ":", "V8SI", "[", "(", "match_operand", ":", "V8DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_FIX_NOTRUNC", ")", ")", "]", "<FIXE>", "<FIXS>", "<STR_LIT>", "<FIXE>" ]

[ "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGS>", "(", "define_insn", "<STR_LIT>", "<BUGE>", "[", "(", "set", "(", "match_operand", ":", "V8SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "unspec", ":", "V8SI", "[", "(", "match_operand", ":", "V8DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_FIX_NOTRUNC", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "MVT", "::", "Flag", ")", ";" ]

[ "bool", "addTest", "=", "true", ";", "SDValue", "Cond", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "DebugLoc", "dl", "=", "Op", ".", "getDebugLoc", "(", ")", ";", "SDValue", "CC", ";", "if", "(", "Cond", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SETCC", ")", "{", "SDValue", "NewCond", "=", "LowerSETCC", "(", "Cond", ",", "DAG", ")", ";", "if", "(", "NewCond", ".", "getNode", "(", ")", ")", "Cond", "=", "NewCond", ";", "}", "SDValue", "Op1", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Op2", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Cond", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "cast", "<", "ConstantSDNode", ">", "(", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", "==", "X86", "::", "COND_E", ")", "{", "SDValue", "Cmp", "=", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Cmp", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "ConstantSDNode", "*", "N1C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op1", ")", ";", "ConstantSDNode", "*", "N2C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op2", ")", ";", "ConstantSDNode", "*", "RHSC", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Cmp", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ")", ";", "if", "(", "N1C", "&&", "N1C", "->", "isAllOnesValue", "(", ")", "&&", "N2C", "&&", "N2C", "->", "isNullValue", "(", ")", "&&", "RHSC", "&&", "RHSC", "->", "isNullValue", "(", ")", ")", "{", "SDValue", "CmpOp0", "=", "Cmp", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "Cmp", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "CmpOp0", ".", "getValueType", "(", ")", ",", "CmpOp0", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "CmpOp0", ".", "getValueType", "(", ")", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ",", "DAG", ".", "getConstant", "(", "X86", "::", "COND_B", ",", "MVT", "::", "i8", ")", ",", "Cmp", ")", ";", "}", "}", "}", "if", "(", "Cond", ".", "getOpcode", "(", ")", "==", "ISD", "::", "AND", "&&", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "C", "&&", "C", "->", "getAPIntValue", "(", ")", "==", "<NUM_LIT>", ")", "Cond", "=", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "}", "if", "(", "Cond", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Cond", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "CC", "=", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Cmp", "=", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "unsigned", "Opc", "=", "Cmp", ".", "getOpcode", "(", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "bool", "IllegalFPCMov", "=", "false", ";", "if", "(", "VT", ".", "isFloatingPoint", "(", ")", "&&", "!", "VT", ".", "isVector", "(", ")", "&&", "!", "isScalarFPTypeInSSEReg", "(", "VT", ")", ")", "IllegalFPCMov", "=", "!", "hasFPCMov", "(", "cast", "<", "ConstantSDNode", ">", "(", "CC", ")", "->", "getSExtValue", "(", ")", ")", ";", "if", "(", "(", "isX86LogicalCmp", "(", "Cmp", ")", "&&", "!", "IllegalFPCMov", ")", "||", "Opc", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "Cond", "=", "Cmp", ";", "addTest", "=", "false", ";", "}", "}", "if", "(", "addTest", ")", "{", "if", "(", "Cond", ".", "getOpcode", "(", ")", "==", "ISD", "::", "TRUNCATE", ")", "Cond", "=", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Cond", ".", "getOpcode", "(", ")", "==", "ISD", "::", "AND", "&&", "Cond", ".", "hasOneUse", "(", ")", ")", "{", "SDValue", "NewSetCC", "=", "LowerToBT", "(", "Cond", ",", "ISD", "::", "SETNE", ",", "dl", ",", "DAG", ")", ";", "if", "(", "NewSetCC", ".", "getNode", "(", ")", ")", "{", "CC", "=", "NewSetCC", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "Cond", "=", "NewSetCC", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "addTest", "=", "false", ";", "}", "}", "}", "if", "(", "addTest", ")", "{", "CC", "=", "DAG", ".", "getConstant", "(", "X86", "::", "COND_NE", ",", "MVT", "::", "i8", ")", ";", "Cond", "=", "EmitTest", "(", "Cond", ",", "X86", "::", "COND_NE", ",", "DAG", ")", ";", "}", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "Op", ".", "getValueType", "(", ")", "," ]

[ "(", "_", "_", "mmask8", ")", "_", "_", "B", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "mmask16", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "kshiftri_mask16", "(", "_", "_", "mmask16", "_", "_", "A", ",", "unsigned", "int", "_", "_", "B", ")", "{", "return", "(", "_", "_", "mmask16", ")", "_", "_", "builtin_ia32_kshiftrihi", "(", "(", "_", "_", "mmask16", ")", "_", "_", "A", "," ]

[ ")" ]

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

[ "<STR_LIT>" ]

[ "<STR_LIT>", ")", "]", ")", "(", "pc", ")", "(", "label_ref", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "(", "clobber", "(", "reg", ":", "BI", "CARRY_REG", ")", ")", "]", "<STR_LIT>" ]

[ "const", "char", "*", "AVRTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "\\", "return", "#", "name", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "nullptr", ";", "NODE", "(", "RET_GLUE", ")", ";", "NODE", "(", "RETI_GLUE", ")", ";", "NODE", "(", "CALL", ")", ";", "NODE", "(", "WRAPPER", ")", ";", "NODE", "(", "LSL", ")", ";", "NODE", "(", "LSLW", ")", ";", "NODE", "(", "LSR", ")", ";", "NODE", "(", "LSRW", ")", ";", "NODE", "(", "ROL", ")", ";", "NODE", "(", "ROR", ")", ";", "NODE", "(", "ASR", ")", ";", "NODE", "(", "ASRW", ")", ";", "NODE", "(", "LSLLOOP", ")", ";", "NODE", "(", "LSRLOOP", ")", ";", "NODE", "(", "ROLLOOP", ")", ";", "NODE", "(", "RORLOOP", ")", ";", "NODE", "(", "ASRLOOP", ")", ";", "NODE", "(", "BRCOND", ")", ";", "NODE", "(", "CMP", ")", ";", "NODE", "(", "CMPC", ")", ";", "NODE", "(", "TST", ")", ";", "NODE", "(", "SELECT_CC", ")", ";", "}" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ ")", ";" ]

[ "if", "(", "!", "isOpcWithIntImmediate", "(", "Op0", ".", "getNode", "(", ")", ",", "ISD", "::", "AND", ",", "AndImm", ")", ")", "return", "false", ";", "const", "uint64_t", "ShiftedAndImm", "=", "(", "(", "AndImm", "<<", "ShlImm", ")", ">>", "ShlImm", ")", ";", "if", "(", "isMask_64", "(", "ShiftedAndImm", ")", ")", "{", "Width", "=", "llvm", "::", "countr_one", "(", "ShiftedAndImm" ]

[ "return", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", ";" ]

[ "bool", "ARMBaseRegisterInfo", "::", "cannotEliminateFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "NoFramePointerElim", "&&", "MFI", "->", "hasCalls", "(", ")", ")", "return", "true", ";" ]

[ "CurDAG", "->", "RemoveDeadNode", "(", "ST", ")", ";" ]

[ "SDValue", "To", "[", "<NUM_LIT>", "]", ";", "if", "(", "IsValidInc", ")", "{", "SDValue", "Ops", "[", "]", "=", "{", "Base", ",", "IncV", ",", "Value", ",", "Chain", "}", ";", "MachineSDNode", "*", "S", "=", "CurDAG", "->", "getMachineNode", "(", "Opcode", ",", "dl", ",", "MVT", "::", "i32", ",", "MVT", "::", "Other", ",", "Ops", ")", ";", "CurDAG", "->", "setNodeMemRefs", "(", "S", ",", "{", "MemOp", "}", ")", ";", "To", "[", "<NUM_LIT>", "]", "=", "SDValue", "(", "S", ",", "<NUM_LIT>", ")", ";", "To", "[", "<NUM_LIT>", "]", "=", "SDValue", "(", "S", ",", "<NUM_LIT>", ")", ";", "}", "else", "{", "SDValue", "Zero", "=", "CurDAG", "->", "getTargetConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "Base", ",", "Zero", ",", "Value", ",", "Chain", "}", ";", "MachineSDNode", "*", "S", "=", "CurDAG", "->", "getMachineNode", "(", "Opcode", ",", "dl", ",", "MVT", "::", "Other", ",", "Ops", ")", ";", "CurDAG", "->", "setNodeMemRefs", "(", "S", ",", "{", "MemOp", "}", ")", ";", "To", "[", "<NUM_LIT>", "]", "=", "SDValue", "(", "S", ",", "<NUM_LIT>", ")", ";", "MachineSDNode", "*", "A", "=", "CurDAG", "->", "getMachineNode", "(", "Hexagon", "::", "A2_addi", ",", "dl", ",", "MVT", "::", "i32", ",", "Base", ",", "IncV", ")", ";", "To", "[", "<NUM_LIT>", "]", "=", "SDValue", "(", "A", ",", "<NUM_LIT>", ")", ";", "}", "ReplaceUses", "(", "From", ",", "To", ",", "<NUM_LIT>", ")", ";" ]

[ "SDValue", "VPermMask", "[", "<NUM_LIT>", "]", ";" ]

[ "assert", "(", "Subtarget", "->", "hasAVX2", "(", ")", "&&", "<STR_LIT>", "We can only lower v8i32 with AVX2!", "<STR_LIT>", ")", ";", "if", "(", "SDValue", "ZExt", "=", "lowerVectorShuffleAsZeroOrAnyExtend", "(", "DL", ",", "MVT", "::", "v8i32", ",", "V1", ",", "V2", ",", "Mask", ",", "Subtarget", ",", "DAG", ")", ")", "return", "ZExt", ";", "if", "(", "SDValue", "Blend", "=", "lowerVectorShuffleAsBlend", "(", "DL", ",", "MVT", "::", "v8i32", ",", "V1", ",", "V2", ",", "Mask", ",", "Subtarget", ",", "DAG", ")", ")", "return", "Blend", ";", "if", "(", "SDValue", "Broadcast", "=", "lowerVectorShuffleAsBroadcast", "(", "DL", ",", "MVT", "::", "v8i32", ",", "V1", ",", "Mask", ",", "Subtarget", ",", "DAG", ")", ")", "return", "Broadcast", ";", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "RepeatedMask", ";", "if", "(", "is128BitLaneRepeatedShuffleMask", "(", "MVT", "::", "v8i32", ",", "Mask", ",", "RepeatedMask", ")", ")", "{", "assert", "(", "RepeatedMask", ".", "size", "(", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Unexpected repeated mask size!", "<STR_LIT>", ")", ";", "if", "(", "isSingleInputShuffleMask", "(", "Mask", ")", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "v8i32", ",", "V1", ",", "getV4X86ShuffleImm8ForMask", "(", "RepeatedMask", ",", "DL", ",", "DAG", ")", ")", ";", "if", "(", "isShuffleEquivalent", "(", "V1", ",", "V2", ",", "Mask", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "v8i32", ",", "V1", ",", "V2", ")", ";", "if", "(", "isShuffleEquivalent", "(", "V1", ",", "V2", ",", "Mask", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "v8i32", ",", "V1", ",", "V2", ")", ";", "if", "(", "isShuffleEquivalent", "(", "V1", ",", "V2", ",", "Mask", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "v8i32", ",", "V2", ",", "V1", ")", ";", "if", "(", "isShuffleEquivalent", "(", "V1", ",", "V2", ",", "Mask", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "v8i32", ",", "V2", ",", "V1", ")", ";", "}", "if", "(", "SDValue", "Shift", "=", "lowerVectorShuffleAsShift", "(", "DL", ",", "MVT", "::", "v8i32", ",", "V1", ",", "V2", ",", "Mask", ",", "DAG", ")", ")", "return", "Shift", ";", "if", "(", "SDValue", "Rotate", "=", "lowerVectorShuffleAsByteRotate", "(", "DL", ",", "MVT", "::", "v8i32", ",", "V1", ",", "V2", ",", "Mask", ",", "Subtarget", ",", "DAG", ")", ")", "return", "Rotate", ";", "if", "(", "isSingleInputShuffleMask", "(", "Mask", ")", ")", "{" ]

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

[ "Register", "scopeReg", ";", "auto", "scope", "=", "Scope", "::", "Workgroup", ";", "if", "(", "OrigArgs", ".", "size", "(", ")", ">=", "<NUM_LIT>", ")", "{", "assert", "(", "OrigArgs", ".", "size", "(", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Extra args for explicit atomic RMW", "<STR_LIT>", ")", ";", "auto", "clScope", "=", "static_cast", "<", "CLMemScope", ">", "(", "getIConstVal", "(", "OrigArgs", "[", "<NUM_LIT>", "]", ",", "MRI", ")", ")", ";", "scope", "=", "getSPIRVScope", "(", "clScope", ")", ";", "if", "(", "clScope", "==", "static_cast", "<", "unsigned", ">", "(", "scope", ")", ")", "scopeReg", "=", "OrigArgs", "[", "<NUM_LIT>", "]", ";", "}", "if", "(", "!", "scopeReg", ".", "isValid", "(", ")", ")", "scopeReg", "=", "GR", "->", "buildConstantInt", "(", "scope", ",", "MIRBuilder", ",", "I32Ty", ")", ";", "auto", "ptr", "=", "OrigArgs", "[", "<NUM_LIT>", "]", ";", "auto", "scSem", "=", "getMemSemanticsForStorageClass", "(", "GR", "->", "getPointerStorageClass", "(", "ptr", ")", ")", ";", "Register", "memSemReg", ";", "unsigned", "memSem", "=", "MemorySemantics", "::", "None", ";", "if", "(", "OrigArgs", ".", "size", "(", ")", ">=", "<NUM_LIT>", ")", "{", "auto", "memOrd", "=", "static_cast", "<", "CLMemOrder", ">", "(", "getIConstVal", "(", "OrigArgs", "[", "<NUM_LIT>", "]", ",", "MRI", ")", ")", ";", "memSem", "=", "getSPIRVMemSemantics", "(", "memOrd", ")", "|", "scSem", ";", "if", "(", "memOrd", "==", "memSem", ")", "memSemReg", "=", "OrigArgs", "[" ]

[ "}" ]

[ "rs6000_sched_context_t", "sc", "=", "(", "rs6000_sched_context_t", ")", "_", "sc", ";", "if", "(", "clean_p", ")", "{", "sc", "->", "cached_can_issue_more", "=", "<NUM_LIT>", ";", "sc", "->", "last_scheduled_insn", "=", "NULL", ";", "sc", "->", "load_store_pendulum", "=", "<NUM_LIT>", ";", "sc", "->", "divide_cnt", "=", "<NUM_LIT>", ";", "sc", "->", "vec_pairing", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "if", "(", "ForcedVEXEncoding", "!=", "VEXEncoding_VEX3", "&&", "X86", "::", "optimizeInstFromVEX3ToVEX2", "(", "Inst", ",", "MII", ".", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ")", ")", "return", "true", ";", "if", "(", "X86", "::", "optimizeShiftRotateWithImmediateOne", "(", "Inst", ")", ")", "return", "true", ";", "<FIXE>" ]

[ "}", "bool", "X86AsmParser", "::", "processInstruction", "(", "MCInst", "&", "Inst", ",", "const", "OperandVector", "&", "Ops", ")", "{", "<BUGS>", "const", "MCRegisterInfo", "*", "MRI", "=", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "<BUGE>", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";" ]

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

[ "let", "Pattern", "=", "pattern", ";", "bits", "<", "<NUM_LIT>", ">", "LI", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "LI", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "aa", ";" ]

[ ")", ")" ]

[ "(", "define_constraint", "<STR_LIT>", "<STR_LIT>", "(", "and", "(", "match_code", "<STR_LIT>", ")", "(", "match_test", "<STR_LIT>", ")" ]

[ ")" ]

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

[ "ashiftrt", "lshiftrt", "]", ")" ]

[ "(", "define_code_iterator", "any_shift", "[", "ashift" ]

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

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

[ ",", "stream", ")", ";" ]

[ "fputc", "(", "'", "\\n", "'" ]

[ "MCSubtargetInfo", "&", "SubtargetInfo", ")", "const", "{" ]

[ "unsigned", "MMIXMCCodeEmitter", "::", "getMHWydeOpValue", "(", "const", "MCInst", "&", "Inst", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const" ]

[ "<STR_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zm", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Pg", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zda", ";", "let", "Constraints", "=" ]

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

[ "(", "unspec", ":", "SI", "[", "(", "match_operand", ":", "BLK", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "isCompare", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

[ "let", "Defs", "=", "[", "USR_OVF", "]", ";" ]

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

[ "}" ]

[ "def", "TLSDESCCALL", ":", "Pseudo", "<", "(", "outs", ")", ",", "(", "ins", "i64imm", ":", "$", "sym", ")", ",", "[", "]", ">", ",", "Sched", "<", "[", "]", ">", "{", "let", "AsmString", "=", "<STR_LIT>", ";" ]

[ "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "]" ]

[ "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "truncate", ":", "DI", "(", "lshiftrt", ":", "TI", "(", "plus", ":", "TI", "(", "zero_extend", ":", "TI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "zero_extend", ":", "TI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")" ]

[ "let", "Uses", "=", "[", "USR", "]", ";" ]

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

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

[ "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps" ]

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

[ "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "-", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "emit_insn", "(", "gen_ashldi3_media", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "DONE", "}", "emit_insn", "(", "gen_ashrdi3_media", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]" ]

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

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

[ "<FIXS>", "ia64_invalid_binary_op", "(", "int", "op", "ATTRIBUTE_UNUSED", ",", "const_tree", "type1", ",", "const_tree", "type2", ")", "<FIXE>" ]

[ "static", "const", "char", "*", "<BUGS>", "ia64_invalid_binary_op", "(", "int", "op", "ATTRIBUTE_UNUSED", ",", "tree", "type1", ",", "tree", "type2", ")", "<BUGE>", "{", "if", "(", "TYPE_MODE", "(", "type1", ")", "==", "RFmode", "||", "TYPE_MODE", "(", "type2", ")", "==", "RFmode", ")" ]

[ "emit_insn", "(", "gen_iorsi3", "(", "target", ",", "popcnt", ",", "tmp_reg_ca", ")", ")", ";" ]

[ "rtx", "tmp_reg_ca", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "emit_insn", "(", "gen_subfdi3_carry_in_xx", "(", "tmp_reg_ca", ")", ")", ";", "rtx", "popcnt", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "emit_insn", "(", "gen_popcntddi2", "(", "popcnt", ",", "sub_result", ")", ")", ";", "rtx", "tmp2", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "emit_insn", "(", "gen_iordi3", "(", "tmp2", ",", "popcnt", ",", "tmp_reg_ca", ")", ")", ";", "emit_insn", "(", "gen_movsi", "(", "target", ",", "gen_lowpart", "(", "SImode", ",", "tmp2", ")", ")", ")", ";", "}", "else", "{", "rtx", "tmp_reg_ca", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_subfsi3_carry_in_xx", "(", "tmp_reg_ca", ")", ")", ";", "rtx", "popcnt", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_popcntdsi2", "(", "popcnt", ",", "sub_result", ")", ")", ";" ]

[ "let", "opNewValue", "=", "<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>", ";" ]

[ "}" ]

[ "else", "return", "false", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "if", "(", "!", "flag_finite_math_only", "||", "flag_signed_zeros", ")", "{", "int", "u", "=", "is_min", "?", "UNSPEC_IEEE_MIN", ":", "UNSPEC_IEEE_MAX", ";", "rtvec", "v", ";", "if_true", "=", "force_reg", "(", "mode", ",", "if_true", ")", ";", "v", "=", "gen_rtvec", "(", "<NUM_LIT>", ",", "if_true", ",", "if_false", ")", ";", "tmp", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "v", ",", "u", ")", ";", "}", "else", "{", "code", "=", "is_min", "?", "SMIN", ":", "SMAX", ";", "if", "(", "MEM_P", "(", "if_true", ")", "&&", "MEM_P", "(", "if_false", ")", ")", "if_true", "=", "force_reg", "(", "mode", ",", "if_true", ")", ";", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "if_true", ",", "if_false", ")", ";" ]

[ "}" ]

[ "rewriteRegionExitPHIs", "(", "Region", ",", "LastMerge", ",", "LRegion", ")", ";", "removeOldExitPreds", "(", "Region", ")", ";", "LLVM_DEBUG", "(", "PHIInfo", ".", "dump", "(", "MRI", ")", ")", ";", "SetVector", "<", "MRT", "*", ">", "*", "Children", "=", "Region", "->", "getChildren", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "===========If Region Start===============\\n", "<STR_LIT>", ")", ";", "if", "(", "LRegion", "->", "getHasLoop", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Has Backedge: Yes\\n", "<STR_LIT>", ")", ";", "}", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Has Backedge: No\\n", "<STR_LIT>", ")", ";", "}", "unsigned", "BBSelectRegIn", ";", "unsigned", "BBSelectRegOut", ";", "for", "(", "MRT", "*", "Child", ":", "*", "Children", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "CurrentRegion: \\n", "<STR_LIT>", ")", ";", "LLVM_DEBUG", "(", "LRegion", "->", "print", "(", "dbgs", "(", ")", ",", "TRI", ")", ")", ";", "if", "(", "Child", "->", "isRegion", "(", ")", ")", "{", "LinearizedRegion", "*", "InnerLRegion", "=", "Child", "->", "getRegionMRT", "(", ")", "->", "getLinearizedRegion", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Linearizing region: ", "<STR_LIT>", ")", ";", "LLVM_DEBUG", "(", "InnerLRegion", "->", "print", "(", "dbgs", "(", ")", ",", "TRI", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "MachineBasicBlock", "*", "InnerEntry", "=", "InnerLRegion", "->", "getEntry", "(", ")", ";", "if", "(", "(", "&", "(", "*", "(", "InnerEntry", "->", "getParent", "(", ")", "->", "begin", "(", ")", ")", ")", ")", "==", "InnerEntry", ")", "{", "unsigned", "OuterSelect", "=", "InnerLRegion", "->", "getBBSelectRegOut", "(", ")", ";", "unsigned", "InnerSelectReg", "=", "InnerLRegion", "->", "getRegionMRT", "(", ")", "->", "getInnerOutputRegister", "(", ")", ";", "replaceRegisterWith", "(", "InnerSelectReg", ",", "OuterSelect", ")", ",", "resolvePHIInfos", "(", "InnerEntry", ")", ";", "if", "(", "!", "InnerLRegion", "->", "getExit", "(", ")", "->", "isSuccessor", "(", "CurrentMerge", ")", ")", "InnerLRegion", "->", "getExit", "(", ")", "->", "addSuccessor", "(", "CurrentMerge", ")", ";", "continue", ";", "}", "BBSelectRegOut", "=", "Child", "->", "getBBSelectRegOut", "(", ")", ";", "BBSelectRegIn", "=", "Child", "->", "getBBSelectRegIn", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "BBSelectRegIn: ", "<STR_LIT>", "<<", "printReg", "(", "BBSelectRegIn", ",", "TRI", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "BBSelectRegOut: ", "<STR_LIT>", "<<", "printReg", "(", "BBSelectRegOut", ",", "TRI", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "MachineBasicBlock", "*", "IfEnd", "=", "CurrentMerge", ";", "CurrentMerge", "=", "createIfRegion", "(", "CurrentMerge", ",", "InnerLRegion", ",", "LRegion", ",", "Child", "->", "getRegionMRT", "(", ")", "->", "getEntry", "(", ")", ",", "BBSelectRegIn", ",", "BBSelectRegOut", ")", ";", "TII", "->", "convertNonUniformIfRegion", "(", "CurrentMerge", ",", "IfEnd", ")", ";", "}", "else", "{", "MachineBasicBlock", "*", "MBB", "=", "Child", "->", "getMBBMRT", "(", ")", "->", "getMBB", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Linearizing block: ", "<STR_LIT>", "<<", "MBB", "->", "getNumber", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "if", "(", "MBB", "==", "getSingleExitNode", "(", "*", "(", "MBB", "->", "getParent", "(", ")", ")", ")", ")", "{", "continue", ";", "}", "BBSelectRegOut", "=", "Child", "->", "getBBSelectRegOut", "(", ")", ";", "BBSelectRegIn", "=", "Child", "->", "getBBSelectRegIn", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "BBSelectRegIn: ", "<STR_LIT>", "<<", "printReg", "(", "BBSelectRegIn", ",", "TRI", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "BBSelectRegOut: ", "<STR_LIT>", "<<", "printReg", "(", "BBSelectRegOut", ",", "TRI", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "MachineBasicBlock", "*", "IfEnd", "=", "CurrentMerge", ";", "CurrentMerge", "=", "createIfRegion", "(", "CurrentMerge", ",", "MBB", ",", "LRegion", ",", "BBSelectRegIn", ",", "BBSelectRegOut", ")", ";", "if", "(", "CurrentMerge", ")", "{", "TII", "->", "convertNonUniformIfRegion", "(", "CurrentMerge", ",", "IfEnd", ")", ";", "}", "LLVM_DEBUG", "(", "PHIInfo", ".", "dump", "(", "MRI", ")", ")", ";", "}", "}", "LRegion", "->", "removeFalseRegisterKills", "(", "MRI", ")", ";", "if", "(", "LRegion", "->", "getHasLoop", "(", ")", ")", "{", "MachineBasicBlock", "*", "NewSucc", "=", "splitEntry", "(", "LRegion", ")", ";", "if", "(", "isFunctionEntryBlock", "(", "LRegion", "->", "getEntry", "(", ")", ")", ")", "{", "resolvePHIInfos", "(", "LRegion", "->", "getEntry", "(", ")", ")", ";", "}", "const", "DebugLoc", "&", "DL", "=", "NewSucc", "->", "findDebugLoc", "(", "NewSucc", "->", "getFirstNonPHI", "(", ")", ")", ";", "unsigned", "InReg", "=", "LRegion", "->", "getBBSelectRegIn", "(", ")", ";", "Register", "InnerSelectReg", "=", "MRI", "->", "createVirtualRegister", "(", "MRI", "->", "getRegClass", "(", "InReg", ")", ")", ";", "Register", "NewInReg", "=", "MRI", "->", "createVirtualRegister", "(", "MRI", "->", "getRegClass", "(", "InReg", ")", ")", ";", "TII", "->", "materializeImmediate", "(", "*", "(", "LRegion", "->", "getEntry", "(", ")", ")", ",", "LRegion", "->", "getEntry", "(", ")", "->", "getFirstTerminator", "(", ")", ",", "DL", ",", "NewInReg", ",", "Region", "->", "getEntry", "(", ")", "->", "getNumber", "(", ")", ")", ";", "LRegion", "->", "replaceRegisterInsideRegion", "(", "InReg", ",", "InnerSelectReg", ",", "false", ",", "MRI", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Loop BBSelect Merge PHI:\\n", "<STR_LIT>", ")", ";", "insertMergePHI", "(", "LRegion", "->", "getEntry", "(", ")", ",", "LRegion", "->", "getExit", "(", ")", ",", "NewSucc", ",", "InnerSelectReg", ",", "NewInReg", ",", "LRegion", "->", "getRegionMRT", "(", ")", "->", "getInnerOutputRegister", "(", ")", ")", ";", "splitExit", "(", "LRegion", ")", ";", "TII", "->", "convertNonUniformLoopRegion", "(", "NewSucc", ",", "LastMerge", ")", ";", "}", "if", "(", "Region", "->", "isRoot", "(", ")", ")", "{", "TII", "->", "insertReturn", "(", "*", "LastMerge", ")", ";", "}", "LLVM_DEBUG", "(", "Region", "->", "getEntry", "(", ")", "->", "getParent", "(", ")", "->", "dump", "(", ")", ")", ";", "LLVM_DEBUG", "(", "LRegion", "->", "print", "(", "dbgs", "(", ")", ",", "TRI", ")", ")", ";", "LLVM_DEBUG", "(", "PHIInfo", ".", "dump", "(", "MRI", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "===========If Region End===============\\n", "<STR_LIT>", ")", ";", "Region", "->", "setLinearizedRegion", "(", "LRegion", ")", ";", "return", "true", ";" ]

[ "<FIXS>", "bool", "dest_gpr_p", ",", "dest_fp_p", ",", "dest_vmx_p", ",", "dest_vsx_p", ";", "bool", "src_gpr_p", ",", "src_fp_p", ",", "src_vmx_p", ",", "src_vsx_p", ";", "<FIXE>", "<FIXS>", "dest_vmx_p", "=", "ALTIVEC_REGNO_P", "(", "dest_regno", ")", ";", "dest_vsx_p", "=", "dest_fp_p", "|", "dest_vmx_p", ";", "<FIXE>", "<FIXS>", "dest_gpr_p", "=", "dest_fp_p", "=", "dest_vmx_p", "=", "dest_vsx_p", "=", "false", ";", "<FIXE>" ]

[ "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "int", "dest_regno", ";", "int", "src_regno", ";", "<BUGS>", "bool", "dest_gpr_p", ",", "dest_fp_p", ",", "dest_av_p", ",", "dest_vsx_p", ";", "bool", "src_gpr_p", ",", "src_fp_p", ",", "src_av_p", ",", "src_vsx_p", ";", "<BUGE>", "if", "(", "REG_P", "(", "dest", ")", ")", "{", "dest_regno", "=", "REGNO", "(", "dest", ")", ";", "dest_gpr_p", "=", "INT_REGNO_P", "(", "dest_regno", ")", ";", "dest_fp_p", "=", "FP_REGNO_P", "(", "dest_regno", ")", ";", "<BUGS>", "dest_av_p", "=", "ALTIVEC_REGNO_P", "(", "dest_regno", ")", ";", "dest_vsx_p", "=", "dest_fp_p", "|", "dest_av_p", ";", "<BUGE>", "}", "else", "{", "dest_regno", "=", "-", "<NUM_LIT>", ";", "<BUGS>", "dest_gpr_p", "=", "dest_fp_p", "=", "dest_av_p", "=", "dest_vsx_p", "=", "false", ";", "<BUGE>", "}", "if", "(", "REG_P", "(", "src", ")", ")" ]

[ "A", ")", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v4f32", "(", "scalar_to_vector", "f32", ":", "$", "A", ")", ")", ",", "(", "v4f32", "(", "XSCVDPSPN", "$" ]

[ "FI", "->", "setCRSpillFrameIndex", "(", "FrameIdx", ")", ";" ]

[ "unsigned", "LR", "=", "RegInfo", "->", "getRARegister", "(", ")", ";", "FI", "->", "setMustSaveLR", "(", "MustSaveLR", "(", "MF", ",", "LR", ")", ")", ";", "SavedRegs", ".", "reset", "(", "LR", ")", ";", "int", "FPSI", "=", "FI", "->", "getFramePointerSaveIndex", "(", ")", ";", "bool", "isPPC64", "=", "Subtarget", ".", "isPPC64", "(", ")", ";", "bool", "isDarwinABI", "=", "Subtarget", ".", "isDarwinABI", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "!", "FPSI", "&&", "needsFP", "(", "MF", ")", ")", "{", "int", "FPOffset", "=", "getFramePointerSaveOffset", "(", ")", ";", "FPSI", "=", "MFI", "->", "CreateFixedObject", "(", "isPPC64", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ",", "FPOffset", ",", "true", ")", ";", "FI", "->", "setFramePointerSaveIndex", "(", "FPSI", ")", ";", "}", "int", "BPSI", "=", "FI", "->", "getBasePointerSaveIndex", "(", ")", ";", "if", "(", "!", "BPSI", "&&", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "int", "BPOffset", "=", "getBasePointerSaveOffset", "(", ")", ";", "BPSI", "=", "MFI", "->", "CreateFixedObject", "(", "isPPC64", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ",", "BPOffset", ",", "true", ")", ";", "FI", "->", "setBasePointerSaveIndex", "(", "BPSI", ")", ";", "}", "if", "(", "FI", "->", "usesPICBase", "(", ")", ")", "{", "int", "PBPSI", "=", "MFI", "->", "CreateFixedObject", "(", "<NUM_LIT>", ",", "-", "<NUM_LIT>", ",", "true", ")", ";", "FI", "->", "setPICBasePointerSaveIndex", "(", "PBPSI", ")", ";", "}", "int", "TCSPDelta", "=", "<NUM_LIT>", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "GuaranteedTailCallOpt", "&&", "(", "TCSPDelta", "=", "FI", "->", "getTailCallSPDelta", "(", ")", ")", "<", "<NUM_LIT>", ")", "{", "MFI", "->", "CreateFixedObject", "(", "-", "<NUM_LIT>", "*", "TCSPDelta", ",", "TCSPDelta", ",", "true", ")", ";", "}", "if", "(", "!", "isPPC64", "&&", "!", "isDarwinABI", "&&", "(", "SavedRegs", ".", "test", "(", "PPC", "::", "CR2", ")", "||", "SavedRegs", ".", "test", "(", "PPC", "::", "CR3", ")", "||", "SavedRegs", ".", "test", "(", "PPC", "::", "CR4", ")", ")", ")", "{", "int", "FrameIdx", "=", "MFI", "->", "CreateFixedObject", "(", "(", "uint64_t", ")", "<NUM_LIT>", ",", "(", "int64_t", ")", "-", "<NUM_LIT>", ",", "true", ")", ";" ]

[ "shl", ">", ";" ]

[ "def", "LSLI16", ":", "I16_XZ_IMM5", "<", "<NUM_LIT>", ",", "<STR_LIT>", "," ]

[ "unsigned", "SparcRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "}" ]

[ "Debug", "information", "queries", "." ]

[ "bool", "HexagonRDFOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "RDFLimit", ".", "getPosition", "(", ")", ")", "{", "if", "(", "RDFCount", ">=", "RDFLimit", ")", "return", "false", ";", "RDFCount", "++", ";", "}", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "const", "auto", "&", "MDF", "=", "getAnalysis", "<", "MachineDominanceFrontier", ">", "(", ")", ";", "const", "auto", "&", "HII", "=", "*", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "auto", "&", "HRI", "=", "*", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "Changed", ";", "if", "(", "RDFDump", ")", "MF", ".", "print", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Before ", "<STR_LIT>", "<<", "getPassName", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ",", "nullptr", ")", ";", "HexagonRegisterAliasInfo", "HAI", "(", "HRI", ")", ";", "TargetOperandInfo", "TOI", "(", "HII", ")", ";", "DataFlowGraph", "G", "(", "MF", ",", "HII", ",", "HRI", ",", "*", "MDT", ",", "MDF", ",", "HAI", ",", "TOI", ")", ";", "G", ".", "build", "(", ")", ";", "if", "(", "RDFDump", ")", "dbgs", "(", ")", "<<", "<STR_LIT>", "Starting copy propagation on: ", "<STR_LIT>", "<<", "MF", ".", "getName", "(", ")", "<<", "'", "\\n", "'", "<<", "PrintNode", "<", "FuncNode", "*", ">", "(", "G", ".", "getFunc", "(", ")", ",", "G", ")", "<<", "'", "\\n", "'", ";", "HexagonCP", "CP", "(", "G", ")", ";", "CP", ".", "trace", "(", "RDFDump", ")", ";", "Changed", "=", "CP", ".", "run", "(", ")", ";", "if", "(", "RDFDump", ")", "dbgs", "(", ")", "<<", "<STR_LIT>", "Starting dead code elimination on: ", "<STR_LIT>", "<<", "MF", ".", "getName", "(", ")", "<<", "'", "\\n", "'", "<<", "PrintNode", "<", "FuncNode", "*", ">", "(", "G", ".", "getFunc", "(", ")", ",", "G", ")", "<<", "'", "\\n", "'", ";", "HexagonDCE", "DCE", "(", "G", ",", "*", "MRI", ")", ";", "DCE", ".", "trace", "(", "RDFDump", ")", ";", "Changed", "|=", "DCE", ".", "run", "(", ")", ";", "if", "(", "Changed", ")", "{", "if", "(", "RDFDump", ")", "dbgs", "(", ")", "<<", "<STR_LIT>", "Starting liveness recomputation on: ", "<STR_LIT>", "<<", "MF", ".", "getName", "(", ")", "<<", "'", "\\n", "'", ";", "Liveness", "LV", "(", "*", "MRI", ",", "G", ")", ";", "LV", ".", "trace", "(", "RDFDump", ")", ";", "LV", ".", "computeLiveIns", "(", ")", ";", "LV", ".", "resetLiveIns", "(", ")", ";", "LV", ".", "resetKills", "(", ")", ";", "}", "if", "(", "RDFDump", ")", "MF", ".", "print", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "After ", "<STR_LIT>", "<<", "getPassName", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ",", "nullptr", ")", ";", "return", "false", ";", "}" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ ",", "<STR_LIT>", ",", "[", "(", "set", "i16", ":", "$", "rd", ",", "imm", ":", "$", "k", ")", "]", ">", ";" ]

[ "def", "LDIRdK", ":", "FRdK", "<", "<NUM_LIT>", ",", "(", "outs", "MainRegs", ":", "$", "rd", ")", ",", "(", "ins", "imm_ldi16", ":", "$", "k", ")" ]

[ "}", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "bits", "<", "<NUM_LIT>", ">", "ext", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "isSub", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "setFlags", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "ext", "{", "<NUM_LIT>" ]

[ "case", "ISD", "::", "INLINEASM", ":" ]

[ "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SDIVREM", ":", "case", "ISD", "::", "UDIVREM", ":", "return", "LowerDivRem", "(", "Op", ",", "DAG", ")", ";" ]

[ "}" ]

[ "MachineRegisterInfo", "&", "RegInfo", "=", "MF", "->", "getRegInfo", "(", ")", ";", "*", "TLSBaseAddrReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "MachineInstr", "*", "Next", "=", "I", "->", "getNextNode", "(", ")", ";", "MachineInstr", "*", "Copy", "=", "BuildMI", "(", "*", "I", "->", "getParent", "(", ")", ",", "Next", ",", "I", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "*", "TLSBaseAddrReg", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "return", "Copy", ";" ]

[ "RegList", ";" ]

[ "case", "RegisterSeq", ":", "RegSeq", "=", "o", ".", "RegSeq", ";", "break", ";", "case", "CPOP", ":", "CPool", "=", "o", ".", "CPool", ";", "break", ";", "case", "Immediate", ":", "Imm", "=", "o", ".", "Imm", ";", "break", ";", "case", "Token", ":", "Tok", "=", "o", ".", "Tok", ";", "break", ";", "case", "RegisterList", ":", "RegList", "=", "o", "." ]

[ "const", "SparcSubtarget", "*", "SparcTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "<STR_LIT>", "target-cpu", "<STR_LIT>", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "<STR_LIT>", "target-features", "<STR_LIT>", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "bool", "softFloat", "=", "F", ".", "hasFnAttribute", "(", "<STR_LIT>", "use-soft-float", "<STR_LIT>", ")", "&&", "F", ".", "getFnAttribute", "(", "<STR_LIT>", "use-soft-float", "<STR_LIT>", ")", ".", "getValueAsString", "(", ")", "==", "<STR_LIT>", "true", "<STR_LIT>", ";", "if", "(", "softFloat", ")", "FS", "+=", "FS", ".", "empty", "(", ")", "?", "<STR_LIT>", "+soft-float", "<STR_LIT>", ":", "<STR_LIT>", ",+soft-float", "<STR_LIT>", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "std", "::", "make_unique", "<", "SparcSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ",", "this", "->", "is64Bit", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "<FIXS>", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "{", "if", "(", "Subtarget", "->", "isPICStyleStub", "(", ")", ")", "O", "<<", "<STR_LIT>", "-\\\"L", "<STR_LIT>", "<<", "getFunctionNumber", "(", ")", "<<", "<STR_LIT>", "$pb\\\"", "<STR_LIT>", ";", "else", "if", "(", "Subtarget", "->", "isPICStyleGOT", "(", ")", ")", "O", "<<", "<STR_LIT>", "@GOTOFF", "<STR_LIT>", ";", "}", "<FIXE>" ]

[ "if", "(", "!", "isMemOp", ")", "O", "<<", "'", "$", "'", ";", "O", "<<", "TAI", "->", "getPrivateGlobalPrefix", "(", ")", "<<", "<STR_LIT>", "JTI", "<STR_LIT>", "<<", "getFunctionNumber", "(", ")", "<<", "<STR_LIT>", "_", "<STR_LIT>", "<<", "MO", ".", "getJumpTableIndex", "(", ")", ";", "<BUGS>", "if", "(", "X86PICStyle", "==", "PICStyle", "::", "Stub", "&&", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "O", "<<", "<STR_LIT>", "-\\\"L", "<STR_LIT>", "<<", "getFunctionNumber", "(", ")", "<<", "<STR_LIT>", "$pb\\\"", "<STR_LIT>", ";", "<BUGE>", "if", "(", "isMemOp", "&&", "Subtarget", "->", "is64Bit", "(", ")", "&&", "!", "NotRIPRel", ")", "O", "<<", "<STR_LIT>", "(%rip)", "<STR_LIT>", ";", "return", ";" ]

[ "}" ]

[ "vfmlslq_high_f16", "(", "float32x4_t", "_", "_", "r", ",", "float16x8_t", "_", "_", "a", ",", "float16x8_t", "_", "_", "b", ")", "{", "return", "_", "_", "builtin_neon_vfmsl_highv4sf", "(", "_", "_", "r", ",", "_", "_", "a", ",", "_", "_", "b", ")", ";" ]

[ ")", ";" ]

[ "SDLoc", "DL", "(", "N", ")", ";", "EVT", "ResultVT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "SDValue", "CastedArg", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "EVT", "CastedVT", "=", "CastedArg", ".", "getValueType", "(", ")", ";", "if", "(", "CastedArg", ".", "getOpcode", "(", ")", "==", "ISD", "::", "EXTRACT_VECTOR_ELT", "&&", "CastedVT", ".", "isInteger", "(", ")", "&&", "CastedVT", ".", "getSizeInBits", "(", ")", "==", "<NUM_LIT>", ")", "{", "SDValue", "VectorArg", "=", "CastedArg", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "uint64_t", "EltNo", "=", "CastedArg", ".", "getNode", "(", ")", "->", "getConstantOperandVal", "(", "<NUM_LIT>", ")", ";", "if", "(", "VectorArg", ".", "getOpcode", "(", ")", "==", "ISD", "::", "BITCAST", ")", "{", "SDValue", "OrigArg", "=", "VectorArg", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "EVT", "OrigType", "=", "OrigArg", ".", "getValueType", "(", ")", ";", "assert", "(", "OrigType", ".", "getSizeInBits", "(", ")", "==", "<NUM_LIT>", ")", ";", "EVT", "ResultType", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "OrigType", ".", "getVectorElementType", "(", ")", ",", "OrigType", ".", "getVectorNumElements", "(", ")", "/", "<NUM_LIT>", ")", ";", "SDValue", "SubRegNo", "=", "DAG", ".", "getConstant", "(", "EltNo", "*", "ResultType", ".", "getVectorNumElements", "(", ")", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "SDValue", "ExtrSubV", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "DL", ",", "ResultType", ",", "OrigArg", ",", "SubRegNo", ")", ";", "if", "(", "ResultType", "==", "ResultVT", ")", "return", "ExtrSubV", ";", "SDValue", "Result", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "ResultVT", ",", "ExtrSubV", ")", ";", "return", "Result", ";", "}", "}", "return", "SDValue", "(" ]

[ "void", "ARMAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "MCContext", "&", "Ctx", "=", "Asm", ".", "getContext", "(", ")", ";", "Value", "=", "adjustFixupValue", "(", "Asm", ",", "Fixup", ",", "Target", ",", "Value", ",", "IsResolved", ",", "Ctx", ",", "STI", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "<STR_LIT>", "Invalid fixup offset!", "<STR_LIT>", ")", ";", "unsigned", "FullSizeBytes", ";", "if", "(", "Endian", "==", "support", "::", "big", ")", "{", "FullSizeBytes", "=", "getFixupKindContainerSizeBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "assert", "(", "(", "Offset", "+", "FullSizeBytes", ")", "<=", "Data", ".", "size", "(", ")", "&&", "<STR_LIT>", "Invalid fixup size!", "<STR_LIT>", ")", ";", "assert", "(", "NumBytes", "<=", "FullSizeBytes", "&&", "<STR_LIT>", "Invalid fixup size!", "<STR_LIT>", ")", ";", "}", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "Endian", "==", "support", "::", "little", "?", "i", ":", "(", "FullSizeBytes", "-", "<NUM_LIT>", "-", "i", ")", ";", "Data", "[", "Offset", "+", "Idx", "]", "|=", "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", "." ]

[ "}" ]

[ "bool", "MipsConstantIslands", "::", "isLongFormOffsetInRange", "(", "unsigned", "UserOffset", ",", "unsigned", "TrialOffset", ",", "const", "CPUser", "&", "U", ")", "{", "return", "isOffsetInRange", "(", "UserOffset", ",", "TrialOffset", ",", "U", ".", "getLongFormMaxDisp", "(", ")", ",", "U", ".", "NegOk", ")", ";" ]

[ ":" ]

[ "if", "(", "ShImm", "==", "<NUM_LIT>", "||", "(", "(", "ShImm", "==", "<NUM_LIT>", "||", "ShImm", "==", "<NUM_LIT>", "||", "ShImm", "==", "<NUM_LIT>", ")", "&&", "<STR_LIT>", "::", "<STR_LIT>", "(", "ShOpVal", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "Latency", "=", "*", "Latency", "-", "<NUM_LIT>", ";", "else", "if", "(", "ShImm", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "::", "<STR_LIT>", "(", "ShOpVal", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "Latency", "=", "*", "Latency", "-", "<NUM_LIT>", ";", "break", ";", "}", "case", "ARM", "::", "t2LDRs", ":", "case", "ARM", "::", "t2LDRBs", ":", "case", "ARM", "::", "t2LDRHs", ":", "case", "ARM", "::", "t2LDRSHs", ":", "Latency", "=", "*", "Latency", "-", "<NUM_LIT>", ";", "break", ";", "}", "}", "if", "(", "DefAlign", "<", "<NUM_LIT>", "&&", "Subtarget", ".", "checkVLDnAccessAlignment", "(", ")", ")", "switch", "(", "DefMCID", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "VLD1q8", ":", "case", "ARM", "::", "VLD1q16", ":", "case", "ARM", "::", "VLD1q32", ":", "case", "ARM", "::", "VLD1q64", ":", "case", "ARM", "::", "VLD1q8wb_register", ":", "case", "ARM", "::", "VLD1q16wb_register", ":", "case", "ARM", "::", "VLD1q32wb_register", ":", "case", "ARM", "::", "VLD1q64wb_register", ":", "case", "ARM", "::", "VLD1q8wb_fixed", ":", "case", "ARM", "::", "VLD1q16wb_fixed", ":", "case", "ARM", "::", "VLD1q32wb_fixed", ":", "case", "ARM", "::", "VLD1q64wb_fixed", ":", "case", "ARM", "::", "VLD2d8", ":", "case", "ARM", "::", "VLD2d16", ":", "case", "ARM", "::", "VLD2d32", ":", "case", "ARM", "::", "VLD2q8Pseudo", ":", "case", "ARM", "::", "VLD2q16Pseudo", ":", "case", "ARM", "::", "VLD2q32Pseudo", ":", "case", "ARM", "::", "VLD2d8wb_fixed", ":", "case", "ARM", "::", "VLD2d16wb_fixed", ":", "case", "ARM", "::", "VLD2d32wb_fixed", ":", "case", "ARM", "::", "VLD2q8PseudoWB_fixed", ":", "case", "ARM", "::", "VLD2q16PseudoWB_fixed", ":", "case", "ARM", "::", "VLD2q32PseudoWB_fixed", ":", "case", "ARM", "::", "VLD2d8wb_register", ":", "case", "ARM", "::", "VLD2d16wb_register", ":", "case", "ARM", "::", "VLD2d32wb_register", ":", "case", "ARM", "::", "VLD2q8PseudoWB_register", ":", "case", "ARM", "::", "VLD2q16PseudoWB_register", ":", "case", "ARM", "::", "VLD2q32PseudoWB_register", ":", "case", "ARM", "::", "VLD3d8Pseudo", ":", "case", "ARM", "::", "VLD3d16Pseudo", ":", "case", "ARM", "::", "VLD3d32Pseudo", ":", "case", "ARM", "::", "VLD1d8TPseudo", ":", "case", "ARM", "::", "VLD1d16TPseudo", ":", "case", "ARM", "::", "VLD1d32TPseudo", ":", "case", "ARM", "::", "VLD1d64TPseudo", ":", "case", "ARM", "::", "VLD1d64TPseudoWB_fixed", ":", "case", "ARM", "::", "VLD1d64TPseudoWB_register", ":", "case", "ARM", "::", "VLD3d8Pseudo_UPD", ":", "case", "ARM", "::", "VLD3d16Pseudo_UPD", ":", "case", "ARM", "::", "VLD3d32Pseudo_UPD", ":", "case", "ARM", "::", "VLD3q8Pseudo_UPD", ":", "case", "ARM", "::", "VLD3q16Pseudo_UPD", ":", "case", "ARM", "::", "VLD3q32Pseudo_UPD", ":", "case", "ARM", "::", "VLD3q8oddPseudo", ":", "case", "ARM", "::", "VLD3q16oddPseudo", ":", "case", "ARM", "::", "VLD3q32oddPseudo", ":", "case", "ARM", "::", "VLD3q8oddPseudo_UPD", ":", "case", "ARM", "::", "VLD3q16oddPseudo_UPD", ":", "case", "ARM", "::", "VLD3q32oddPseudo_UPD", ":", "case", "ARM", "::", "VLD4d8Pseudo", ":", "case", "ARM", "::", "VLD4d16Pseudo", ":", "case", "ARM", "::", "VLD4d32Pseudo", ":", "case", "ARM", "::", "VLD1d8QPseudo", ":", "case", "ARM", "::", "VLD1d16QPseudo", ":", "case", "ARM", "::", "VLD1d32QPseudo", ":", "case", "ARM", "::", "VLD1d64QPseudo", ":", "case", "ARM", "::", "VLD1d64QPseudoWB_fixed", ":", "case", "ARM", "::", "VLD1d64QPseudoWB_register", ":", "case", "ARM", "::", "VLD1q8HighQPseudo", ":", "case", "ARM", "::", "VLD1q8LowQPseudo_UPD", ":", "case", "ARM", "::", "VLD1q8HighTPseudo", ":", "case", "ARM", "::", "VLD1q8LowTPseudo_UPD", ":", "case", "ARM", "::", "VLD1q16HighQPseudo", ":", "case", "ARM", "::", "VLD1q16LowQPseudo_UPD", ":", "case", "ARM", "::", "VLD1q16HighTPseudo", ":", "case", "ARM", "::", "VLD1q16LowTPseudo_UPD", ":", "case", "ARM", "::", "VLD1q32HighQPseudo", ":", "case", "ARM", "::", "VLD1q32LowQPseudo_UPD", ":", "case", "ARM", "::", "VLD1q32HighTPseudo", ":", "case", "ARM", "::", "VLD1q32LowTPseudo_UPD", ":", "case", "ARM", "::", "VLD1q64HighQPseudo", ":", "case", "ARM", "::", "VLD1q64LowQPseudo_UPD", ":", "case", "ARM", "::", "VLD1q64HighTPseudo", ":", "case", "ARM", "::", "VLD1q64LowTPseudo_UPD", ":", "case", "ARM", "::", "VLD4d8Pseudo_UPD", ":", "case", "ARM", "::", "VLD4d16Pseudo_UPD", ":", "case", "ARM", "::", "VLD4d32Pseudo_UPD", ":", "case", "ARM", "::", "VLD4q8Pseudo_UPD", ":", "case", "ARM", "::", "VLD4q16Pseudo_UPD", ":", "case", "ARM", "::", "VLD4q32Pseudo_UPD", ":", "case", "ARM", "::", "VLD4q8oddPseudo", ":", "case", "ARM", "::", "VLD4q16oddPseudo", ":", "case", "ARM", "::", "VLD4q32oddPseudo", ":", "case", "ARM", "::", "VLD4q8oddPseudo_UPD", ":", "case", "ARM", "::", "VLD4q16oddPseudo_UPD", ":", "case", "ARM", "::", "VLD4q32oddPseudo_UPD", ":", "case", "ARM", "::", "VLD1DUPq8", ":", "case", "ARM", "::", "VLD1DUPq16", ":", "case", "ARM", "::", "VLD1DUPq32", ":", "case", "ARM", "::", "VLD1DUPq8wb_fixed", ":", "case", "ARM", "::", "VLD1DUPq16wb_fixed", ":", "case", "ARM", "::", "VLD1DUPq32wb_fixed", ":", "case", "ARM", "::", "VLD1DUPq8wb_register", ":", "case", "ARM", "::", "VLD1DUPq16wb_register", ":", "case", "ARM", "::", "VLD1DUPq32wb_register", ":", "case", "ARM", "::", "VLD2DUPd8", ":", "case", "ARM", "::", "VLD2DUPd16", ":", "case", "ARM", "::", "VLD2DUPd32", ":", "case", "ARM", "::", "VLD2DUPd8wb_fixed", ":", "case", "ARM", "::", "VLD2DUPd16wb_fixed", ":", "case", "ARM", "::", "VLD2DUPd32wb_fixed", ":", "case", "ARM", "::", "VLD2DUPd8wb_register", ":", "case", "ARM", "::", "VLD2DUPd16wb_register", ":", "case", "ARM", "::", "VLD2DUPd32wb_register", ":", "case", "ARM", "::", "VLD2DUPq8EvenPseudo", ":", "case", "ARM", "::", "VLD2DUPq8OddPseudo", ":", "case", "ARM", "::", "VLD2DUPq16EvenPseudo", ":", "case", "ARM", "::", "VLD2DUPq16OddPseudo", ":", "case", "ARM", "::", "VLD2DUPq32EvenPseudo", ":", "case", "ARM", "::", "VLD2DUPq32OddPseudo", ":", "case", "ARM", "::", "VLD3DUPq8EvenPseudo", ":", "case", "ARM", "::", "VLD3DUPq8OddPseudo", ":", "case", "ARM", "::", "VLD3DUPq16EvenPseudo", ":", "case", "ARM", "::", "VLD3DUPq16OddPseudo", ":", "case", "ARM", "::", "VLD3DUPq32EvenPseudo", ":", "case", "ARM", "::", "VLD3DUPq32OddPseudo", ":", "case", "ARM", "::", "VLD4DUPd8Pseudo" ]

[ "=", "_", "_", "B", ";" ]

[ "_", "_", "asm__", "(", "<STR_LIT>", "<STR_LIT>", ":", ":", "<STR_LIT>", "b", "<STR_LIT>", "(", "_", "_", "A", ")", ":", "<STR_LIT>", "memory", "<STR_LIT>", ")", ";", "*", "_", "_", "A" ]

[ "return", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "SL", ",", "MVT", "::", "i32", ",", "Vec", ",", "One", ")", ";" ]

[ "SDValue", "Vec", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "SL", ",", "MVT", "::", "v2i32", ",", "Op", ")", ";", "const", "SDValue", "One", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "SL", ",", "MVT", "::", "i32", ")", ";" ]

[ ";" ]

[ "RegsNeeded", "=", "NumBytes", "/", "<NUM_LIT>", ";", "RegClass", "=", "&", "ARM", "::", "GPRRegClass", ";", "}", "SmallVector", "<", "MachineOperand", ",", "<NUM_LIT>", ">", "RegList", ";", "unsigned", "FirstRegEnc", "=", "-", "<NUM_LIT>", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getRegInfo", "(", ")", ".", "getTargetRegisterInfo", "(", ")", ";", "for", "(", "int", "i", "=", "MI", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ";", "i", ">=", "RegListIdx", ";", "--", "i", ")", "{", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "RegList", ".", "push_back", "(", "MO", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "TRI", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", "<", "FirstRegEnc", ")", "FirstRegEnc", "=", "TRI", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "const", "MCPhysReg", "*", "CSRegs", "=", "TRI", "->", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "for", "(", "int", "CurRegEnc", "=", "FirstRegEnc", "-", "<NUM_LIT>", ";", "CurRegEnc", ">=", "<NUM_LIT>", "&&", "RegsNeeded", ";", "--", "CurRegEnc", ")", "{", "unsigned", "CurReg", "=", "RegClass", "->", "getRegister", "(", "CurRegEnc", ")", ";", "if", "(", "!", "IsPop", ")", "{", "RegList", ".", "push_back", "(", "MachineOperand", "::", "CreateReg", "(", "CurReg", ",", "false", ",", "false", ",", "false", ",", "false", ",", "true", ")", ")", ";", "--", "RegsNeeded", ";", "continue", ";", "}", "if", "(", "isCalleeSavedRegister", "(", "CurReg", ",", "CSRegs", ")", "||", "MI", "->", "getParent", "(", ")", "->", "computeRegisterLiveness", "(", "TRI", ",", "CurReg", ",", "MI", ")", "!=", "MachineBasicBlock", "::", "LQR_Dead", ")", "{", "if", "(", "IsVFPPushPop", ")", "return", "false", ";", "else", "continue" ]

[ ";" ]

[ "for", "(", "UUSetMap", "::", "iterator", "I", "=", "P2Rs", ".", "begin", "(", ")", ",", "E", "=", "P2Rs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "first", "==", "<NUM_LIT>", ")", "continue", ";", "if", "(", "Limit", ">=", "<NUM_LIT>", "&&", "Counter", ">=", "Limit", ")", "break", ";", "USet", "&", "Part", "=", "I", "->", "second", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Calculating profit for partition #", "<STR_LIT>", "<<", "I", "->", "first", "<<", "'", "\\n", "'", ")", ";", "if", "(", "!", "isProfitable", "(", "Part", ",", "IRM", ")", ")", "continue", ";", "Counter", "++" ]

[ "return", ";" ]

[ "case", "MachineOperand", "::", "MO_Register", ":", "PrintOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "O", "<<", "MO", ".", "getImm", "(", ")", ";", "return", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "PrintSymbolOperand", "(", "MO", ",", "O", ")", ";" ]

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

[ "gcc_assert", "(", "ok", ")", ";", "x", "=", "gen_rtx_VEC_CONCAT", "(", "mode", ",", "x", ",", "x", ")", ";", "<BUGS>", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "target", ",", "x", ")", ")", ";", "<BUGE>", "}", "return", "true", ";" ]

[ ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "base", ";", "bits", "<", "<NUM_LIT>", ">", "offset", ";", "bits", "<", "<NUM_LIT>", ">", "extend", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sz", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "V", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>" ]

[ "<NUM_LIT>", ";" ]

[ "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "accessSize", "=", "WordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "GP", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isPredicable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=" ]

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

[ "machine_mode", "cmp_mode", ";", "rtx", "cc_reg", ",", "dst", ",", "cmp", ";", "cmp", "=", "operands", "[", "<NUM_LIT>", "]", ";", "if", "(", "GET_MODE", "(", "XEXP", "(", "cmp", ",", "<NUM_LIT>", ")", ")", "==", "DImode", "&&", "!", "TARGET_ARCH64", ")", "return", "false", ";", "if", "(", "GET_MODE", "(", "XEXP", "(", "cmp", ",", "<NUM_LIT>", ")", ")", "==", "TFmode", "&&", "!", "TARGET_HARD_QUAD", ")", "cmp", "=", "sparc_emit_float_lib_cmp", "(", "XEXP", "(", "cmp", ",", "<NUM_LIT>", ")", ",", "XEXP", "(", "cmp", ",", "<NUM_LIT>", ")", ",", "rc", ")", ";", "cmp_mode", "=", "GET_MODE", "(", "XEXP", "(", "cmp", ",", "<NUM_LIT>", ")", ")", ";", "rc", "=", "GET_CODE", "(", "cmp", ")", ";", "dst", "=", "operands", "[", "<NUM_LIT>", "]", ";", "if", "(", "!", "rtx_equal_p", "(", "operands", "[", "<NUM_LIT>", "]", ",", "dst", ")", "&&", "!", "rtx_equal_p", "(", "operands", "[", "<NUM_LIT>", "]", ",", "dst", ")", ")", "{", "if", "(", "reg_overlap_mentioned_p", "(", "dst", ",", "cmp", ")", ")", "dst", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_move_insn", "(", "dst", ",", "operands", "[" ]

[ ")", "]" ]

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

[ "a", ";" ]

[ "vreinterpretq_p8_p16", "(", "poly16x8_t", "_", "_", "a", ")", "{", "return", "(", "poly8x16_t", ")", "_", "_" ]

[ "asm_out_file", ")", ";" ]

[ "fputs", "(", "<STR_LIT>", "\\t.end\\t", "<STR_LIT>", ",", "asm_out_file", ")", ";", "assemble_name", "(", "asm_out_file", ",", "name", ")", ";", "fputs", "(", "<STR_LIT>", "\\n", "<STR_LIT>", "," ]

[ ".", "getRegInfo", "(", ")", ";" ]

[ "const", "uint32_t", "*", "CalleePreserved", "=", "TRI", "->", "getCallPreservedMask", "(", "MF", ",", "CalleeCC", ")", ";", "if", "(", "!", "TRI", "->", "regmaskSubsetEqual", "(", "CallerPreserved", ",", "CalleePreserved", ")", ")", "return", "false", ";", "}", "const", "ARMFunctionInfo", "*", "AFI_Caller", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "if", "(", "AFI_Caller", "->", "getArgRegsSaveSize", "(", ")", ")", "return", "false", ";", "if", "(", "!", "Outs", ".", "empty", "(", ")", ")", "{", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CalleeCC", ",", "isVarArg", ",", "MF", ",", "ArgLocs", ",", "C", ")", ";", "CCInfo", ".", "AnalyzeCallOperands", "(", "Outs", ",", "CCAssignFnForCall", "(", "CalleeCC", ",", "isVarArg", ")", ")", ";", "if", "(", "CCInfo", ".", "getNextStackOffset", "(", ")", ")", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "realArgIdx", "=", "<NUM_LIT>", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ",", "++", "realArgIdx", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "EVT", "RegVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "SDValue", "Arg", "=", "OutVals", "[", "realArgIdx", "]", ";", "ISD", "::", "ArgFlagsTy", "Flags", "=", "Outs", "[", "realArgIdx", "]", ".", "Flags", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "Indirect", ")", "return", "false", ";", "if", "(", "VA", ".", "needsCustom", "(", ")", ")", "{", "if", "(", "!", "VA", ".", "isRegLoc", "(", ")", ")", "return", "false", ";", "if", "(", "!", "ArgLocs", "[", "++", "i", "]", ".", "isRegLoc", "(", ")", ")", "return", "false", ";", "if", "(", "RegVT", "==", "MVT", "::", "v2f64", ")", "{", "if", "(", "!", "ArgLocs", "[", "++", "i", "]", ".", "isRegLoc", "(", ")", ")", "return", "false", ";", "if", "(", "!", "ArgLocs", "[", "++", "i", "]", ".", "isRegLoc", "(", ")", ")", "return", "false", ";", "}", "}", "else", "if", "(", "!", "VA", ".", "isRegLoc", "(", ")", ")", "{", "if", "(", "!", "MatchingStackOffset", "(", "Arg", ",", "VA", ".", "getLocMemOffset", "(", ")", ",", "Flags", ",", "MFI", ",", "MRI", ",", "TII", ")", ")", "return", "false", ";", "}", "}", "}", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF" ]

[ "(", "AArch64duplane16", "(", "v8i16", "V128_lo", ":", "$", "Rm", ")", ",", "VectorIndexH", ":", "$", "idx", ")", ")", ")", ")", "]", ">", "{" ]

[ "def", "v4i16_indexed", ":", "BaseSIMDIndexed", "<", "<NUM_LIT>", ",", "U", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "opc", ",", "V128", ",", "V64", ",", "V128_lo", ",", "VectorIndexH", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "(", "v4i32", "V128", ":", "$", "Rd", ")", ",", "(", "OpNode", "(", "v4i16", "V64", ":", "$", "Rn", ")", ",", "(", "v4i16" ]

[ "}" ]

[ "CALLInst", ".", "setOpcode", "(", "Is64Bit", "?", "X86", "::", "CALL64pcrel32", ":", "X86", "::", "CALLpcrel32", ")", ";", "CALLInst", ".", "addOperand", "(", "Op", ")", ";", "Out", ".", "EmitInstruction", "(", "CALLInst", ")", ";", "Out", ".", "EmitBundleUnlock", "(", ")", ";" ]

[ "<NUM_LIT>", ";" ]

[ "def", "L2_loadalignh_pci", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Ryy32", ",", "IntRegs", ":", "$", "Rx32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Ryy32in", ",", "IntRegs", ":", "$", "Rx32in", ",", "s4_1Imm", ":", "$", "Ii", ",", "ModRegs", ":", "$", "Mu2", ")", ",", "<STR_LIT>", ",", "tc_785f65a7", ",", "TypeLD", ">", ",", "Enc_9e2e1c", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "PostInc", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=" ]

[ "false", ";" ]

[ "HasV7Ops", "=", "false", ";", "HasV8Ops", "=", "false", ";", "HasV8_1aOps", "=", "false", ";", "HasVFPv2", "=", "false", ";", "HasVFPv3", "=", "false", ";", "HasVFPv4", "=", "false", ";", "HasFPARMv8", "=", "false", ";", "HasNEON", "=", "false", ";", "UseNEONForSinglePrecisionFP", "=", "false", ";", "UseMulOps", "=", "UseFusedMulOps", ";", "SlowFPVMLx", "=", "false", ";", "HasVMLxForwarding", "=", "false", ";", "SlowFPBrcc", "=", "false", ";", "InThumbMode", "=", "false", ";", "UseSoftFloat", "=", "false", ";", "HasThumb2", "=", "false", ";", "NoARM", "=", "false", ";", "ReserveR9", "=", "false", ";", "NoMovt", "=", "false", ";", "SupportsTailCall", "=", "false", ";", "HasFP16", "=", "false", ";", "HasD16", "=", "false", ";", "HasHardwareDivide", "=", "false", ";", "HasHardwareDivideInARM", "=", "false", ";", "HasT2ExtractPack", "=", "false", ";", "HasDataBarrier", "=", "false", ";", "Pref32BitThumb", "=", "false", ";", "AvoidCPSRPartialUpdate", "=", "false", ";", "AvoidMOVsShifterOperand", "=", "false", ";", "HasRAS", "=", "false", ";", "HasMPExtension", "=", "false", ";", "HasVirtualization", "=", "false", ";", "FPOnlySP", "=", "false", ";", "HasPerfMon", "=", "false", ";", "HasTrustZone", "=", "false", ";", "HasCrypto", "=", "false", ";", "HasCRC", "=" ]

[ "_", "B", ",", "(", "_", "_", "v64qi", ")", "_", "mm512_setzero_si512", "(", ")", ",", "(", "_", "_", "mmask64", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_psubsb512_mask", "(", "(", "_", "_", "v64qi", ")", "_", "_", "A", ",", "(", "_", "_", "v64qi", ")", "_" ]

[ "}" ]

[ "case", "ISD", "::", "SETEQ", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETGT", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETGE", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETLT", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETLE", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETULT", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETULE", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETUGE", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETUGT", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "offset", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "extend", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "extend", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "base", ";" ]

[ "GPR64RegClass", ",", "&", "HSAIL", "::", "CRRegClass", "}", ";" ]

[ "const", "TargetRegisterClass", "*", "HSAILRegisterInfo", "::", "getPhysRegClass", "(", "unsigned", "Reg", ")", "const", "{", "assert", "(", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Reg", ")", ")", ";", "static", "const", "TargetRegisterClass", "*", "BaseClasses", "[", "]", "=", "{", "&", "HSAIL", "::", "GPR32RegClass", ",", "&", "HSAIL", "::" ]

[ "let", "opExtentBits", "=", "<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>", ";", "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", "=", "[", "P0", "]", ";", "let", "Defs", "=", "[", "P0", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

[ ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "PostInc", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>" ]

[ "return", "MCDisassembler", "::", "Success", ";" ]

[ "if", "(", "Bytes", ".", "size", "(", ")", "<", "<NUM_LIT>", ")", "{", "Size", "=", "<NUM_LIT>", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "Insn", "=", "IsLittleEndian", "?", "(", "Bytes", "[", "<NUM_LIT>", "]", "<<", "<NUM_LIT>", ")", "|", "(", "Bytes", "[", "<NUM_LIT>", "]", "<<", "<NUM_LIT>", ")", "|", "(", "Bytes", "[", "<NUM_LIT>", "]", "<<", "<NUM_LIT>", ")", "|", "(", "Bytes", "[", "<NUM_LIT>", "]", "<<", "<NUM_LIT>", ")", ":", "(", "Bytes", "[", "<NUM_LIT>", "]", "<<", "<NUM_LIT>", ")", "|", "(", "Bytes", "[", "<NUM_LIT>", "]", "<<", "<NUM_LIT>", ")", "|", "(", "Bytes", "[", "<NUM_LIT>", "]", "<<", "<NUM_LIT>", ")", "|", "(", "Bytes", "[", "<NUM_LIT>", "]", "<<", "<NUM_LIT>", ")", ";" ]

[ "<FIXS>", "SDValue", "TempNode", "=", "DAG", ".", "getUNDEF", "(", "Op", ".", "getNode", "(", ")", "->", "getValueType", "(", "i", ")", ")", ";", "<FIXE>", "<FIXS>", "return", "DAG", ".", "getNode", "(", "ISD", "::", "MERGE_VALUES", ",", "dl", ",", "Op", ".", "getNode", "(", ")", "->", "getVTList", "(", ")", ",", "<FIXE>" ]

[ "SelectionDAG", "&", "DAG", ")", "{", "SmallVector", "SDValue", ",", "<NUM_LIT>", ">", "ArgValues", ";", "unsigned", "NumArgs", "=", "Op", ".", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "NumArgs", ";", "i", "++", ")", "{", "<BUGS>", "SDValue", "TempNode", "=", "DAG", ".", "getNode", "(", "ISD", "::", "UNDEF", ",", "Op", ".", "getNode", "(", ")", "->", "getValueType", "(", "i", ")", ")", ";", "<BUGE>", "ArgValues", ".", "push_back", "(", "TempNode", ")", ";", "}", "ArgValues", ".", "push_back", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "<BUGS>", "return", "DAG", ".", "getNode", "(", "ISD", "::", "MERGE_VALUES", ",", "Op", ".", "getNode", "(", ")", "->", "getVTList", "(", ")", ",", "<BUGE>", "&", "ArgValues", "[", "<NUM_LIT>", "]", ",", "ArgValues", ".", "size", "(", ")", ")", ".", "getValue", "(", "Op", ".", "getResNo", "(", ")", ")", ";", "}" ]

[ "<FIXS>", "void", "saveLROnStack", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "It", ",", "bool", "CFI", ",", "bool", "Auth", ")", "const", ";", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "MachineBasicBlock", "::", "iterator", "It", ",", "bool", "CFI", ",", "bool", "Auth", ")", "const", ";", "<FIXE>" ]

[ "unsigned", "findRegisterToSaveLRTo", "(", "const", "outliner", "::", "Candidate", "&", "C", ")", "const", ";", "<BUGS>", "void", "saveLROnStack", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "It", ")", "const", ";", "<BUGE>", "<BUGS>", "<BUGE>", "void", "restoreLRFromStack", "(", "MachineBasicBlock", "&", "MBB", ",", "<BUGS>", "MachineBasicBlock", "::", "iterator", "It", ")", "const", ";", "void", "emitCFIForLRSaveOnStack", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "It", ")", "const", ";", "<BUGE>" ]

[ ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "PostInc", ";", "let", "accessSize", "=", "ByteAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>" ]

[ ";" ]

[ "if", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "!=", "REG", ")", "operands", "[", "<NUM_LIT>", "]", "=", "adjust_address", "(", "operands", "[", "<NUM_LIT>", "]", ",", "HImode", ",", "<NUM_LIT>", ")", ";", "if", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "<NUM_LIT>", ")", "return", "<STR_LIT>", "mov%.w %2,%0", "<STR_LIT>", ";", "return", "<STR_LIT>", "or%.w %2,%0", "<STR_LIT>", ";", "}", "if", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "CONST_INT", "&&", "(", "logval", "=", "exact_log2", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "&", "<NUM_LIT>", ")", ")", ">=", "<NUM_LIT>", "&&", "(", "DATA_REG_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", "||", "offsettable_memref_p", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", ")", "{", "if", "(", "DATA_REG_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "logval", ")", ";", "else", "{", "operands", "[", "<NUM_LIT>", "]", "=", "adjust_address", "(", "operands", "[", "<NUM_LIT>", "]", ",", "SImode", ",", "<NUM_LIT>", "-", "(", "logval", "/", "<NUM_LIT>", ")", ")", ";", "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "logval", "%", "<NUM_LIT>", ")", ";", "}", "return", "<STR_LIT>", "bset %1,%0", "<STR_LIT>", ";", "}", "if", "(", "!", "side_effects_p", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "flags_operand1", "=", "operands", "[", "<NUM_LIT>", "]", ";", "flags_valid", "=", "FLAGS_VALID_YES", ";", "return", "<STR_LIT>", "or%.l %2,%0", "<STR_LIT>" ]

[ "<FIXS>", "llvm_unreachable", "(", "<STR_LIT>", "Only dealing with PC-relative fixups for now", "<STR_LIT>", ")", ";", "<FIXE>" ]

[ "unsigned", "FISCELFObjectWriter", "::", "GetRelocType", "(", "const", "MCValue", "&", "Target", ",", "const", "MCFixup", "&", "Fixup", ",", "bool", "IsPCRel", ")", "const", "{", "if", "(", "!", "IsPCRel", ")", "<BUGS>", "llvm_unreachable", "(", "<STR_LIT>", "Only dealying with PC-relative fixups for now", "<STR_LIT>", ")", ";", "<BUGE>", "unsigned", "Type", "=", "<NUM_LIT>", ";", "switch", "(", "(", "unsigned", ")", "Fixup", ".", "getKind", "(", ")", ")", "{" ]

[ "}" ]

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

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

[ "def", "C4_addipc", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "u32_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_a813cf9a", ",", "TypeCR", ">", ",", "Enc_607661", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "[", "(", "set", "(", "match_operand", ":", "DDTD", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "DDTD", "[", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DDTD", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_DDEDPD", ")", ")", "]", "<FIXE>", "<FIXS>", "<STR_LIT>", "<FIXE>", "<FIXS>", "[", "(", "set", "(", "match_operand", ":", "DDTD", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "DDTD", "[", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DDTD", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_DENBCD", ")", ")", "]", "<FIXE>", "<FIXS>", "<STR_LIT>", "<FIXE>", "<FIXS>", "(", "unspec", ":", "DI", "[", "(", "match_operand", ":", "DDTD", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<FIXE>", "<FIXS>", "<STR_LIT>", "<FIXE>", "<FIXS>", "[", "(", "set", "(", "match_operand", ":", "DDTD", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "DDTD", "[", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DDTD", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_DXEX", ")", ")", "]", "<FIXE>", "<FIXS>", "<STR_LIT>", "<FIXE>", "<FIXS>", "(", "compare", ":", "CCFP", "(", "unspec", ":", "DDTD", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DDTD", "<NUM_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_DTSTSFI", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "<FIXE>", "<FIXS>", "(", "DFP_TEST", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "(", "compare", ":", "CCFP", "(", "unspec", ":", "DDTD", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DDTD", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_DTSTSFI", ")", "<FIXE>" ]

[ "(", "define_code_iterator", "DFP_TEST", "[", "eq", "lt", "gt", "unordered", "]", ")", "(", "define_insn", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "match_operand", ":", "D64_D128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "D64_D128", "[", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "D64_D128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_DDEDPD", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_insn", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "match_operand", ":", "D64_D128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "D64_D128", "[", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "D64_D128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_DENBCD", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "unspec", ":", "DI", "[", "(", "match_operand", ":", "D64_D128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<BUGE>", "UNSPEC_DXEX", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_insn", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "match_operand", ":", "D64_D128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "D64_D128", "[", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "D64_D128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_DXEX", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "<BUGS>", "(", "compare", ":", "CCFP", "(", "unspec", ":", "D64_D128", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "D64_D128", "<NUM_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_DTSTSFI", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "<BUGE>", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "DFP_TEST", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "<BUGE>", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{", "operands", "[", "<NUM_LIT>", "]", "=", "gen_reg_rtx", "(", "CCFPmode", ")", "<BUGS>", "operands", "[", "<NUM_LIT>", "]", "=", "const0_rtx", "<BUGE>", "}", ")", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "CCFP", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "compare", ":", "CCFP", "(", "unspec", ":", "D64_D128", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "D64_D128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_DTSTSFI", ")", "<BUGE>", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{" ]

[ "DecodeFPRegsRegisterClass", ")", ";" ]

[ "return", "DecodeMem", "(", "Inst", ",", "insn", ",", "Address", ",", "Decoder", ",", "false", "," ]

[ "false", ")", ";" ]

[ "bool", "iss32Imm", "(", ")", "const", "{", "return", "CheckImmRange", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "true", ",", "true", "," ]

[ "]", "=", "{" ]

[ "const", "static", "MCFixupKindInfo", "InfosLE", "[", "ARM", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "<STR_LIT>", "fixup_arm_ldst_pcrel_12", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_t2_ldst_pcrel_12", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", ",", "{", "<STR_LIT>", "fixup_arm_pcrel_10_unscaled", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_arm_pcrel_10", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_t2_pcrel_10", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", ",", "{", "<STR_LIT>", "fixup_arm_pcrel_9", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_t2_pcrel_9", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", ",", "{", "<STR_LIT>", "fixup_thumb_adr_pcrel_10", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", ",", "{", "<STR_LIT>", "fixup_arm_adr_pcrel_12", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_t2_adr_pcrel_12", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", ",", "{", "<STR_LIT>", "fixup_arm_condbranch", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_arm_uncondbranch", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_t2_condbranch", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_t2_uncondbranch", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_arm_thumb_br", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_arm_uncondbl", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_arm_condbl", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_arm_blx", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_arm_thumb_bl", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_arm_thumb_blx", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", ",", "{", "<STR_LIT>", "fixup_arm_thumb_cb", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_arm_thumb_cp", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", ",", "{", "<STR_LIT>", "fixup_arm_thumb_bcc", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_arm_movt_hi16", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "fixup_arm_movw_lo16", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "fixup_t2_movt_hi16", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "fixup_t2_movw_lo16", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "fixup_arm_mod_imm", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "fixup_t2_so_imm", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "}", ";", "const", "static", "MCFixupKindInfo", "InfosBE", "[", "ARM", "::", "NumTargetFixupKinds" ]

[ ",", "IIC_BrB", ",", "[", "]", ">", ";" ]

[ "def", "BCCTRn", ":", "XLForm_2_br2", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "crbitrc", ":", "$", "bi", ")", ",", "<STR_LIT>" ]