Attachment #268906 for bug #152952

View Details Raw Unified Return to Bug 152952

| Differences between



			buildPhases = (
			);
			dependencies = (
				0F6183471C45F67A0072450B /* PBXTargetDependency */,
				0F93275D1C20BF3A00CF6564 /* PBXTargetDependency */,
				0FEC85B11BDB5D8F0080FF74 /* PBXTargetDependency */,
				5D6B2A4F152B9E23005231DE /* PBXTargetDependency */,

		0F5EF91E16878F7A003E5C25 /* JITThunks.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0F5EF91B16878F78003E5C25 /* JITThunks.cpp */; };
		0F5EF91F16878F7D003E5C25 /* JITThunks.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F5EF91C16878F78003E5C25 /* JITThunks.h */; settings = {ATTRIBUTES = (Private, ); }; };
		0F5F08CF146C7633000472A9 /* UnconditionalFinalizer.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F5F08CE146C762F000472A9 /* UnconditionalFinalizer.h */; settings = {ATTRIBUTES = (Private, ); }; };
		0F6183291C45BF070072450B /* AirCCallingConvention.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0F6183201C45BF070072450B /* AirCCallingConvention.cpp */; };
		0F61832A1C45BF070072450B /* AirCCallingConvention.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F6183211C45BF070072450B /* AirCCallingConvention.h */; };
		0F61832B1C45BF070072450B /* AirCustom.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0F6183221C45BF070072450B /* AirCustom.cpp */; };
		0F61832C1C45BF070072450B /* AirEmitShuffle.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0F6183231C45BF070072450B /* AirEmitShuffle.cpp */; };
		0F61832D1C45BF070072450B /* AirEmitShuffle.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F6183241C45BF070072450B /* AirEmitShuffle.h */; };
		0F61832E1C45BF070072450B /* AirLowerAfterRegAlloc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0F6183251C45BF070072450B /* AirLowerAfterRegAlloc.cpp */; };
		0F61832F1C45BF070072450B /* AirLowerAfterRegAlloc.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F6183261C45BF070072450B /* AirLowerAfterRegAlloc.h */; };
		0F6183301C45BF070072450B /* AirLowerMacros.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0F6183271C45BF070072450B /* AirLowerMacros.cpp */; };
		0F6183311C45BF070072450B /* AirLowerMacros.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F6183281C45BF070072450B /* AirLowerMacros.h */; };
		0F6183331C45F35C0072450B /* AirOpcode.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F6183321C45F35C0072450B /* AirOpcode.h */; };
		0F6183361C45F3B60072450B /* AirOpcodeGenerated.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F6183341C45F3B60072450B /* AirOpcodeGenerated.h */; };
		0F6183371C45F3B60072450B /* AirOpcodeUtils.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F6183351C45F3B60072450B /* AirOpcodeUtils.h */; };
		0F61833C1C45F62A0072450B /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 51F0EB6105C86C6B00E6DF1B /* Foundation.framework */; };
		0F61833D1C45F62A0072450B /* JavaScriptCore.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 932F5BD90822A1C700736975 /* JavaScriptCore.framework */; };
		0F6183451C45F6600072450B /* testair.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0F6183441C45F6600072450B /* testair.cpp */; };
		0F620174143FCD330068B77C /* DFGVariableAccessData.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F620172143FCD2F0068B77C /* DFGVariableAccessData.h */; };
		0F620176143FCD3B0068B77C /* DFGBasicBlock.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F620170143FCD2F0068B77C /* DFGBasicBlock.h */; };
		0F620177143FCD3F0068B77C /* DFGAbstractValue.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F62016F143FCD2F0068B77C /* DFGAbstractValue.h */; };

/* End PBXBuildFile section */

/* Begin PBXContainerItemProxy section */
		0F6183461C45F67A0072450B /* PBXContainerItemProxy */ = {
			isa = PBXContainerItemProxy;
			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
			proxyType = 1;
			remoteGlobalIDString = 0F6183381C45F62A0072450B;
			remoteInfo = testair;
		};
		0F93275C1C20BF3A00CF6564 /* PBXContainerItemProxy */ = {
			isa = PBXContainerItemProxy;
			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;

		0F5EF91B16878F78003E5C25 /* JITThunks.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JITThunks.cpp; sourceTree = "<group>"; };
		0F5EF91C16878F78003E5C25 /* JITThunks.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JITThunks.h; sourceTree = "<group>"; };
		0F5F08CE146C762F000472A9 /* UnconditionalFinalizer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = UnconditionalFinalizer.h; sourceTree = "<group>"; };
		0F6183201C45BF070072450B /* AirCCallingConvention.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = AirCCallingConvention.cpp; path = b3/air/AirCCallingConvention.cpp; sourceTree = "<group>"; };
		0F6183211C45BF070072450B /* AirCCallingConvention.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = AirCCallingConvention.h; path = b3/air/AirCCallingConvention.h; sourceTree = "<group>"; };
		0F6183221C45BF070072450B /* AirCustom.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = AirCustom.cpp; path = b3/air/AirCustom.cpp; sourceTree = "<group>"; };
		0F6183231C45BF070072450B /* AirEmitShuffle.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = AirEmitShuffle.cpp; path = b3/air/AirEmitShuffle.cpp; sourceTree = "<group>"; };
		0F6183241C45BF070072450B /* AirEmitShuffle.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = AirEmitShuffle.h; path = b3/air/AirEmitShuffle.h; sourceTree = "<group>"; };
		0F6183251C45BF070072450B /* AirLowerAfterRegAlloc.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = AirLowerAfterRegAlloc.cpp; path = b3/air/AirLowerAfterRegAlloc.cpp; sourceTree = "<group>"; };
		0F6183261C45BF070072450B /* AirLowerAfterRegAlloc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = AirLowerAfterRegAlloc.h; path = b3/air/AirLowerAfterRegAlloc.h; sourceTree = "<group>"; };
		0F6183271C45BF070072450B /* AirLowerMacros.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = AirLowerMacros.cpp; path = b3/air/AirLowerMacros.cpp; sourceTree = "<group>"; };
		0F6183281C45BF070072450B /* AirLowerMacros.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = AirLowerMacros.h; path = b3/air/AirLowerMacros.h; sourceTree = "<group>"; };
		0F6183321C45F35C0072450B /* AirOpcode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AirOpcode.h; sourceTree = "<group>"; };
		0F6183341C45F3B60072450B /* AirOpcodeGenerated.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AirOpcodeGenerated.h; sourceTree = "<group>"; };
		0F6183351C45F3B60072450B /* AirOpcodeUtils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AirOpcodeUtils.h; sourceTree = "<group>"; };
		0F6183431C45F62A0072450B /* testair */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = testair; sourceTree = BUILT_PRODUCTS_DIR; };
		0F6183441C45F6600072450B /* testair.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testair.cpp; path = b3/air/testair.cpp; sourceTree = "<group>"; };
		0F62016F143FCD2F0068B77C /* DFGAbstractValue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DFGAbstractValue.h; path = dfg/DFGAbstractValue.h; sourceTree = "<group>"; };
		0F620170143FCD2F0068B77C /* DFGBasicBlock.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DFGBasicBlock.h; path = dfg/DFGBasicBlock.h; sourceTree = "<group>"; };
		0F620172143FCD2F0068B77C /* DFGVariableAccessData.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DFGVariableAccessData.h; path = dfg/DFGVariableAccessData.h; sourceTree = "<group>"; };

		7013CA8A1B491A9400CAE613 /* JSJob.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSJob.h; sourceTree = "<group>"; };
		7035587C1C418419004BD7BF /* MapPrototype.js */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.javascript; path = MapPrototype.js; sourceTree = "<group>"; };
		7035587D1C418419004BD7BF /* SetPrototype.js */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.javascript; path = SetPrototype.js; sourceTree = "<group>"; };
		7035587E1C418458004BD7BF /* MapPrototype.lut.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MapPrototype.lut.h; sourceTree = "<group>"; };
		7035587F1C418458004BD7BF /* SetPrototype.lut.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SetPrototype.lut.h; sourceTree = "<group>"; };
		704FD35305697E6D003DBED9 /* BooleanObject.h */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = BooleanObject.h; sourceTree = "<group>"; tabWidth = 8; };
		705B41A31A6E501E00716757 /* Symbol.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Symbol.cpp; sourceTree = "<group>"; };
		705B41A41A6E501E00716757 /* Symbol.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Symbol.h; sourceTree = "<group>"; };

/* End PBXFileReference section */

/* Begin PBXFrameworksBuildPhase section */
		0F61833B1C45F62A0072450B /* Frameworks */ = {
			isa = PBXFrameworksBuildPhase;
			buildActionMask = 2147483647;
			files = (
				0F61833C1C45F62A0072450B /* Foundation.framework in Frameworks */,
				0F61833D1C45F62A0072450B /* JavaScriptCore.framework in Frameworks */,
			);
			runOnlyForDeploymentPostprocessing = 0;
		};
		0F9327511C20BCBA00CF6564 /* Frameworks */ = {
			isa = PBXFrameworksBuildPhase;
			buildActionMask = 2147483647;

				0FEC85AD1BDB5CF10080FF74 /* testb3 */,
				6511230514046A4C002B101D /* testRegExp */,
				0F9327591C20BCBA00CF6564 /* dynbench */,
				0F6183431C45F62A0072450B /* testair */,
			);
			name = Products;
			sourceTree = "<group>";

				0FEC854C1BDACDC70080FF74 /* AirBasicBlock.cpp */,
				0FEC854D1BDACDC70080FF74 /* AirBasicBlock.h */,
				0FB3878B1BFBC44D00E3AB1E /* AirBlockWorklist.h */,
				0F6183201C45BF070072450B /* AirCCallingConvention.cpp */,
				0F6183211C45BF070072450B /* AirCCallingConvention.h */,
				0FEC854E1BDACDC70080FF74 /* AirCCallSpecial.cpp */,
				0FEC854F1BDACDC70080FF74 /* AirCCallSpecial.h */,
				0FEC85501BDACDC70080FF74 /* AirCode.cpp */,
				0FEC85511BDACDC70080FF74 /* AirCode.h */,
				0F6183221C45BF070072450B /* AirCustom.cpp */,
				0F10F1A21C420BF0001C07D2 /* AirCustom.h */,
				0F4570361BE44C910062A629 /* AirEliminateDeadCode.cpp */,
				0F4570371BE44C910062A629 /* AirEliminateDeadCode.h */,
				0F6183231C45BF070072450B /* AirEmitShuffle.cpp */,
				0F6183241C45BF070072450B /* AirEmitShuffle.h */,
				262D85B41C0D650F006ACB61 /* AirFixPartialRegisterStalls.cpp */,
				262D85B51C0D650F006ACB61 /* AirFixPartialRegisterStalls.h */,
				0F4C91671C2B3D68004341A6 /* AirFixSpillSlotZDef.h */,

				26718BA21BE99F780052017B /* AirIteratedRegisterCoalescing.cpp */,
				26718BA31BE99F780052017B /* AirIteratedRegisterCoalescing.h */,
				2684D4371C00161C0081D663 /* AirLiveness.h */,
				0F6183251C45BF070072450B /* AirLowerAfterRegAlloc.cpp */,
				0F6183261C45BF070072450B /* AirLowerAfterRegAlloc.h */,
				0F6183271C45BF070072450B /* AirLowerMacros.cpp */,
				0F6183281C45BF070072450B /* AirLowerMacros.h */,
				264091FA1BE2FD4100684DB2 /* AirOpcode.opcodes */,
				0FB3878C1BFBC44D00E3AB1E /* AirOptimizeBlockOrder.cpp */,
				0FB3878D1BFBC44D00E3AB1E /* AirOptimizeBlockOrder.h */,

				0F3730921C0D67EE00052BFA /* AirUseCounts.h */,
				0FEC856B1BDACDC70080FF74 /* AirValidate.cpp */,
				0FEC856C1BDACDC70080FF74 /* AirValidate.h */,
				0F6183441C45F6600072450B /* testair.cpp */,
			);
			name = air;
			sourceTree = "<group>";

		650FDF8D09D0FCA700769E54 /* Derived Sources */ = {
			isa = PBXGroup;
			children = (
				0F6183321C45F35C0072450B /* AirOpcode.h */,
				0F6183341C45F3B60072450B /* AirOpcodeGenerated.h */,
				0F6183351C45F3B60072450B /* AirOpcodeUtils.h */,
				996B73151BDA05AA00331B84 /* ArrayConstructor.lut.h */,
				996B73161BDA05AA00331B84 /* ArrayIteratorPrototype.lut.h */,
				996B73071BD9FA2C00331B84 /* BooleanPrototype.lut.h */,

				0F4570391BE44C910062A629 /* AirEliminateDeadCode.h in Headers */,
				79CFC6F01C33B10000C768EA /* LLIntPCRanges.h in Headers */,
				79D5CD5B1C1106A900CECA07 /* SamplingProfiler.h in Headers */,
				0F6183311C45BF070072450B /* AirLowerMacros.h in Headers */,
				0FEC85771BDACDC70080FF74 /* AirFrequentedBlock.h in Headers */,
				0FEC85791BDACDC70080FF74 /* AirGenerate.h in Headers */,
				79DF66B11BF26A570001CF11 /* FTLExceptionHandlerManager.h in Headers */,

				0FEC85141BDACDAC0080FF74 /* B3ControlValue.h in Headers */,
				0FEC85C11BE167A00080FF74 /* B3Effects.h in Headers */,
				0FEC85161BDACDAC0080FF74 /* B3FrequencyClass.h in Headers */,
				0F61832F1C45BF070072450B /* AirLowerAfterRegAlloc.h in Headers */,
				0FEC85171BDACDAC0080FF74 /* B3FrequentedBlock.h in Headers */,
				0FEC85191BDACDAC0080FF74 /* B3Generate.h in Headers */,
				0FEC851A1BDACDAC0080FF74 /* B3GenericFrequentedBlock.h in Headers */,

				A77A424017A0BBFD00A8DB81 /* DFGClobberize.h in Headers */,
				0F37308D1C0BD29100052BFA /* B3PhiChildren.h in Headers */,
				A77A424217A0BBFD00A8DB81 /* DFGClobberSet.h in Headers */,
				0F61832D1C45BF070072450B /* AirEmitShuffle.h in Headers */,
				0F3C1F1B1B868E7900ABB08B /* DFGClobbersExitState.h in Headers */,
				0F04396E1B03DC0B009598B7 /* DFGCombinedLiveness.h in Headers */,
				0F7B294D14C3CD4C007C3DB1 /* DFGCommon.h in Headers */,

				0F2B9CED19D0BA7D00B1D1B5 /* DFGPromotedHeapLocation.h in Headers */,
				0FFC92161B94FB3E0071DD66 /* DFGPropertyTypeKey.h in Headers */,
				0FB17663196B8F9E0091052A /* DFGPureValue.h in Headers */,
				0F6183361C45F3B60072450B /* AirOpcodeGenerated.h in Headers */,
				0F3730911C0CD70C00052BFA /* AllowMacroScratchRegisterUsage.h in Headers */,
				0F3A1BFA1A9ECB7D000DE01A /* DFGPutStackSinkingPhase.h in Headers */,
				86EC9DD11328DF82002B2AD7 /* DFGRegisterBank.h in Headers */,

				0FC20CBA18556A3500C9E954 /* DFGSSALoweringPhase.h in Headers */,
				0F9FB4F517FCB91700CB67F8 /* DFGStackLayoutPhase.h in Headers */,
				0F4F29E018B6AD1C0057BC15 /* DFGStaticExecutionCountEstimationPhase.h in Headers */,
				0F6183371C45F3B60072450B /* AirOpcodeUtils.h in Headers */,
				0F9E32641B05AB0400801ED5 /* DFGStoreBarrierInsertionPhase.h in Headers */,
				0FC20CB61852E2C600C9E954 /* DFGStrengthReductionPhase.h in Headers */,
				0F63947815DCE34B006A597C /* DFGStructureAbstractValue.h in Headers */,

				0F2B66F717B6B5AB00A7AE3F /* JSInt8Array.h in Headers */,
				A76C51761182748D00715B05 /* JSInterfaceJIT.h in Headers */,
				E33F50811B8429A400413856 /* JSInternalPromise.h in Headers */,
				0F61832A1C45BF070072450B /* AirCCallingConvention.h in Headers */,
				E33F50791B84225700413856 /* JSInternalPromiseConstructor.h in Headers */,
				E33F50871B8449EF00413856 /* JSInternalPromiseConstructor.lut.h in Headers */,
				E33F50851B8437A000413856 /* JSInternalPromiseDeferred.h in Headers */,

				142E313C134FF0A600AFADB5 /* Weak.h in Headers */,
				14E84F9F14EE1ACC00D6D5D4 /* WeakBlock.h in Headers */,
				14BFCE6910CDB1FC00364CCE /* WeakGCMap.h in Headers */,
				0F6183331C45F35C0072450B /* AirOpcode.h in Headers */,
				AD86A93E1AA4D88D002FE77F /* WeakGCMapInlines.h in Headers */,
				14F7256614EE265E00B1652B /* WeakHandleOwner.h in Headers */,
				14E84FA214EE1ACC00D6D5D4 /* WeakImpl.h in Headers */,

/* End PBXHeadersBuildPhase section */

/* Begin PBXNativeTarget section */
		0F6183381C45F62A0072450B /* testair */ = {
			isa = PBXNativeTarget;
			buildConfigurationList = 0F61833E1C45F62A0072450B /* Build configuration list for PBXNativeTarget "testair" */;
			buildPhases = (
				0F6183391C45F62A0072450B /* Sources */,
				0F61833B1C45F62A0072450B /* Frameworks */,
			);
			buildRules = (
			);
			dependencies = (
			);
			name = testair;
			productName = testapi;
			productReference = 0F6183431C45F62A0072450B /* testair */;
			productType = "com.apple.product-type.tool";
		};
		0F93274E1C20BCBA00CF6564 /* dynbench */ = {
			isa = PBXNativeTarget;
			buildConfigurationList = 0F9327541C20BCBA00CF6564 /* Build configuration list for PBXNativeTarget "dynbench" */;

				0FEC85941BDB5CF10080FF74 /* testb3 */,
				5D6B2A47152B9E17005231DE /* Test Tools */,
				0F93274E1C20BCBA00CF6564 /* dynbench */,
				0F6183381C45F62A0072450B /* testair */,
			);
		};
/* End PBXProject section */

/* End PBXShellScriptBuildPhase section */

/* Begin PBXSourcesBuildPhase section */
		0F6183391C45F62A0072450B /* Sources */ = {
			isa = PBXSourcesBuildPhase;
			buildActionMask = 2147483647;
			files = (
				0F6183451C45F6600072450B /* testair.cpp in Sources */,
			);
			runOnlyForDeploymentPostprocessing = 0;
		};
		0F93274F1C20BCBA00CF6564 /* Sources */ = {
			isa = PBXSourcesBuildPhase;
			buildActionMask = 2147483647;

				52B717B51A0597E1007AF4F3 /* ControlFlowProfiler.cpp in Sources */,
				0FBADF541BD1F4B800E073C1 /* CopiedBlock.cpp in Sources */,
				C240305514B404E60079EB64 /* CopiedSpace.cpp in Sources */,
				0F6183301C45BF070072450B /* AirLowerMacros.cpp in Sources */,
				C2239D1716262BDD005AC5FD /* CopyVisitor.cpp in Sources */,
				2A111245192FCE79005EE18D /* CustomGetterSetter.cpp in Sources */,
				62E3D5F01B8D0B7300B868BB /* DataFormat.cpp in Sources */,

				0F0981F71BC5E565004814F8 /* DFGCopyBarrierOptimizationPhase.cpp in Sources */,
				0FBE0F7216C1DB030082C5E8 /* DFGCPSRethreadingPhase.cpp in Sources */,
				A7D89CF517A0B8CC00773AD8 /* DFGCriticalEdgeBreakingPhase.cpp in Sources */,
				0F6183291C45BF070072450B /* AirCCallingConvention.cpp in Sources */,
				0FFFC95914EF90A600C72532 /* DFGCSEPhase.cpp in Sources */,
				0F2FC77216E12F710038D976 /* DFGDCEPhase.cpp in Sources */,
				0F338E121BF0276C0013C88F /* B3OpaqueByproducts.cpp in Sources */,

				A78A9774179738B8009DF744 /* DFGFailedFinalizer.cpp in Sources */,
				A78A9776179738B8009DF744 /* DFGFinalizer.cpp in Sources */,
				0F2BDC15151C5D4D00CD8910 /* DFGFixupPhase.cpp in Sources */,
				0F61832C1C45BF070072450B /* AirEmitShuffle.cpp in Sources */,
				0F9D339617FFC4E60073C2BC /* DFGFlushedAt.cpp in Sources */,
				A7D89CF717A0B8CC00773AD8 /* DFGFlushFormat.cpp in Sources */,
				0F69CC88193AC60A0045759E /* DFGFrozenValue.cpp in Sources */,

				E33F50841B8437A000413856 /* JSInternalPromiseDeferred.cpp in Sources */,
				E33F50741B8421C000413856 /* JSInternalPromisePrototype.cpp in Sources */,
				A503FA1B188E0FB000110F14 /* JSJavaScriptCallFrame.cpp in Sources */,
				0F61832E1C45BF070072450B /* AirLowerAfterRegAlloc.cpp in Sources */,
				A503FA1D188E0FB000110F14 /* JSJavaScriptCallFramePrototype.cpp in Sources */,
				7013CA8B1B491A9400CAE613 /* JSJob.cpp in Sources */,
				140B7D1D0DC69AF7009C42B8 /* JSLexicalEnvironment.cpp in Sources */,

				0F9D4C0C1C3E1C11006CD984 /* FTLExceptionTarget.cpp in Sources */,
				0FB1058B1675483100F8AB6E /* ProfilerOSRExit.cpp in Sources */,
				0FB1058D1675483700F8AB6E /* ProfilerOSRExitSite.cpp in Sources */,
				0F61832B1C45BF070072450B /* AirCustom.cpp in Sources */,
				0F13912B16771C3A009CCB07 /* ProfilerProfiledBytecodes.cpp in Sources */,
				0FD3E40D1B618B6600C80E1E /* PropertyCondition.cpp in Sources */,
				A7FB60A4103F7DC20017A286 /* PropertyDescriptor.cpp in Sources */,

/* End PBXSourcesBuildPhase section */

/* Begin PBXTargetDependency section */
		0F6183471C45F67A0072450B /* PBXTargetDependency */ = {
			isa = PBXTargetDependency;
			target = 0F6183381C45F62A0072450B /* testair */;
			targetProxy = 0F6183461C45F67A0072450B /* PBXContainerItemProxy */;
		};
		0F93275D1C20BF3A00CF6564 /* PBXTargetDependency */ = {
			isa = PBXTargetDependency;
			target = 0F93274E1C20BCBA00CF6564 /* dynbench */;

			};
			name = Production;
		};
		0F61833F1C45F62A0072450B /* Debug */ = {
			isa = XCBuildConfiguration;
			baseConfigurationReference = BC021BF2136900C300FC5467 /* ToolExecutable.xcconfig */;
			buildSettings = {
				CODE_SIGN_ENTITLEMENTS_ios_testair = entitlements.plist;
				PRODUCT_NAME = testair;
			};
			name = Debug;
		};
		0F6183401C45F62A0072450B /* Release */ = {
			isa = XCBuildConfiguration;
			baseConfigurationReference = BC021BF2136900C300FC5467 /* ToolExecutable.xcconfig */;
			buildSettings = {
				CODE_SIGN_ENTITLEMENTS_ios_testair = entitlements.plist;
				PRODUCT_NAME = testair;
			};
			name = Release;
		};
		0F6183411C45F62A0072450B /* Profiling */ = {
			isa = XCBuildConfiguration;
			baseConfigurationReference = BC021BF2136900C300FC5467 /* ToolExecutable.xcconfig */;
			buildSettings = {
				CODE_SIGN_ENTITLEMENTS_ios_testair = entitlements.plist;
				PRODUCT_NAME = testair;
			};
			name = Profiling;
		};
		0F6183421C45F62A0072450B /* Production */ = {
			isa = XCBuildConfiguration;
			baseConfigurationReference = BC021BF2136900C300FC5467 /* ToolExecutable.xcconfig */;
			buildSettings = {
				CODE_SIGN_ENTITLEMENTS_ios_testair = entitlements.plist;
				PRODUCT_NAME = testair;
			};
			name = Production;
		};
		0F9327551C20BCBA00CF6564 /* Debug */ = {
			isa = XCBuildConfiguration;
			baseConfigurationReference = BC021BF2136900C300FC5467 /* ToolExecutable.xcconfig */;

			defaultConfigurationIsVisible = 0;
			defaultConfigurationName = Production;
		};
		0F61833E1C45F62A0072450B /* Build configuration list for PBXNativeTarget "testair" */ = {
			isa = XCConfigurationList;
			buildConfigurations = (
				0F61833F1C45F62A0072450B /* Debug */,
				0F6183401C45F62A0072450B /* Release */,
				0F6183411C45F62A0072450B /* Profiling */,
				0F6183421C45F62A0072450B /* Production */,
			);
			defaultConfigurationIsVisible = 0;
			defaultConfigurationName = Production;
		};
		0F9327541C20BCBA00CF6564 /* Build configuration list for PBXNativeTarget "dynbench" */ = {
			isa = XCConfigurationList;
			buildConfigurations = (

Lines 1-5 Source/JavaScriptCore/assembler/AbstractMacroAssembler.h_sec1
- Source/JavaScriptCore/assembler/AbstractMacroAssembler.h -1 / +10 lines
1	/*	1	/*
2	* Copyright (C) 2008, 2012, 2014, 2015 Apple Inc. All rights reserved.	2	* Copyright (C) 2008, 2012, 2014-2016 Apple Inc. All rights reserved.
3	*	3	*
4	* Redistribution and use in source and binary forms, with or without	4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions	5	* modification, are permitted provided that the following conditions
Lines 76-81 inline bool isX86_64() Source/JavaScriptCore/assembler/AbstractMacroAssembler.h_sec2
76	#endif	76	#endif
77	}	77	}
78		78
		79	inline bool isIOS()
		80	{
		81	#if PLATFORM(IOS)
		82	return true;
		83	#else
		84	return false;
		85	#endif
		86	}
		87
79	inline bool optimizeForARMv7IDIVSupported()	88	inline bool optimizeForARMv7IDIVSupported()
80	{	89	{
81	return isARMv7IDIVSupported() && Options::useArchitectureSpecificOptimizations();	90	return isARMv7IDIVSupported() && Options::useArchitectureSpecificOptimizations();



    }
#endif

    void swap32(RegisterID src, RegisterID dest)
    {
        m_assembler.xchgl_rr(src, dest);
    }

    void swap32(RegisterID src, Address dest)
    {
        m_assembler.xchgl_rm(src, dest.offset, dest.base);
    }

    void moveConditionally32(RelationalCondition cond, RegisterID left, RegisterID right, RegisterID src, RegisterID dest)
    {
        m_assembler.cmpl_rr(right, left);



/*
 * Copyright (C) 2008, 2012, 2014-2016 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions

        return DataLabel32(this);
    }

    void swap64(RegisterID src, RegisterID dest)
    {
        m_assembler.xchgq_rr(src, dest);
    }

    void swap64(RegisterID src, Address dest)
    {
        m_assembler.xchgq_rm(src, dest.offset, dest.base);
    }

    void move64ToDouble(RegisterID src, FPRegisterID dest)
    {
        m_assembler.movq_rr(src, dest);

Lines 1-5 Source/JavaScriptCore/assembler/X86Assembler.h_sec1
- Source/JavaScriptCore/assembler/X86Assembler.h -1 / +11 lines
1	/*	1	/*
2	* Copyright (C) 2008, 2012-2015 Apple Inc. All rights reserved.	2	* Copyright (C) 2008, 2012-2016 Apple Inc. All rights reserved.
3	*	3	*
4	* Redistribution and use in source and binary forms, with or without	4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions	5	* modification, are permitted provided that the following conditions
Lines 1431-1436 public: Source/JavaScriptCore/assembler/X86Assembler.h_sec2
1431	m_formatter.oneByteOp(OP_XCHG_EvGv, src, dst);	1431	m_formatter.oneByteOp(OP_XCHG_EvGv, src, dst);
1432	}	1432	}
1433		1433
		1434	void xchgl_rm(RegisterID src, int offset, RegisterID base)
		1435	{
		1436	m_formatter.oneByteOp(OP_XCHG_EvGv, src, base, offset);
		1437	}
		1438
1434	#if CPU(X86_64)	1439	#if CPU(X86_64)
1435	void xchgq_rr(RegisterID src, RegisterID dst)	1440	void xchgq_rr(RegisterID src, RegisterID dst)
1436	{	1441	{
Lines 1441-1446 public: Source/JavaScriptCore/assembler/X86Assembler.h_sec3
1441	else	1446	else
1442	m_formatter.oneByteOp64(OP_XCHG_EvGv, src, dst);	1447	m_formatter.oneByteOp64(OP_XCHG_EvGv, src, dst);
1443	}	1448	}
		1449
		1450	void xchgq_rm(RegisterID src, int offset, RegisterID base)
		1451	{
		1452	m_formatter.oneByteOp64(OP_XCHG_EvGv, src, base, offset);
		1453	}
1444	#endif	1454	#endif
1445		1455
1446	void movl_rr(RegisterID src, RegisterID dst)	1456	void movl_rr(RegisterID src, RegisterID dst)



/*
 * Copyright (C) 2015-2016 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions


    ~CCallValue();

    Effects effects { Effects::forCall() };

private:
    friend class Procedure;

    template<typename... Arguments>
    CCallValue(unsigned index, Type type, Origin origin, Arguments... arguments)
        : Value(index, CheckedOpcode, CCall, type, origin, arguments...)
        , effects(Effects::forCall())
    {
        RELEASE_ASSERT(numChildren() >= 1);
    }

Lines 1-5 Source/JavaScriptCore/b3/B3Compilation.cpp_sec1
- Source/JavaScriptCore/b3/B3Compilation.cpp -1 / +7 lines
1	/*	1	/*
2	* Copyright (C) 2015 Apple Inc. All rights reserved.	2	* Copyright (C) 2015-2016 Apple Inc. All rights reserved.
3	*	3	*
4	* Redistribution and use in source and binary forms, with or without	4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions	5	* modification, are permitted provided that the following conditions
Lines 52-57 Compilation::Compilation(VM& vm, Procedu Source/JavaScriptCore/b3/B3Compilation.cpp_sec2
52	m_byproducts = proc.releaseByproducts();	52	m_byproducts = proc.releaseByproducts();
53	}	53	}
54		54
		55	Compilation::Compilation(MacroAssemblerCodeRef codeRef, std::unique_ptr<OpaqueByproducts> byproducts)
		56	: m_codeRef(codeRef)
		57	, m_byproducts(WTFMove(byproducts))
		58	{
		59	}
		60
55	Compilation::~Compilation()	61	Compilation::~Compilation()
56	{	62	{
57	}	63	}

Lines 1-5 Source/JavaScriptCore/b3/B3Compilation.h_sec1
- Source/JavaScriptCore/b3/B3Compilation.h -1 / +6 lines
1	/*	1	/*
2	* Copyright (C) 2015 Apple Inc. All rights reserved.	2	* Copyright (C) 2015-2016 Apple Inc. All rights reserved.
3	*	3	*
4	* Redistribution and use in source and binary forms, with or without	4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions	5	* modification, are permitted provided that the following conditions
Lines 55-60 class Compilation { Source/JavaScriptCore/b3/B3Compilation.h_sec2
55		55
56	public:	56	public:
57	JS_EXPORT_PRIVATE Compilation(VM&, Procedure&, unsigned optLevel = 1);	57	JS_EXPORT_PRIVATE Compilation(VM&, Procedure&, unsigned optLevel = 1);
		58
		59	// This constructor allows you to manually create a Compilation. It's currently only used by test
		60	// code. Probably best to keep it that way.
		61	JS_EXPORT_PRIVATE Compilation(MacroAssemblerCodeRef, std::unique_ptr<OpaqueByproducts>);
		62
58	JS_EXPORT_PRIVATE ~Compilation();	63	JS_EXPORT_PRIVATE ~Compilation();
59		64
60	MacroAssemblerCodePtr code() const { return m_codeRef.code(); }	65	MacroAssemblerCodePtr code() const { return m_codeRef.code(); }

Lines 35-40 Source/JavaScriptCore/b3/B3LowerToAir.cpp_sec1
- Source/JavaScriptCore/b3/B3LowerToAir.cpp -77 / +20 lines
35	#include "AirStackSlot.h"	35	#include "AirStackSlot.h"
36	#include "B3ArgumentRegValue.h"	36	#include "B3ArgumentRegValue.h"
37	#include "B3BasicBlockInlines.h"	37	#include "B3BasicBlockInlines.h"
		38	#include "B3BlockWorklist.h"
38	#include "B3CCallValue.h"	39	#include "B3CCallValue.h"
39	#include "B3CheckSpecial.h"	40	#include "B3CheckSpecial.h"
40	#include "B3Commutativity.h"	41	#include "B3Commutativity.h"
Lines 94-99 public: Source/JavaScriptCore/b3/B3LowerToAir.cpp_sec2
94	}	95	}
95	}	96	}
96		97
		98	// Figure out which blocks are not rare.
		99	m_fastWorklist.push(m_procedure[0]);
		100	while (B3::BasicBlock* block = m_fastWorklist.pop()) {
		101	for (B3::FrequentedBlock& successor : block->successors()) {
		102	if (!successor.isRare())
		103	m_fastWorklist.push(successor.block());
		104	}
		105	}
		106
97	m_procedure.resetValueOwners(); // Used by crossesInterference().	107	m_procedure.resetValueOwners(); // Used by crossesInterference().
98		108
99	// Lower defs before uses on a global level. This is a good heuristic to lock down a	109	// Lower defs before uses on a global level. This is a good heuristic to lock down a
Lines 103-108 public: Source/JavaScriptCore/b3/B3LowerToAir.cpp_sec3
103	// Reset some state.	113	// Reset some state.
104	m_insts.resize(0);	114	m_insts.resize(0);
105		115
		116	m_isRare = !m_fastWorklist.saw(block);
		117
106	if (verbose)	118	if (verbose)
107	dataLog("Lowering Block ", *block, ":\n");	119	dataLog("Lowering Block ", *block, ":\n");
108		120
Lines 1541-1577 private: Source/JavaScriptCore/b3/B3LowerToAir.cpp_sec4
1541	inverted);	1553	inverted);
1542	}	1554	}
1543		1555
1544	template<typename BankInfo>
1545	Arg marshallCCallArgument(unsigned& argumentCount, unsigned& stackOffset, Value* child)
1546	{
1547	unsigned argumentIndex = argumentCount++;
1548	if (argumentIndex < BankInfo::numberOfArgumentRegisters) {
1549	Tmp result = Tmp(BankInfo::toArgumentRegister(argumentIndex));
1550	append(relaxedMoveForType(child->type()), immOrTmp(child), result);
1551	return result;
1552	}
1553
1554	#if CPU(ARM64) && PLATFORM(IOS)
1555	// iOS does not follow the ARM64 ABI regarding function calls.
1556	// Arguments must be packed.
1557	unsigned slotSize = sizeofType(child->type());
1558	stackOffset = WTF::roundUpToMultipleOf(slotSize, stackOffset);
1559	#else
1560	unsigned slotSize = sizeof(void*);
1561	#endif
1562	Arg result = Arg::callArg(stackOffset);
1563	stackOffset += slotSize;
1564
1565	// Put the code for storing the argument before anything else. This significantly eases the
1566	// burden on the register allocator. If we could, we'd hoist these stores as far as
1567	// possible.
1568	// FIXME: Add a phase to hoist stores as high as possible to relieve register pressure.
1569	// https://bugs.webkit.org/show_bug.cgi?id=151063
1570	m_insts.last().insert(0, createStore(child, result));
1571
1572	return result;
1573	}
1574
1575	void lower()	1556	void lower()
1576	{	1557	{
1577	switch (m_value->opcode()) {	1558	switch (m_value->opcode()) {
Lines 1919-1932 private: Source/JavaScriptCore/b3/B3LowerToAir.cpp_sec5
1919	return;	1900	return;
1920	}	1901	}
1921		1902
1922	case CCall: {	1903	case B3::CCall: {
1923	CCallValue* cCall = m_value->as<CCallValue>();	1904	CCallValue* cCall = m_value->as<CCallValue>();
1924	Inst inst(Patch, cCall, Arg::special(m_code.cCallSpecial()));	1905	Inst inst(m_isRare ? Air::ColdCCall : Air::CCall, cCall);
1925
1926	// This is a bit weird - we have a super intense contract with Arg::CCallSpecial. It might
1927	// be better if we factored Air::CCallSpecial out of the Air namespace and made it a B3
1928	// thing.
1929	// FIXME: https://bugs.webkit.org/show_bug.cgi?id=151045
1930		1906
1931	// We have a ton of flexibility regarding the callee argument, but currently, we don't	1907	// We have a ton of flexibility regarding the callee argument, but currently, we don't
1932	// use it yet. It gets weird for reasons:	1908	// use it yet. It gets weird for reasons:
Lines 1939-1986 private: Source/JavaScriptCore/b3/B3LowerToAir.cpp_sec6
1939	// FIXME: https://bugs.webkit.org/show_bug.cgi?id=151052	1915	// FIXME: https://bugs.webkit.org/show_bug.cgi?id=151052
1940	inst.args.append(tmp(cCall->child(0)));	1916	inst.args.append(tmp(cCall->child(0)));
1941		1917
1942	// We need to tell Air what registers this defines.	1918	if (cCall->type() != Void)
1943	inst.args.append(Tmp(GPRInfo::returnValueGPR));	1919	inst.args.append(tmp(cCall));
1944	inst.args.append(Tmp(GPRInfo::returnValueGPR2));
1945	inst.args.append(Tmp(FPRInfo::returnValueFPR));
1946
1947	// Now marshall the arguments. This is where we implement the C calling convention. After
1948	// this, Air does not know what the convention is; it just takes our word for it.
1949	unsigned gpArgumentCount = 0;
1950	unsigned fpArgumentCount = 0;
1951	unsigned stackOffset = 0;
1952	for (unsigned i = 1; i < cCall->numChildren(); ++i) {
1953	Value* argChild = cCall->child(i);
1954	Arg arg;
1955
1956	switch (Arg::typeForB3Type(argChild->type())) {
1957	case Arg::GP:
1958	arg = marshallCCallArgument<GPRInfo>(gpArgumentCount, stackOffset, argChild);
1959	break;
1960		1920
1961	case Arg::FP:	1921	for (unsigned i = 1; i < cCall->numChildren(); ++i)
1962	arg = marshallCCallArgument<FPRInfo>(fpArgumentCount, stackOffset, argChild);	1922	inst.args.append(immOrTmp(cCall->child(i)));
1963	break;
1964	}
1965		1923
1966	if (arg.isTmp())
1967	inst.args.append(arg);
1968	}
1969
1970	m_insts.last().append(WTFMove(inst));	1924	m_insts.last().append(WTFMove(inst));
1971
1972	switch (cCall->type()) {
1973	case Void:
1974	break;
1975	case Int32:
1976	case Int64:
1977	append(Move, Tmp(GPRInfo::returnValueGPR), tmp(cCall));
1978	break;
1979	case Float:
1980	case Double:
1981	append(MoveDouble, Tmp(FPRInfo::returnValueFPR), tmp(cCall));
1982	break;
1983	}
1984	return;	1925	return;
1985	}	1926	}
1986		1927
Lines 2272-2282 private: Source/JavaScriptCore/b3/B3LowerToAir.cpp_sec7
2272		2213
2273	UseCounts m_useCounts;	2214	UseCounts m_useCounts;
2274	PhiChildren m_phiChildren;	2215	PhiChildren m_phiChildren;
		2216	BlockWorklist m_fastWorklist;
2275		2217
2276	Vector<Vector<Inst, 4>> m_insts;	2218	Vector<Vector<Inst, 4>> m_insts;
2277	Vector<Inst> m_prologue;	2219	Vector<Inst> m_prologue;
2278		2220
2279	B3::BasicBlock* m_block;	2221	B3::BasicBlock* m_block;
		2222	bool m_isRare;
2280	unsigned m_index;	2223	unsigned m_index;
2281	Value* m_value;	2224	Value* m_value;
2282		2225



/*
 * Copyright (C) 2015-2016 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions

    WTF_MAKE_FAST_ALLOCATED;
public:
    OpaqueByproducts();
    JS_EXPORT_PRIVATE ~OpaqueByproducts();

    size_t count() const { return m_byproducts.size(); }
    



    case Arg::Tmp:
    case Arg::Imm:
    case Arg::Imm64:
    case Arg::Stack:
    case Arg::CallArg:
        break; // OK
    case Arg::Addr:
        if (arg.base() != Tmp(GPRInfo::callFrameRegister)
            && arg.base() != Tmp(MacroAssembler::stackPointerRegister))
            return false;
        break;
    default:
        if (!arg.isStackMemory())
            return false;
        break;
    }
    
    Arg::Type type = Arg::typeForB3Type(value->type());

    return arg.canRepresent(value);
}

bool StackmapSpecial::isArgValidForRep(Air::Code& code, const Air::Arg& arg, const ValueRep& rep)

Lines 30-38 Source/JavaScriptCore/b3/air/AirArg.cpp_sec1
- Source/JavaScriptCore/b3/air/AirArg.cpp -4 / +43 lines
30		30
31	#include "AirSpecial.h"	31	#include "AirSpecial.h"
32	#include "AirStackSlot.h"	32	#include "AirStackSlot.h"
		33	#include "B3Value.h"
		34	#include "FPRInfo.h"
		35	#include "GPRInfo.h"
33		36
34	namespace JSC { namespace B3 { namespace Air {	37	namespace JSC { namespace B3 { namespace Air {
35		38
		39	bool Arg::isStackMemory() const
		40	{
		41	switch (kind()) {
		42	case Addr:
		43	return base() == Air::Tmp(GPRInfo::callFrameRegister)
		44	\|\| base() == Air::Tmp(MacroAssembler::stackPointerRegister);
		45	case Stack:
		46	case CallArg:
		47	return true;
		48	default:
		49	return false;
		50	}
		51	}
		52
36	bool Arg::isRepresentableAs(Width width, Signedness signedness) const	53	bool Arg::isRepresentableAs(Width width, Signedness signedness) const
37	{	54	{
38	switch (signedness) {	55	switch (signedness) {
Lines 61-66 bool Arg::isRepresentableAs(Width width, Source/JavaScriptCore/b3/air/AirArg.cpp_sec2
61	}	78	}
62	}	79	}
63		80
		81	bool Arg::usesTmp(Air::Tmp tmp) const
		82	{
		83	bool uses = false;
		84	const_cast<Arg*>(this)->forEachTmpFast(
		85	[&] (Air::Tmp otherTmp) {
		86	if (otherTmp == tmp)
		87	uses = true;
		88	});
		89	return uses;
		90	}
		91
		92	bool Arg::canRepresent(Value* value) const
		93	{
		94	return isType(typeForB3Type(value->type()));
		95	}
		96
64	void Arg::dump(PrintStream& out) const	97	void Arg::dump(PrintStream& out) const
65	{	98	{
66	switch (m_kind) {	99	switch (m_kind) {
Lines 111-116 void Arg::dump(PrintStream& out) const Source/JavaScriptCore/b3/air/AirArg.cpp_sec3
111	case Special:	144	case Special:
112	out.print(pointerDump(special()));	145	out.print(pointerDump(special()));
113	return;	146	return;
		147	case WidthArg:
		148	out.print(width());
		149	return;
114	}	150	}
115		151
116	RELEASE_ASSERT_NOT_REACHED();	152	RELEASE_ASSERT_NOT_REACHED();
Lines 161-166 void printInternal(PrintStream& out, Arg Source/JavaScriptCore/b3/air/AirArg.cpp_sec4
161	case Arg::Special:	197	case Arg::Special:
162	out.print("Special");	198	out.print("Special");
163	return;	199	return;
		200	case Arg::WidthArg:
		201	out.print("WidthArg");
		202	return;
164	}	203	}
165		204
166	RELEASE_ASSERT_NOT_REACHED();	205	RELEASE_ASSERT_NOT_REACHED();
Lines 225-240 void printInternal(PrintStream& out, Arg Source/JavaScriptCore/b3/air/AirArg.cpp_sec5
225	{	264	{
226	switch (width) {	265	switch (width) {
227	case Arg::Width8:	266	case Arg::Width8:
228	out.print("Width8");	267	out.print("8");
229	return;	268	return;
230	case Arg::Width16:	269	case Arg::Width16:
231	out.print("Width16");	270	out.print("16");
232	return;	271	return;
233	case Arg::Width32:	272	case Arg::Width32:
234	out.print("Width32");	273	out.print("32");
235	return;	274	return;
236	case Arg::Width64:	275	case Arg::Width64:
237	out.print("Width64");	276	out.print("64");
238	return;	277	return;
239	}	278	}
240		279

Lines 33-39 Source/JavaScriptCore/b3/air/AirArg.h_sec1
- Source/JavaScriptCore/b3/air/AirArg.h -14 / +81 lines
33	#include "B3Type.h"	33	#include "B3Type.h"
34	#include <wtf/Optional.h>	34	#include <wtf/Optional.h>
35		35
36	namespace JSC { namespace B3 { namespace Air {	36	namespace JSC { namespace B3 {
		37
		38	class Value;
		39
		40	namespace Air {
37		41
38	class Special;	42	class Special;
39	class StackSlot;	43	class StackSlot;
Lines 69-75 public: Source/JavaScriptCore/b3/air/AirArg.h_sec2
69	RelCond,	73	RelCond,
70	ResCond,	74	ResCond,
71	DoubleCond,	75	DoubleCond,
72	Special	76	Special,
		77	WidthArg
73	};	78	};
74		79
75	enum Role : int8_t {	80	enum Role : int8_t {
Lines 156-161 public: Source/JavaScriptCore/b3/air/AirArg.h_sec3
156		161
157	static const unsigned numTypes = 2;	162	static const unsigned numTypes = 2;
158		163
		164	template<typename Functor>
		165	static void forEachType(const Functor& functor)
		166	{
		167	functor(GP);
		168	functor(FP);
		169	}
		170
159	enum Width : int8_t {	171	enum Width : int8_t {
160	Width8,	172	Width8,
161	Width16,	173	Width16,
Lines 220-225 public: Source/JavaScriptCore/b3/air/AirArg.h_sec4
220	return isAnyUse(role) && !isColdUse(role);	232	return isAnyUse(role) && !isColdUse(role);
221	}	233	}
222		234
		235	static Role cooled(Role role)
		236	{
		237	switch (role) {
		238	case ColdUse:
		239	case LateColdUse:
		240	case UseDef:
		241	case UseZDef:
		242	case Def:
		243	case ZDef:
		244	case UseAddr:
		245	case Scratch:
		246	case EarlyDef:
		247	return role;
		248	case Use:
		249	return ColdUse;
		250	case LateUse:
		251	return LateColdUse;
		252	}
		253	}
		254
223	// Returns true if the Role implies that the Inst will Use the Arg before doing anything else.	255	// Returns true if the Role implies that the Inst will Use the Arg before doing anything else.
224	static bool isEarlyUse(Role role)	256	static bool isEarlyUse(Role role)
225	{	257	{
Lines 549-554 public: Source/JavaScriptCore/b3/air/AirArg.h_sec5
549	return result;	581	return result;
550	}	582	}
551		583
		584	static Arg widthArg(Width width)
		585	{
		586	Arg result;
		587	result.m_kind = WidthArg;
		588	result.m_offset = width;
		589	return result;
		590	}
		591
552	bool operator==(const Arg& other) const	592	bool operator==(const Arg& other) const
553	{	593	{
554	return m_offset == other.m_offset	594	return m_offset == other.m_offset
Lines 585-590 public: Source/JavaScriptCore/b3/air/AirArg.h_sec6
585	return kind() == Imm64;	625	return kind() == Imm64;
586	}	626	}
587		627
		628	bool isSomeImm() const
		629	{
		630	return isImm() \|\| isImm64();
		631	}
		632
588	bool isAddr() const	633	bool isAddr() const
589	{	634	{
590	return kind() == Addr;	635	return kind() == Addr;
Lines 605-610 public: Source/JavaScriptCore/b3/air/AirArg.h_sec7
605	return kind() == Index;	650	return kind() == Index;
606	}	651	}
607		652
		653	bool isMemory() const
		654	{
		655	switch (kind()) {
		656	case Addr:
		657	case Stack:
		658	case CallArg:
		659	case Index:
		660	return true;
		661	default:
		662	return false;
		663	}
		664	}
		665
		666	bool isStackMemory() const;
		667
608	bool isRelCond() const	668	bool isRelCond() const
609	{	669	{
610	return kind() == RelCond;	670	return kind() == RelCond;
Lines 637-642 public: Source/JavaScriptCore/b3/air/AirArg.h_sec8
637	return kind() == Special;	697	return kind() == Special;
638	}	698	}
639		699
		700	bool isWidthArg() const
		701	{
		702	return kind() == WidthArg;
		703	}
		704
640	bool isAlive() const	705	bool isAlive() const
641	{	706	{
642	return isTmp() \|\| isStack();	707	return isTmp() \|\| isStack();
Lines 680-697 public: Source/JavaScriptCore/b3/air/AirArg.h_sec9
680	return m_base;	745	return m_base;
681	}	746	}
682		747
683	bool hasOffset() const	748	bool hasOffset() const { return isMemory(); }
684	{
685	switch (kind()) {
686	case Addr:
687	case Stack:
688	case CallArg:
689	case Index:
690	return true;
691	default:
692	return false;
693	}
694	}
695		749
696	int32_t offset() const	750	int32_t offset() const
697	{	751	{
Lines 730-735 public: Source/JavaScriptCore/b3/air/AirArg.h_sec10
730	return bitwise_cast<Air::Special*>(m_offset);	784	return bitwise_cast<Air::Special*>(m_offset);
731	}	785	}
732		786
		787	Width width() const
		788	{
		789	ASSERT(kind() == WidthArg);
		790	return static_cast<Width>(m_offset);
		791	}
		792
733	bool isGPTmp() const	793	bool isGPTmp() const
734	{	794	{
735	return isTmp() && tmp().isGP();	795	return isTmp() && tmp().isGP();
Lines 754-759 public: Source/JavaScriptCore/b3/air/AirArg.h_sec11
754	case ResCond:	814	case ResCond:
755	case DoubleCond:	815	case DoubleCond:
756	case Special:	816	case Special:
		817	case WidthArg:
757	return true;	818	return true;
758	case Tmp:	819	case Tmp:
759	return isGPTmp();	820	return isGPTmp();
Lines 771-776 public: Source/JavaScriptCore/b3/air/AirArg.h_sec12
771	case ResCond:	832	case ResCond:
772	case DoubleCond:	833	case DoubleCond:
773	case Special:	834	case Special:
		835	case WidthArg:
774	case Invalid:	836	case Invalid:
775	return false;	837	return false;
776	case Addr:	838	case Addr:
Lines 812-817 public: Source/JavaScriptCore/b3/air/AirArg.h_sec13
812	}	874	}
813	}	875	}
814		876
		877	bool canRepresent(Value* value) const;
		878
815	bool isGPR() const	879	bool isGPR() const
816	{	880	{
817	return isTmp() && tmp().isGPR();	881	return isTmp() && tmp().isGPR();
Lines 953-958 public: Source/JavaScriptCore/b3/air/AirArg.h_sec14
953	case ResCond:	1017	case ResCond:
954	case DoubleCond:	1018	case DoubleCond:
955	case Special:	1019	case Special:
		1020	case WidthArg:
956	return true;	1021	return true;
957	}	1022	}
958	}	1023	}
Lines 974-979 public: Source/JavaScriptCore/b3/air/AirArg.h_sec15
974	}	1039	}
975	}	1040	}
976		1041
		1042	bool usesTmp(Air::Tmp tmp) const;
		1043
977	// This is smart enough to know that an address arg in a Def or UseDef rule will use its	1044	// This is smart enough to know that an address arg in a Def or UseDef rule will use its
978	// tmps and never def them. For example, this:	1045	// tmps and never def them. For example, this:
979	//	1046	//



    InstList& insts() { return m_insts; }

    template<typename Inst>
    Inst& appendInst(Inst&& inst)
    {
        m_insts.append(std::forward<Inst>(inst));
        return m_insts.last();
    }

    template<typename... Arguments>
    Inst& append(Arguments&&... arguments)
    {
        m_insts.append(Inst(std::forward<Arguments>(arguments)...));
        return m_insts.last();
    }

    // The "0" case is the case to which the branch jumps, so the "then" case. The "1" case is the



/*
 * Copyright (C) 2016 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 */

#include "config.h"
#include "AirCCallingConvention.h"

#if ENABLE(B3_JIT)

#include "AirCCallSpecial.h"
#include "AirCode.h"
#include "B3CCallValue.h"
#include "B3ValueInlines.h"

namespace JSC { namespace B3 { namespace Air {

namespace {

template<typename BankInfo>
Arg marshallCCallArgumentImpl(unsigned& argumentCount, unsigned& stackOffset, Value* child)
{
    unsigned argumentIndex = argumentCount++;
    if (argumentIndex < BankInfo::numberOfArgumentRegisters)
        return Tmp(BankInfo::toArgumentRegister(argumentIndex));

    unsigned slotSize;
    if (isARM64() && isIOS()) {
        // Arguments are packed.
        slotSize = sizeofType(child->type());
    } else {
        // Arguments are aligned.
        slotSize = 8;
    }

    stackOffset = WTF::roundUpToMultipleOf(slotSize, stackOffset);
    Arg result = Arg::callArg(stackOffset);
    stackOffset += slotSize;
    return result;
}

Arg marshallCCallArgument(
    unsigned& gpArgumentCount, unsigned& fpArgumentCount, unsigned& stackOffset, Value* child)
{
    switch (Arg::typeForB3Type(child->type())) {
    case Arg::GP:
        return marshallCCallArgumentImpl<GPRInfo>(gpArgumentCount, stackOffset, child);
    case Arg::FP:
        return marshallCCallArgumentImpl<FPRInfo>(fpArgumentCount, stackOffset, child);
    }
    RELEASE_ASSERT_NOT_REACHED();
    return Arg();
}

} // anonymous namespace

Vector<Arg> computeCCallingConvention(Code& code, CCallValue* value)
{
    Vector<Arg> result;
    result.append(Tmp(CCallSpecial::scratchRegister));
    unsigned gpArgumentCount = 0;
    unsigned fpArgumentCount = 0;
    unsigned stackOffset = 0;
    for (unsigned i = 1; i < value->numChildren(); ++i) {
        result.append(
            marshallCCallArgument(gpArgumentCount, fpArgumentCount, stackOffset, value->child(i)));
    }
    code.requestCallArgAreaSize(WTF::roundUpToMultipleOf(stackAlignmentBytes(), stackOffset));
    return result;
}

Tmp cCallResult(Type type)
{
    switch (type) {
    case Void:
        return Tmp();
    case Int32:
    case Int64:
        return Tmp(GPRInfo::returnValueGPR);
    case Float:
    case Double:
        return Tmp(FPRInfo::returnValueFPR);
    }

    RELEASE_ASSERT_NOT_REACHED();
    return Tmp();
}

Inst buildCCall(Code& code, Value* origin, const Vector<Arg>& arguments)
{
    Inst inst(Patch, origin, Arg::special(code.cCallSpecial()));
    inst.args.append(arguments[0]);
    inst.args.append(Tmp(GPRInfo::returnValueGPR));
    inst.args.append(Tmp(GPRInfo::returnValueGPR2));
    inst.args.append(Tmp(FPRInfo::returnValueFPR));
    for (unsigned i = 1; i < arguments.size(); ++i) {
        Arg arg = arguments[i];
        if (arg.isTmp())
            inst.args.append(arg);
    }
    return inst;
}

} } } // namespace JSC::B3::Air

#endif // ENABLE(B3_JIT)




/*
 * Copyright (C) 2016 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 */

#ifndef AirCCallingConvention_h
#define AirCCallingConvention_h

#if ENABLE(B3_JIT)

#include "AirArg.h"
#include "AirInst.h"
#include "B3Type.h"
#include <wtf/Vector.h>

namespace JSC { namespace B3 {

class CCallValue;

namespace Air {

class Code;

Vector<Arg> computeCCallingConvention(Code&, CCallValue*);

Tmp cCallResult(Type);

Inst buildCCall(Code&, Value* origin, const Vector<Arg>&);

} } } // namespace JSC::B3::Air

#endif // ENABLE(B3_JIT)

#endif // AirCCallingConvention_h




/*
 * Copyright (C) 2015-2016 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions


    Procedure& proc() { return m_proc; }

    JS_EXPORT_PRIVATE BasicBlock* addBlock(double frequency = 1);

    // Note that you can rely on stack slots always getting indices that are larger than the index
    // of any prior stack slot. In fact, all stack slots you create in the future will have an index
    // that is >= stackSlots().size().
    JS_EXPORT_PRIVATE StackSlot* addStackSlot(
        unsigned byteSize, StackSlotKind, StackSlotValue* = nullptr);
    StackSlot* addStackSlot(StackSlotValue*);

    Special* addSpecial(std::unique_ptr<Special>);



/*
 * Copyright (C) 2016 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 */

#include "config.h"
#include "AirCustom.h"

#if ENABLE(B3_JIT)

#include "B3CCallValue.h"
#include "B3ValueInlines.h"

namespace JSC { namespace B3 { namespace Air {

bool CCallCustom::isValidForm(Inst& inst)
{
    CCallValue* value = inst.origin->as<CCallValue>();
    if (!value)
        return false;

    if (inst.args.size() != 1 + (value->type() == Void ? 0 : 1) + value->numChildren())
        return false;

    // The arguments can only refer to the stack, tmps, or immediates.
    for (Arg& arg : inst.args) {
        if (!arg.isTmp() && !arg.isStackMemory() && !arg.isSomeImm())
            return false;
    }

    unsigned offset = 1;

    // If there is a result then it cannot be an immediate.
    if (value->type() != Void) {
        if (inst.args[1].isSomeImm())
            return false;
        if (!inst.args[1].canRepresent(value))
            return false;
        offset++;
    }

    for (unsigned i = value->numChildren(); i--;) {
        Value* child = value->child(i);
        Arg arg = inst.args[offset + i];
        if (!arg.canRepresent(child))
            return false;
    }

    return true;
}

CCallHelpers::Jump CCallCustom::generate(Inst& inst, CCallHelpers&, GenerationContext&)
{
    dataLog("FATAL: Unlowered C call: ", inst, "\n");
    UNREACHABLE_FOR_PLATFORM();
    return CCallHelpers::Jump();
}

bool ShuffleCustom::isValidForm(Inst& inst)
{
    if (inst.args.size() % 3)
        return false;

    // A destination may only appear once. This requirement allows us to avoid the undefined behavior
    // of having a destination that is supposed to get multiple inputs simultaneously. It also
    // imposes some interesting constraints on the "shape" of the shuffle. If we treat a shuffle pair
    // as an edge and the Args as nodes, then the single-destination requirement means that the
    // shuffle graph consists of two kinds of subgraphs:
    //
    // - Spanning trees. We call these shifts. They can be executed as a sequence of Move
    //   instructions and don't usually require scratch registers.
    //
    // - Closed loops. These loops consist of nodes that have one successor and one predecessor, so
    //   there is no way to "get into" the loop from outside of it. These can be executed using swaps
    //   or by saving one of the Args to a scratch register and executing it as a shift.
    HashSet<Arg> dsts;

    for (unsigned i = 0; i < inst.args.size(); ++i) {
        Arg arg = inst.args[i];
        unsigned mode = i % 3;

        if (mode == 2) {
            // It's the width.
            if (!arg.isWidthArg())
                return false;
            continue;
        }

        // The source can be an immediate.
        if (!mode) {
            if (arg.isSomeImm())
                continue;
        } else {
            ASSERT(mode == 1);
            if (!dsts.add(arg).isNewEntry)
                return false;
        }

        if (arg.isTmp() || arg.isStackMemory())
            continue;

        return false;
    }

    return true;
}

CCallHelpers::Jump ShuffleCustom::generate(Inst& inst, CCallHelpers&, GenerationContext&)
{
    dataLog("FATAL: Unlowered shuffle: ", inst, "\n");
    UNREACHABLE_FOR_PLATFORM();
    return CCallHelpers::Jump();
}

} } } // namespace JSC::B3::Air

#endif // ENABLE(B3_JIT)


Lines 30-35 Source/JavaScriptCore/b3/air/AirCustom.h_sec1
- Source/JavaScriptCore/b3/air/AirCustom.h +110 lines
30		30
31	#include "AirInst.h"	31	#include "AirInst.h"
32	#include "AirSpecial.h"	32	#include "AirSpecial.h"
		33	#include "B3Value.h"
33		34
34	namespace JSC { namespace B3 { namespace Air {	35	namespace JSC { namespace B3 { namespace Air {
35		36
Lines 51-56 namespace JSC { namespace B3 { namespace Source/JavaScriptCore/b3/air/AirCustom.h_sec2
51	// you need to carry extra state around with the instruction. Also, Specials mean that you	52	// you need to carry extra state around with the instruction. Also, Specials mean that you
52	// always have access to Code& even in methods that don't take a GenerationContext.	53	// always have access to Code& even in methods that don't take a GenerationContext.
53		54
		55	// Definition of Patch instruction. Patch is used to delegate the behavior of the instruction to the
		56	// Special object, which will be the first argument to the instruction.
54	struct PatchCustom {	57	struct PatchCustom {
55	template<typename Functor>	58	template<typename Functor>
56	static void forEachArg(Inst& inst, const Functor& functor)	59	static void forEachArg(Inst& inst, const Functor& functor)
Lines 96-101 struct PatchCustom { Source/JavaScriptCore/b3/air/AirCustom.h_sec3
96	}	99	}
97	};	100	};
98		101
		102	// Definition of CCall instruction. CCall is used for hot path C function calls. It's lowered to a
		103	// Patch with an Air CCallSpecial along with code to marshal instructions. The lowering happens
		104	// before register allocation, so that the register allocator sees the clobbers.
		105	struct CCallCustom {
		106	template<typename Functor>
		107	static void forEachArg(Inst& inst, const Functor& functor)
		108	{
		109	Value* value = inst.origin;
		110
		111	unsigned index = 0;
		112
		113	functor(inst.args[index++], Arg::Use, Arg::GP, Arg::pointerWidth()); // callee
		114
		115	if (value->type() != Void) {
		116	functor(
		117	inst.args[index++], Arg::Def,
		118	Arg::typeForB3Type(value->type()),
		119	Arg::widthForB3Type(value->type()));
		120	}
		121
		122	for (Value* child : value->children()) {
		123	functor(
		124	inst.args[index++], Arg::Use,
		125	Arg::typeForB3Type(child->type()),
		126	Arg::widthForB3Type(child->type()));
		127	}
		128	}
		129
		130	template<typename... Arguments>
		131	static bool isValidFormStatic(Arguments...)
		132	{
		133	return false;
		134	}
		135
		136	static bool isValidForm(Inst&);
		137
		138	static bool admitsStack(Inst&, unsigned)
		139	{
		140	return true;
		141	}
		142
		143	static bool hasNonArgNonControlEffects(Inst&)
		144	{
		145	return true;
		146	}
		147
		148	// This just crashes, since we expect C calls to be lowered before generation.
		149	static CCallHelpers::Jump generate(Inst&, CCallHelpers&, GenerationContext&);
		150	};
		151
		152	struct ColdCCallCustom : CCallCustom {
		153	template<typename Functor>
		154	static void forEachArg(Inst& inst, const Functor& functor)
		155	{
		156	// This is just like a call, but uses become cold.
		157	CCallCustom::forEachArg(
		158	inst,
		159	[&] (Arg& arg, Arg::Role role, Arg::Type type, Arg::Width width) {
		160	functor(arg, Arg::cooled(role), type, width);
		161	});
		162	}
		163	};
		164
		165	struct ShuffleCustom {
166	template<typename Functor>
167	static void forEachArg(Inst& inst, const Functor& functor)
168	{
169	unsigned limit = inst.args.size() / 3 * 3;
170	for (unsigned i = 0; i < limit; i += 3) {
171	Arg& src = inst.args[i + 0];
172	Arg& dst = inst.args[i + 1];
173	Arg& widthArg = inst.args[i + 2];
174	Arg::Width width = widthArg.width();
175	Arg::Type type = src.isGP() && dst.isGP() ? Arg::GP : Arg::FP;
176	functor(src, Arg::Use, type, width);
177	functor(dst, Arg::Def, type, width);
178	functor(widthArg, Arg::Use, Arg::GP, Arg::Width8);
179	}
180	}
181
182	template<typename... Arguments>
183	static bool isValidFormStatic(Arguments...)
184	{
185	return false;
186	}
187
188	static bool isValidForm(Inst&);
189
190	static bool admitsStack(Inst&, unsigned index)
191	{
192	switch (index % 3) {
193	case 0:
194	case 1:
195	return true;
196	default:
197	return false;
198	}
199	}
200
201	static bool hasNonArgNonControlEffects(Inst&)
202	{
203	return false;
204	}
205
206	static CCallHelpers::Jump generate(Inst&, CCallHelpers&, GenerationContext&);
207	};
208
99	} } } // namespace JSC::B3::Air	209	} } } // namespace JSC::B3::Air
100		210
101	#endif // ENABLE(B3_JIT)	211	#endif // ENABLE(B3_JIT)



/*
 * Copyright (C) 2016 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 */

#include "config.h"
#include "AirEmitShuffle.h"

#if ENABLE(B3_JIT)

#include "AirInstInlines.h"
#include "AirRegisterPriority.h"
#include <wtf/GraphNodeWorklist.h>

namespace JSC { namespace B3 { namespace Air {

namespace {

template<typename Functor>
Tmp findPossibleScratch(Arg::Type type, const Functor& functor) {
    for (Reg reg : regsInPriorityOrder(type)) {
        Tmp tmp(reg);
        if (functor(tmp))
            return tmp;
    }
    return Tmp();
}

Tmp findPossibleScratch(Arg::Type type, const Arg& arg1, const Arg& arg2) {
    return findPossibleScratch(
        type,
        [&] (Tmp tmp) -> bool {
            return !arg1.usesTmp(tmp) && !arg2.usesTmp(tmp);
        });
}

// Example: (a => b, b => a, a => c, b => d)
struct Rotate {
    Vector<ShufflePair> loop; // in the example, this is the loop: (a => b, b => a)
    Vector<ShufflePair> fringe; // in the example, these are the associated shifts: (a => c, b => d)
};

} // anonymous namespace

void ShufflePair::dump(PrintStream& out) const
{
    out.print(width(), ":", src(), "=>", dst());
}

Vector<Inst> emitShuffle(
    Vector<ShufflePair> pairs, std::array<Arg, 2> scratches, Arg::Type type, Value* origin)
{
    pairs.removeAllMatching(
        [&] (const ShufflePair& pair) -> bool {
            return pair.src() == pair.dst();
        });
    
    // First validate that this is the kind of shuffle that we know how to deal with.
    for (const ShufflePair& pair : pairs) {
        ASSERT(pair.src().isType(type));
        ASSERT(pair.dst().isType(type));
        ASSERT(pair.dst().isTmp() || pair.dst().isMemory());
    }

    // There are two possible kinds of operations that we will do:
    //
    // - Shift. Example: (a => b, b => c). We emit this as "Move b, c; Move a, b". This only requires
    //   scratch registers if there are memory->memory moves. We want to find as many of these as
    //   possible because they are cheaper. Note that shifts can involve the same source mentioned
    //   multiple times. Example: (a => b, a => c, b => d, b => e).
    //
    // - Rotate. Example: (a => b, b => a). We want to emit this as "Swap a, b", but that instruction
    //   may not be available, in which case we may need a scratch register or a scratch memory
    //   location. A gnarlier example is (a => b, b => c, c => a). We can emit this as "Swap b, c;
    //   Swap a, b". Note that swapping has to be careful about differing widths.
    //
    // Note that a rotate can have "fringe". For example, we might have (a => b, b => a, a =>c,
    // b => d). This has a rotate loop (a => b, b => a) and some fringe (a => c, b => d). We treat
    // the whole thing as a single rotate.
    //
    // We will find multiple disjoint such operations. We can execute them in any order.

    // We interpret these as Moves that should be executed backwards. All shifts are keyed by their
    // starting source.
    HashMap<Arg, Vector<ShufflePair>> shifts;

    // We interpret these as Swaps over src()'s that should be executed backwards, i.e. for a list
    // of size 3 we would do "Swap list[1].src(), list[2].src(); Swap list[0].src(), list[1].src()".
    // Note that we actually can't do that if the widths don't match or other bad things happen.
    // But, prior to executing all of that, we need to execute the fringe: the shifts comming off the
    // rotate.
    Vector<Rotate> rotates;

    {
        HashMap<Arg, Vector<ShufflePair>> mapping;
        for (const ShufflePair& pair : pairs)
            mapping.add(pair.src(), Vector<ShufflePair>()).iterator->value.append(pair);

        Vector<ShufflePair> currentPairs;

        while (!mapping.isEmpty()) {
            ASSERT(currentPairs.isEmpty());
            Arg originalSrc = mapping.begin()->key;
            ASSERT(!shifts.contains(originalSrc));
            
            GraphNodeWorklist<Arg> worklist;
            worklist.push(originalSrc);
            while (Arg src = worklist.pop()) {
                HashMap<Arg, Vector<ShufflePair>>::iterator iter = mapping.find(src);
                if (iter == mapping.end()) {
                    // With a shift it's possible that we previously built the tail of this shift.
                    // See if that's the case now.
                    currentPairs.appendVector(shifts.take(src));
                    continue;
                }
                Vector<ShufflePair> pairs = WTFMove(iter->value);
                mapping.remove(iter);

                for (const ShufflePair& pair : pairs) {
                    currentPairs.append(pair);
                    ASSERT(pair.src() == src);
                    worklist.push(pair.dst());
                }
            }

            ASSERT(currentPairs.size());
            ASSERT(currentPairs[0].src() == originalSrc);

            bool isRotate = false;
            for (const ShufflePair& pair : currentPairs) {
                if (pair.dst() == originalSrc) {
                    isRotate = true;
                    break;
                }
            }

            if (isRotate) {
                Rotate rotate;
                
                // The common case is that the rotate does not have fringe. When this happens, the
                // last element is the rotate.
                if (currentPairs.last().dst() == originalSrc)
                    rotate.loop = WTFMove(currentPairs);
                else {
                    // This is the slow path. The rotate has fringe. We figure this out by working
                    // backward.
                    
                    HashMap<Arg, ShufflePair> dstMapping;
                    for (const ShufflePair& pair : currentPairs)
                        dstMapping.add(pair.dst(), pair);

                    ShufflePair pair = dstMapping.take(originalSrc);
                    for (;;) {
                        rotate.loop.append(pair);

                        auto iter = dstMapping.find(pair.src());
                        if (iter == dstMapping.end())
                            break;
                        pair = iter->value;
                        dstMapping.remove(iter);
                    }

                    rotate.loop.reverse();

                    // Make sure that the fringe appears in the same order as how it appeared in the
                    // currentPairs, since that's the DFS order.
                    for (const ShufflePair& pair : currentPairs) {
                        // But of course we only include it if it's not in the loop.
                        if (dstMapping.contains(pair.dst()))
                            rotate.fringe.append(pair);
                    }
                }
                
                // If the graph search terminates because we returned to the first source, then the
                // pair list has to have a very particular shape.
                for (unsigned i = rotate.loop.size() - 1; i--;)
                    ASSERT(rotate.loop[i].dst() == rotate.loop[i + 1].src());
                rotates.append(WTFMove(rotate));
            } else
                shifts.add(originalSrc, WTFMove(currentPairs));
        }
    }

    // In the worst case, we need two scratch registers. The way we do this is that the client passes
    // us what scratch registers he happens to have laying around. We will need scratch registers in
    // the following cases:
    //
    // - Shuffle pairs where both src and dst refer to memory.
    // - Rotate when no Swap instruction is available.
    //
    // Lucky for us, we are guaranteed to have extra scratch registers anytime we have a Shift that
    // ends with a register. We search for such a register right now.

    auto moveForWidth = [&] (Arg::Width width) -> Opcode {
        switch (width) {
        case Arg::Width32:
            return type == Arg::GP ? Move32 : MoveFloat;
        case Arg::Width64:
            return type == Arg::GP ? Move : MoveDouble;
        default:
            RELEASE_ASSERT_NOT_REACHED();
        }
    };

    Opcode conservativeMove = moveForWidth(Arg::conservativeWidth(type));

    // We will emit things in reverse. We maintain a list of packs of instructions, and then we emit
    // append them together in reverse (for example the thing at the end of resultPacks is placed
    // first). This is useful because the last thing we emit frees up its destination registers, so
    // it affects how we emit things before it.
    Vector<Vector<Inst>> resultPacks;
    Vector<Inst> result;

    auto commitResult = [&] () {
        resultPacks.append(WTFMove(result));
    };

    auto getScratch = [&] (unsigned index, Tmp possibleScratch) -> Tmp {
        if (scratches[index].isTmp())
            return scratches[index].tmp();

        if (!possibleScratch)
            return Tmp();
        result.append(Inst(conservativeMove, origin, possibleScratch, scratches[index]));
        return possibleScratch;
    };

    auto returnScratch = [&] (unsigned index, Tmp tmp) {
        if (Arg(tmp) != scratches[index])
            result.append(Inst(conservativeMove, origin, scratches[index], tmp));
    };

    auto handleShiftPair = [&] (const ShufflePair& pair, unsigned scratchIndex) {
        Opcode move = moveForWidth(pair.width());
        
        if (!isValidForm(move, pair.src().kind(), pair.dst().kind())) {
            Tmp scratch =
                getScratch(scratchIndex, findPossibleScratch(type, pair.src(), pair.dst()));
            RELEASE_ASSERT(scratch);
            if (isValidForm(move, pair.src().kind(), Arg::Tmp))
                result.append(Inst(moveForWidth(pair.width()), origin, pair.src(), scratch));
            else {
                ASSERT(pair.src().isSomeImm());
                ASSERT(move == Move32);
                result.append(Inst(Move, origin, Arg::imm64(pair.src().value()), scratch));
            }
            result.append(Inst(moveForWidth(pair.width()), origin, scratch, pair.dst()));
            returnScratch(scratchIndex, scratch);
            return;
        }
        
        result.append(Inst(move, origin, pair.src(), pair.dst()));
    };

    auto handleShift = [&] (Vector<ShufflePair>& shift) {
        for (unsigned i = shift.size(); i--;)
            handleShiftPair(shift[i], 0);

        Arg lastDst = shift.last().dst();
        if (lastDst.isTmp()) {
            for (Arg& scratch : scratches) {
                ASSERT(scratch != lastDst);
                if (!scratch.isTmp()) {
                    scratch = lastDst;
                    break;
                }
            }
        }
    };

    // First handle shifts whose last destination is a tmp because these free up scratch registers.
    // These end up last in the final sequence, so the final destination of these shifts will be
    // available as a scratch location for anything emitted prior (so, after, since we're emitting in
    // reverse).
    for (auto& entry : shifts) {
        Vector<ShufflePair>& shift = entry.value;
        if (shift.last().dst().isTmp())
            handleShift(shift);
        commitResult();
    }

    // Now handle the rest of the shifts.
    for (auto& entry : shifts) {
        Vector<ShufflePair>& shift = entry.value;
        if (!shift.last().dst().isTmp())
            handleShift(shift);
        commitResult();
    }

    for (Rotate& rotate : rotates) {
        if (!rotate.fringe.isEmpty()) {
            // Make sure we do the fringe first! This won't clobber any of the registers that are
            // part of the rotation.
            handleShift(rotate.fringe);
        }
        
        bool canSwap = false;
        Opcode swap = Oops;
        Arg::Width swapWidth = Arg::Width8; // bogus value
        
        if (type == Arg::GP) {
            swap = Swap32;
            swapWidth = Arg::Width32;
            for (ShufflePair& pair : rotate.loop) {
                switch (pair.width()) {
                case Arg::Width32:
                    break;
                case Arg::Width64:
                    swap = Swap64;
                    swapWidth = Arg::Width64;
                    break;
                default:
                    RELEASE_ASSERT_NOT_REACHED();
                    break;
                }
            }
            
            canSwap = isValidForm(swap, Arg::Tmp, Arg::Tmp);
            for (ShufflePair& pair : rotate.loop) {
                if (pair.src().isMemory() || pair.dst().isMemory()) {
                    canSwap &= isValidForm(swap, Arg::Tmp, Arg::Addr);

                    // We don't take the swapping path if there is a mix of widths and some of the
                    // shuffles involve memory. That gets too confusing.
                    canSwap &= (pair.width() < swapWidth);
                }
            }
        }

        if (canSwap) {
            for (unsigned i = rotate.loop.size() - 1; i--;) {
                Arg left = rotate.loop[i].src();
                Arg right = rotate.loop[i + 1].src();

                if (left.isMemory() && right.isMemory()) {
                    // Note that this is a super rare outcome. Rotates are rare. Spills are rare.
                    // Moving data between two spills is rare. To get here a lot of rare stuff has to
                    // all happen at once.
                    
                    Tmp scratch = getScratch(0, findPossibleScratch(type, left, right));
                    RELEASE_ASSERT(scratch);
                    result.append(Inst(moveForWidth(swapWidth), origin, left, scratch));
                    result.append(Inst(swap, origin, scratch, right));
                    result.append(Inst(moveForWidth(swapWidth), origin, scratch, left));
                    returnScratch(0, scratch);
                    continue;
                }

                if (left.isMemory())
                    std::swap(left, right);
                
                result.append(Inst(swap, origin, left, right));
            }

            for (ShufflePair pair : rotate.loop) {
                if (pair.width() == swapWidth)
                    continue;

                RELEASE_ASSERT(pair.width() == Arg::Width32);
                RELEASE_ASSERT(swapWidth == Arg::Width64);
                RELEASE_ASSERT(pair.dst().isTmp());

                // Need to do an extra zero extension.
                result.append(Inst(Move32, origin, pair.dst(), pair.dst()));
            }
        } else {
            // We can treat this as a shift so long as we take the last destination (i.e. first
            // source) and save it first. Then we handle the first entry in the pair in the rotate
            // specially, after we restore the last destination. This requires some special care to
            // find a scratch register. It's possible that we have a rotate that uses the entire
            // available register file.

            Tmp scratch = findPossibleScratch(
                type,
                [&] (Tmp tmp) -> bool {
                    for (ShufflePair pair : rotate.loop) {
                        if (pair.src().usesTmp(tmp))
                            return false;
                        if (pair.dst().usesTmp(tmp))
                            return false;
                    }
                    return true;
                });

            scratch = getScratch(0, scratch);

            Arg rotateSave = scratch ? Arg(scratch) : scratches[0];
            
            handleShiftPair(
                ShufflePair(rotate.loop.last().dst(), rotateSave, rotate.loop[0].width()), 1);

            for (unsigned i = rotate.loop.size(); i-- > 1;)
                handleShiftPair(rotate.loop[i], 1);

            handleShiftPair(
                ShufflePair(rotateSave, rotate.loop[0].dst(), rotate.loop[0].width()), 1);

            if (scratch)
                returnScratch(0, scratch);
        }

        commitResult();
    }

    ASSERT(result.isEmpty());

    for (unsigned i = resultPacks.size(); i--;)
        result.appendVector(resultPacks[i]);

    return result;
}

Vector<Inst> emitShuffle(
    const Vector<ShufflePair>& pairs,
    const std::array<Arg, 2>& gpScratch, const std::array<Arg, 2>& fpScratch,
    Value* origin)
{
    Vector<ShufflePair> gpPairs;
    Vector<ShufflePair> fpPairs;
    for (const ShufflePair& pair : pairs) {
        if (pair.src().isMemory() && pair.dst().isMemory() && pair.width() > Arg::pointerWidth()) {
            // 8-byte memory-to-memory moves on a 32-bit platform are best handled as float moves.
            fpPairs.append(pair);
        } else if (pair.src().isGP() && pair.dst().isGP()) {
            // This means that gpPairs gets memory-to-memory shuffles. The assumption is that we
            // can do that more efficiently using GPRs, except in the special case above.
            gpPairs.append(pair);
        } else
            fpPairs.append(pair);
    }

    Vector<Inst> result;
    result.appendVector(emitShuffle(gpPairs, gpScratch, Arg::GP, origin));
    result.appendVector(emitShuffle(fpPairs, fpScratch, Arg::FP, origin));
    return result;
}

} } } // namespace JSC::B3::Air

#endif // ENABLE(B3_JIT)




/*
 * Copyright (C) 2016 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 */

#ifndef AirEmitShuffle_h
#define AirEmitShuffle_h

#if ENABLE(B3_JIT)

#include "AirArg.h"
#include "AirInst.h"
#include <wtf/Vector.h>

namespace JSC { namespace B3 {

class Value;

namespace Air {

class ShufflePair {
public:
    ShufflePair()
    {
    }
    
    ShufflePair(const Arg& src, const Arg& dst, Arg::Width width)
        : m_src(src)
        , m_dst(dst)
        , m_width(width)
    {
    }

    const Arg& src() const { return m_src; }
    const Arg& dst() const { return m_dst; }

    // The width determines the kind of move we do. You can only choose Width32 or Width64 right now.
    // For GP, it picks between Move32 and Move. For FP, it picks between MoveFloat and MoveDouble.
    Arg::Width width() const { return m_width; }

    void dump(PrintStream&) const;
    
private:
    Arg m_src;
    Arg m_dst;
    Arg::Width m_width { Arg::Width8 };
};

// Perform a shuffle of a given type. The scratch argument is mandatory. You should pass it as
// follows: If you know that you have scratch registers or temporaries available - that is, they're
// registers that are not mentioned in the shuffle, have the same type as the shuffle, and are not
// live at the shuffle - then you can pass them. If you don't have scratch registers available or if
// you don't feel like looking for them, you can pass memory locations. It's always safe to pass a
// pair of memory locations, and replacing either memory location with a register can be viewed as an
// optimization. It's a pretty important optimization. Some more notes:
//
// - We define scratch registers as things that are not live before the shuffle and are not one of
//   the destinations of the shuffle. Not being live before the shuffle also means that they cannot
//   be used 
//
// - A second scratch location is only needed when you have shuffle pairs where memory is used both
//   as source and destination.
//
// - You're guaranteed not to need any scratch locations if there is a Swap instruction available for
//   the type and you don't have any memory locations that are both the source and the destination of
//   some pairs. GP supports Swap on x86 while FP never supports Swap.
//
// - Passing memory locations as scratch if are running emitShuffle() before register allocation is
//   silly, since that will cause emitShuffle() to pick some specific registers when it does need
//   scratch. One easy way to avoid that predicament is to ensure that you call emitShuffle() after
//   register allocation. For this reason we could add a Shuffle instruction so that we can defer
//   shufflings until after regalloc.
//
// - Shuffles with memory=>memory pairs are not very well tuned. You should avoid them if you want
//   performance. If you need to do them, then making sure that you reserve a temporary is one way to
//   get acceptable performance.
Vector<Inst> emitShuffle(
    Vector<ShufflePair>, std::array<Arg, 2> scratch, Arg::Type, Value* origin);

// Perform a shuffle that involves any number of types. Pass scratch registers or memory locations
// for each type according to the rules above.
Vector<Inst> emitShuffle(
    const Vector<ShufflePair>&,
    const std::array<Arg, 2>& gpScratch, const std::array<Arg, 2>& fpScratch,
    Value* origin);

} } } // namespace JSC::B3::Air

#endif // ENABLE(B3_JIT)

#endif // AirEmitShuffle_h


Lines 1-5 Source/JavaScriptCore/b3/air/AirGenerate.cpp_sec1
- Source/JavaScriptCore/b3/air/AirGenerate.cpp -1 / +7 lines
1	/*	1	/*
2	* Copyright (C) 2015 Apple Inc. All rights reserved.	2	* Copyright (C) 2015-2016 Apple Inc. All rights reserved.
3	*	3	*
4	* Redistribution and use in source and binary forms, with or without	4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions	5	* modification, are permitted provided that the following conditions
Lines 35-40 Source/JavaScriptCore/b3/air/AirGenerate.cpp_sec2
35	#include "AirGenerationContext.h"	35	#include "AirGenerationContext.h"
36	#include "AirHandleCalleeSaves.h"	36	#include "AirHandleCalleeSaves.h"
37	#include "AirIteratedRegisterCoalescing.h"	37	#include "AirIteratedRegisterCoalescing.h"
		38	#include "AirLowerAfterRegAlloc.h"
		39	#include "AirLowerMacros.h"
38	#include "AirOpcodeUtils.h"	40	#include "AirOpcodeUtils.h"
39	#include "AirOptimizeBlockOrder.h"	41	#include "AirOptimizeBlockOrder.h"
40	#include "AirReportUsedRegisters.h"	42	#include "AirReportUsedRegisters.h"
Lines 65-70 void prepareForGeneration(Code& code) Source/JavaScriptCore/b3/air/AirGenerate.cpp_sec3
65	dataLog(code);	67	dataLog(code);
66	}	68	}
67		69
		70	lowerMacros(code);
		71
68	// This is where we run our optimizations and transformations.	72	// This is where we run our optimizations and transformations.
69	// FIXME: Add Air optimizations.	73	// FIXME: Add Air optimizations.
70	// https://bugs.webkit.org/show_bug.cgi?id=150456	74	// https://bugs.webkit.org/show_bug.cgi?id=150456
Lines 80-85 void prepareForGeneration(Code& code) Source/JavaScriptCore/b3/air/AirGenerate.cpp_sec4
80	else	84	else
81	iteratedRegisterCoalescing(code);	85	iteratedRegisterCoalescing(code);
82		86
		87	lowerAfterRegAlloc(code);
		88
83	// Prior to this point the prologue and epilogue is implicit. This makes it explicit. It also	89	// Prior to this point the prologue and epilogue is implicit. This makes it explicit. It also
84	// does things like identify which callee-saves we're using and saves them.	90	// does things like identify which callee-saves we're using and saves them.
85	handleCalleeSaves(code);	91	handleCalleeSaves(code);



/*
 * Copyright (C) 2015-2016 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions


// This takes an Air::Code that hasn't had any stack allocation and optionally hasn't had any
// register allocation and does both of those things.
JS_EXPORT_PRIVATE void prepareForGeneration(Code&);

// This generates the code using the given CCallHelpers instance. Note that this may call callbacks
// in the supplied code as it is generating.
JS_EXPORT_PRIVATE void generate(Code&, CCallHelpers&);

} } } // namespace JSC::B3::Air




/*
 * Copyright (C) 2015-2016 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions


namespace JSC { namespace B3 { namespace Air {

void InsertionSet::insertInsts(size_t index, const Vector<Inst>& insts)
{
    for (const Inst& inst : insts)
        insertInst(index, inst);
}

void InsertionSet::insertInsts(size_t index, Vector<Inst>&& insts)
{
    for (Inst& inst : insts)
        insertInst(index, WTFMove(inst));
}

void InsertionSet::execute(BasicBlock* block)
{
    bubbleSort(m_insertions.begin(), m_insertions.end());

Lines 1-5 Source/JavaScriptCore/b3/air/AirInsertionSet.h_sec1
- Source/JavaScriptCore/b3/air/AirInsertionSet.h -1 / +4 lines
1	/*	1	/*
2	* Copyright (C) 2015 Apple Inc. All rights reserved.	2	* Copyright (C) 2015-2016 Apple Inc. All rights reserved.
3	*	3	*
4	* Redistribution and use in source and binary forms, with or without	4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions	5	* modification, are permitted provided that the following conditions
Lines 59-64 public: Source/JavaScriptCore/b3/air/AirInsertionSet.h_sec2
59	{	59	{
60	appendInsertion(Insertion(index, std::forward<Inst>(inst)));	60	appendInsertion(Insertion(index, std::forward<Inst>(inst)));
61	}	61	}
		62
		63	void insertInsts(size_t index, const Vector<Inst>&);
		64	void insertInsts(size_t index, Vector<Inst>&&);
62		65
63	template<typename... Arguments>	66	template<typename... Arguments>
64	void insert(size_t index, Arguments&&... arguments)	67	void insert(size_t index, Arguments&&... arguments)

Lines 85-90 public: Source/JavaScriptCore/b3/air/AirInst.h_sec1
- Source/JavaScriptCore/b3/air/AirInst.h +9 lines
85		85
86	explicit operator bool() const { return origin \|\| opcode != Nop \|\| args.size(); }	86	explicit operator bool() const { return origin \|\| opcode != Nop \|\| args.size(); }
87		87
		88	void append() { }
		89
		90	template<typename... Arguments>
		91	void append(Arg arg, Arguments... arguments)
		92	{
		93	args.append(arg);
		94	append(arguments...);
		95	}
		96
88	// Note that these functors all avoid using "const" because we want to use them for things that	97	// Note that these functors all avoid using "const" because we want to use them for things that
89	// edit IR. IR is meant to be edited; if you're carrying around a "const Inst&" then you're	98	// edit IR. IR is meant to be edited; if you're carrying around a "const Inst&" then you're
90	// probably doing it wrong.	99	// probably doing it wrong.



/*
 * Copyright (C) 2016 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 */

#include "config.h"
#include "AirLowerAfterRegAlloc.h"

#if ENABLE(B3_JIT)

#include "AirCCallingConvention.h"
#include "AirCode.h"
#include "AirEmitShuffle.h"
#include "AirInsertionSet.h"
#include "AirInstInlines.h"
#include "AirLiveness.h"
#include "AirPhaseScope.h"
#include "AirRegisterPriority.h"
#include "B3CCallValue.h"
#include "RegisterSet.h"
#include <wtf/HashMap.h>

namespace JSC { namespace B3 { namespace Air {

void lowerAfterRegAlloc(Code& code)
{
    PhaseScope phaseScope(code, "lowerAfterRegAlloc");

    HashMap<Inst*, RegisterSet> usedRegisters;

    RegLiveness liveness(code);
    for (BasicBlock* block : code) {
        RegLiveness::LocalCalc localCalc(liveness, block);

        for (unsigned instIndex = block->size(); instIndex--;) {
            Inst& inst = block->at(instIndex);
            
            RegisterSet set;

            if (inst.opcode == Shuffle || inst.opcode == ColdCCall) {
                for (Reg reg : localCalc.live())
                    set.set(reg);
            }
            
            localCalc.execute(instIndex);

            if (set.numberOfSetRegisters())
                usedRegisters.add(&inst, set);
        }
    }

    auto getScratches = [&] (const RegisterSet& set, Arg::Type type) -> std::array<Arg, 2> {
        std::array<Arg, 2> result;
        for (unsigned i = 0; i < 2; ++i) {
            bool found = false;
            for (Reg reg : regsInPriorityOrder(type)) {
                if (!set.get(reg)) {
                    result[i] = Tmp(reg);
                    found = true;
                    break;
                }
            }
            if (!found) {
                result[i] = Arg::stack(
                    code.addStackSlot(
                        Arg::bytes(Arg::conservativeWidth(type)),
                        StackSlotKind::Anonymous));
            }
        }
        return result;
    };

    // Now transform the code.
    InsertionSet insertionSet(code);
    for (BasicBlock* block : code) {
        for (unsigned instIndex = 0; instIndex < block->size(); ++instIndex) {
            Inst& inst = block->at(instIndex);

            switch (inst.opcode) {
            case Shuffle: {
                RegisterSet set = usedRegisters.get(&inst);
                Vector<ShufflePair> pairs;
                for (unsigned i = 0; i < inst.args.size(); i += 3) {
                    Arg src = inst.args[i + 0];
                    Arg dst = inst.args[i + 1];
                    Arg::Width width = inst.args[i + 2].width();
                    if (src.isReg())
                        set.set(src.reg());
                    pairs.append(ShufflePair(src, dst, width));
                }
                std::array<Arg, 2> gpScratch = getScratches(set, Arg::GP);
                std::array<Arg, 2> fpScratch = getScratches(set, Arg::FP);
                insertionSet.insertInsts(
                    instIndex, emitShuffle(pairs, gpScratch, fpScratch, inst.origin));
                inst = Inst();
                break;
            }

            case ColdCCall: {
                CCallValue* value = inst.origin->as<CCallValue>();

                RegisterSet preUsed;
                Vector<Arg> destinations = computeCCallingConvention(code, value);
                Tmp result = cCallResult(value->type());
                
                Vector<ShufflePair> pairs;
                for (unsigned i = 0; i < destinations.size(); ++i) {
                    Value* child = value->child(i);
                    Arg src = inst.args[result ? (i >= 1 ? i + 1 : i) : i ];
                    Arg dst = destinations[i];
                    Arg::Width width = Arg::widthForB3Type(child->type());
                    pairs.append(ShufflePair(src, dst, width));
                    if (src.isReg())
                        preUsed.set(src.reg());
                }

                std::array<Arg, 2> gpScratch = getScratches(preUsed, Arg::GP);
                std::array<Arg, 2> fpScratch = getScratches(preUsed, Arg::FP);
                
                RegisterSet regsToSave = usedRegisters.get(&inst);

                // Also need to save all live registers. Don't need to worry about the result
                // register.
                if (result)
                    regsToSave.clear(result.reg());
                Vector<StackSlot*> stackSlots;
                regsToSave.forEach(
                    [&] (Reg reg) {
                        Tmp tmp(reg);
                        Arg arg(tmp);
                        Arg::Width width = Arg::conservativeWidth(arg.type());
                        StackSlot* stackSlot =
                            code.addStackSlot(Arg::bytes(width), StackSlotKind::Anonymous);
                        pairs.append(ShufflePair(arg, Arg::stack(stackSlot), width));
                        stackSlots.append(stackSlot);
                    });
                
                insertionSet.insertInsts(
                    instIndex, emitShuffle(pairs, gpScratch, fpScratch, inst.origin));

                inst = buildCCall(code, inst.origin, destinations);

                // Now we need to emit code to restore registers.
                pairs.resize(0);
                unsigned stackSlotIndex = 0;
                regsToSave.forEach(
                    [&] (Reg reg) {
                        Tmp tmp(reg);
                        Arg arg(tmp);
                        Arg::Width width = Arg::conservativeWidth(arg.type());
                        StackSlot* stackSlot = stackSlots[stackSlotIndex++];
                        pairs.append(ShufflePair(Arg::stack(stackSlot), arg, width));
                    });
                if (result) {
                    ShufflePair pair(result, inst.args[1], Arg::widthForB3Type(value->type()));
                    pairs.append(pair);
                }

                if (result)
                    regsToSave.set(result.reg());
                
                gpScratch = getScratches(regsToSave, Arg::GP);
                fpScratch = getScratches(regsToSave, Arg::FP);
                
                insertionSet.insertInsts(
                    instIndex + 1, emitShuffle(pairs, gpScratch, fpScratch, inst.origin));
                break;
            }

            default:
                break;
            }
        }

        insertionSet.execute(block);

        block->insts().removeAllMatching(
            [&] (Inst& inst) -> bool {
                return !inst;
            });
    }
}

} } } // namespace JSC::B3::Air

#endif // ENABLE(B3_JIT)




/*
 * Copyright (C) 2016 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 */

#ifndef AirLowerAfterRegAlloc_h
#define AirLowerAfterRegAlloc_h

#if ENABLE(B3_JIT)

namespace JSC { namespace B3 { namespace Air {

class Code;

// This lowers Shuffle and ColdCCall instructions. This phase is designed to be run after register
// allocation.

void lowerAfterRegAlloc(Code&);

} } } // namespace JSC::B3::Air

#endif // ENABLE(B3_JIT)

#endif // AirLowerAfterRegAlloc_h



/*
 * Copyright (C) 2016 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 */

#include "config.h"
#include "AirLowerMacros.h"

#if ENABLE(B3_JIT)

#include "AirCCallingConvention.h"
#include "AirCode.h"
#include "AirInsertionSet.h"
#include "AirInstInlines.h"
#include "AirPhaseScope.h"
#include "B3CCallValue.h"
#include "B3ValueInlines.h"

namespace JSC { namespace B3 { namespace Air {

void lowerMacros(Code& code)
{
    PhaseScope phaseScope(code, "lowerMacros");

    InsertionSet insertionSet(code);
    for (BasicBlock* block : code) {
        for (unsigned instIndex = 0; instIndex < block->size(); ++instIndex) {
            Inst& inst = block->at(instIndex);

            switch (inst.opcode) {
            case CCall: {
                CCallValue* value = inst.origin->as<CCallValue>();

                Vector<Arg> destinations = computeCCallingConvention(code, value);

                Inst shuffleArguments(Shuffle, value);
                unsigned offset = value->type() == Void ? 0 : 1;
                for (unsigned i = 1; i < destinations.size(); ++i) {
                    Value* child = value->child(i);
                    shuffleArguments.args.append(inst.args[offset + i]);
                    shuffleArguments.args.append(destinations[i]);
                    shuffleArguments.args.append(Arg::widthArg(Arg::widthForB3Type(child->type())));
                }
                insertionSet.insertInst(instIndex, WTFMove(shuffleArguments));

                // Indicate that we're using our original callee argument.
                destinations[0] = inst.args[0];

                // Save where the original instruction put its result.
                Arg resultDst = value->type() == Void ? Arg() : inst.args[1];
                
                inst = buildCCall(code, inst.origin, destinations);

                Tmp result = cCallResult(value->type());
                switch (value->type()) {
                case Void:
                    break;
                case Float:
                    insertionSet.insert(instIndex + 1, MoveFloat, value, result, resultDst);
                    break;
                case Double:
                    insertionSet.insert(instIndex + 1, MoveDouble, value, result, resultDst);
                    break;
                case Int32:
                    insertionSet.insert(instIndex + 1, Move32, value, result, resultDst);
                    break;
                case Int64:
                    insertionSet.insert(instIndex + 1, Move, value, result, resultDst);
                    break;
                }
                break;
            }

            default:
                break;
            }
        }
        insertionSet.execute(block);
    }
}

} } } // namespace JSC::B3::Air

#endif // ENABLE(B3_JIT)




/*
 * Copyright (C) 2016 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 */

#ifndef AirLowerMacros_h
#define AirLowerMacros_h

#if ENABLE(B3_JIT)

namespace JSC { namespace B3 { namespace Air {

class Code;

// Air has some opcodes that are very high-level and are meant to reduce the amount of low-level
// knowledge in the B3->Air lowering. The current example is CCall.

void lowerMacros(Code&);

} } } // namespace JSC::B3::Air

#endif // ENABLE(B3_JIT)

#endif // AirLowerMacros_h


Lines 407-412 Move U:G:Ptr, D:G:Ptr Source/JavaScriptCore/b3/air/AirOpcode.opcodes_sec1
- Source/JavaScriptCore/b3/air/AirOpcode.opcodes +20 lines
407	Tmp, Index as storePtr	407	Tmp, Index as storePtr
408	x86: Imm, Addr as storePtr	408	x86: Imm, Addr as storePtr
409		409
		410	x86: Swap32 UD:G:32, UD:G:32
		411	Tmp, Tmp
		412	Tmp, Addr
		413
		414	x86_64: Swap64 UD:G:64, UD:G:64
		415	Tmp, Tmp
		416	Tmp, Addr
		417
410	Move32 U:G:32, ZD:G:32	418	Move32 U:G:32, ZD:G:32
411	Tmp, Tmp as zeroExtend32ToPtr	419	Tmp, Tmp as zeroExtend32ToPtr
412	Addr, Tmp as load32	420	Addr, Tmp as load32
Lines 672-678 RetDouble U:F:64 /return Source/JavaScriptCore/b3/air/AirOpcode.opcodes_sec2
672		680
673	Oops /terminal	681	Oops /terminal
674		682
		683	# A Shuffle is a multi-source, multi-destination move. It simultaneously does multiple moves at once.
		684	# The moves are specified as triplets of src, dst, and width. For example you can request a swap this
		685	# way:
		686	# Shuffle %tmp1, %tmp2, 64, %tmp2, %tmp1, 64
		687	custom Shuffle
		688
675	# Air allows for exotic behavior. A Patch's behavior is determined entirely by the Special operand,	689	# Air allows for exotic behavior. A Patch's behavior is determined entirely by the Special operand,
676	# which must be the first operand.	690	# which must be the first operand.
677	custom Patch	691	custom Patch
678		692
		693	# Instructions used for lowering C calls. These don't make it to Air generation. They get lowered to
		694	# something else first. The origin Value must be a CCallValue.
		695	custom CCall
		696	custom ColdCCall
		697
		698



/*
 * Copyright (C) 2015-2016 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions

    return RegistersInPriorityOrder<Bank>::inPriorityOrder();
}

JS_EXPORT_PRIVATE const Vector<Reg>& regsInPriorityOrder(Arg::Type);

} } } // namespace JSC::B3::Air




/*
 * Copyright (C) 2016 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 */

#include "config.h"

#include "AirCode.h"
#include "AirGenerate.h"
#include "AirInstInlines.h"
#include "AirRegisterPriority.h"
#include "AllowMacroScratchRegisterUsage.h"
#include "B3Compilation.h"
#include "B3Procedure.h"
#include "CCallHelpers.h"
#include "InitializeThreading.h"
#include "JSCInlines.h"
#include "LinkBuffer.h"
#include "PureNaN.h"
#include "VM.h"
#include <cmath>
#include <string>
#include <wtf/Lock.h>
#include <wtf/NumberOfCores.h>
#include <wtf/Threading.h>

// We don't have a NO_RETURN_DUE_TO_EXIT, nor should we. That's ridiculous.
static bool hiddenTruthBecauseNoReturnIsStupid() { return true; }

static void usage()
{
    dataLog("Usage: testb3 [<filter>]\n");
    if (hiddenTruthBecauseNoReturnIsStupid())
        exit(1);
}

#if ENABLE(B3_JIT)

using namespace JSC;
using namespace JSC::B3::Air;

namespace {

StaticLock crashLock;

// Nothing fancy for now; we just use the existing WTF assertion machinery.
#define CHECK(x) do {                                                   \
        if (!!(x))                                                      \
            break;                                                      \
        crashLock.lock();                                               \
        WTFReportAssertionFailure(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, #x); \
        CRASH();                                                        \
    } while (false)

VM* vm;

std::unique_ptr<B3::Compilation> compile(B3::Procedure& proc)
{
    prepareForGeneration(proc.code());
    CCallHelpers jit(vm);
    generate(proc.code(), jit);
    LinkBuffer linkBuffer(*vm, jit, nullptr);

    return std::make_unique<B3::Compilation>(
        FINALIZE_CODE(linkBuffer, ("testair compilation")), proc.releaseByproducts());
}

template<typename T, typename... Arguments>
T invoke(const B3::Compilation& code, Arguments... arguments)
{
    T (*function)(Arguments...) = bitwise_cast<T(*)(Arguments...)>(code.code().executableAddress());
    return function(arguments...);
}

template<typename T, typename... Arguments>
T compileAndRun(B3::Procedure& procedure, Arguments... arguments)
{
    return invoke<T>(*compile(procedure), arguments...);
}

void testSimple()
{
    B3::Procedure proc;
    Code& code = proc.code();

    BasicBlock* root = code.addBlock();
    root->append(Move, nullptr, Arg::imm(42), Tmp(GPRInfo::returnValueGPR));
    root->append(Ret32, nullptr, Tmp(GPRInfo::returnValueGPR));

    CHECK(compileAndRun<int>(proc) == 42);
}

void testShuffleSimpleSwap()
{
    B3::Procedure proc;
    Code& code = proc.code();

    BasicBlock* root = code.addBlock();
    root->append(Move, nullptr, Arg::imm(1), Tmp(GPRInfo::regT0));
    root->append(Move, nullptr, Arg::imm(2), Tmp(GPRInfo::regT1));
    root->append(Move, nullptr, Arg::imm(3), Tmp(GPRInfo::regT2));
    root->append(Move, nullptr, Arg::imm(4), Tmp(GPRInfo::regT3));
    root->append(
        Shuffle, nullptr,
        Tmp(GPRInfo::regT2), Tmp(GPRInfo::regT3), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT3), Tmp(GPRInfo::regT2), Arg::widthArg(Arg::Width32));

    int32_t things[4];
    Tmp base = code.newTmp(Arg::GP);
    root->append(Move, nullptr, Arg::imm64(bitwise_cast<intptr_t>(&things)), base);
    root->append(Move32, nullptr, Tmp(GPRInfo::regT0), Arg::addr(base, 0 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT1), Arg::addr(base, 1 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT2), Arg::addr(base, 2 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT3), Arg::addr(base, 3 * sizeof(int32_t)));
    root->append(Move, nullptr, Arg::imm(0), Tmp(GPRInfo::returnValueGPR));
    root->append(Ret32, nullptr, Tmp(GPRInfo::returnValueGPR));

    memset(things, 0, sizeof(things));
    
    CHECK(!compileAndRun<int>(proc));

    CHECK(things[0] == 1);
    CHECK(things[1] == 2);
    CHECK(things[2] == 4);
    CHECK(things[3] == 3);
}

void testShuffleSimpleShift()
{
    B3::Procedure proc;
    Code& code = proc.code();

    BasicBlock* root = code.addBlock();
    root->append(Move, nullptr, Arg::imm(1), Tmp(GPRInfo::regT0));
    root->append(Move, nullptr, Arg::imm(2), Tmp(GPRInfo::regT1));
    root->append(Move, nullptr, Arg::imm(3), Tmp(GPRInfo::regT2));
    root->append(Move, nullptr, Arg::imm(4), Tmp(GPRInfo::regT3));
    root->append(
        Shuffle, nullptr,
        Tmp(GPRInfo::regT2), Tmp(GPRInfo::regT3), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT3), Tmp(GPRInfo::regT4), Arg::widthArg(Arg::Width32));

    int32_t things[5];
    Tmp base = code.newTmp(Arg::GP);
    root->append(Move, nullptr, Arg::imm64(bitwise_cast<intptr_t>(&things)), base);
    root->append(Move32, nullptr, Tmp(GPRInfo::regT0), Arg::addr(base, 0 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT1), Arg::addr(base, 1 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT2), Arg::addr(base, 2 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT3), Arg::addr(base, 3 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT4), Arg::addr(base, 4 * sizeof(int32_t)));
    root->append(Move, nullptr, Arg::imm(0), Tmp(GPRInfo::returnValueGPR));
    root->append(Ret32, nullptr, Tmp(GPRInfo::returnValueGPR));

    memset(things, 0, sizeof(things));
    
    CHECK(!compileAndRun<int>(proc));

    CHECK(things[0] == 1);
    CHECK(things[1] == 2);
    CHECK(things[2] == 3);
    CHECK(things[3] == 3);
    CHECK(things[4] == 4);
}

void testShuffleLongShift()
{
    B3::Procedure proc;
    Code& code = proc.code();

    BasicBlock* root = code.addBlock();
    root->append(Move, nullptr, Arg::imm(1), Tmp(GPRInfo::regT0));
    root->append(Move, nullptr, Arg::imm(2), Tmp(GPRInfo::regT1));
    root->append(Move, nullptr, Arg::imm(3), Tmp(GPRInfo::regT2));
    root->append(Move, nullptr, Arg::imm(4), Tmp(GPRInfo::regT3));
    root->append(Move, nullptr, Arg::imm(5), Tmp(GPRInfo::regT4));
    root->append(Move, nullptr, Arg::imm(6), Tmp(GPRInfo::regT5));
    root->append(Move, nullptr, Arg::imm(7), Tmp(GPRInfo::regT6));
    root->append(Move, nullptr, Arg::imm(8), Tmp(GPRInfo::regT7));
    root->append(
        Shuffle, nullptr,
        Tmp(GPRInfo::regT0), Tmp(GPRInfo::regT1), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT1), Tmp(GPRInfo::regT2), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT2), Tmp(GPRInfo::regT3), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT3), Tmp(GPRInfo::regT4), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT4), Tmp(GPRInfo::regT5), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT5), Tmp(GPRInfo::regT6), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT6), Tmp(GPRInfo::regT7), Arg::widthArg(Arg::Width32));

    int32_t things[8];
    Tmp base = code.newTmp(Arg::GP);
    root->append(Move, nullptr, Arg::imm64(bitwise_cast<intptr_t>(&things)), base);
    root->append(Move32, nullptr, Tmp(GPRInfo::regT0), Arg::addr(base, 0 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT1), Arg::addr(base, 1 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT2), Arg::addr(base, 2 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT3), Arg::addr(base, 3 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT4), Arg::addr(base, 4 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT5), Arg::addr(base, 5 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT6), Arg::addr(base, 6 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT7), Arg::addr(base, 7 * sizeof(int32_t)));
    root->append(Move, nullptr, Arg::imm(0), Tmp(GPRInfo::returnValueGPR));
    root->append(Ret32, nullptr, Tmp(GPRInfo::returnValueGPR));

    memset(things, 0, sizeof(things));
    
    CHECK(!compileAndRun<int>(proc));

    CHECK(things[0] == 1);
    CHECK(things[1] == 1);
    CHECK(things[2] == 2);
    CHECK(things[3] == 3);
    CHECK(things[4] == 4);
    CHECK(things[5] == 5);
    CHECK(things[6] == 6);
    CHECK(things[7] == 7);
}

void testShuffleLongShiftBackwards()
{
    B3::Procedure proc;
    Code& code = proc.code();

    BasicBlock* root = code.addBlock();
    root->append(Move, nullptr, Arg::imm(1), Tmp(GPRInfo::regT0));
    root->append(Move, nullptr, Arg::imm(2), Tmp(GPRInfo::regT1));
    root->append(Move, nullptr, Arg::imm(3), Tmp(GPRInfo::regT2));
    root->append(Move, nullptr, Arg::imm(4), Tmp(GPRInfo::regT3));
    root->append(Move, nullptr, Arg::imm(5), Tmp(GPRInfo::regT4));
    root->append(Move, nullptr, Arg::imm(6), Tmp(GPRInfo::regT5));
    root->append(Move, nullptr, Arg::imm(7), Tmp(GPRInfo::regT6));
    root->append(Move, nullptr, Arg::imm(8), Tmp(GPRInfo::regT7));
    root->append(
        Shuffle, nullptr,
        Tmp(GPRInfo::regT6), Tmp(GPRInfo::regT7), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT5), Tmp(GPRInfo::regT6), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT4), Tmp(GPRInfo::regT5), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT3), Tmp(GPRInfo::regT4), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT2), Tmp(GPRInfo::regT3), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT1), Tmp(GPRInfo::regT2), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT0), Tmp(GPRInfo::regT1), Arg::widthArg(Arg::Width32));

    int32_t things[8];
    Tmp base = code.newTmp(Arg::GP);
    root->append(Move, nullptr, Arg::imm64(bitwise_cast<intptr_t>(&things)), base);
    root->append(Move32, nullptr, Tmp(GPRInfo::regT0), Arg::addr(base, 0 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT1), Arg::addr(base, 1 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT2), Arg::addr(base, 2 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT3), Arg::addr(base, 3 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT4), Arg::addr(base, 4 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT5), Arg::addr(base, 5 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT6), Arg::addr(base, 6 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT7), Arg::addr(base, 7 * sizeof(int32_t)));
    root->append(Move, nullptr, Arg::imm(0), Tmp(GPRInfo::returnValueGPR));
    root->append(Ret32, nullptr, Tmp(GPRInfo::returnValueGPR));

    memset(things, 0, sizeof(things));
    
    CHECK(!compileAndRun<int>(proc));

    CHECK(things[0] == 1);
    CHECK(things[1] == 1);
    CHECK(things[2] == 2);
    CHECK(things[3] == 3);
    CHECK(things[4] == 4);
    CHECK(things[5] == 5);
    CHECK(things[6] == 6);
    CHECK(things[7] == 7);
}

void testShuffleSimpleRotate()
{
    B3::Procedure proc;
    Code& code = proc.code();

    BasicBlock* root = code.addBlock();
    root->append(Move, nullptr, Arg::imm(1), Tmp(GPRInfo::regT0));
    root->append(Move, nullptr, Arg::imm(2), Tmp(GPRInfo::regT1));
    root->append(Move, nullptr, Arg::imm(3), Tmp(GPRInfo::regT2));
    root->append(Move, nullptr, Arg::imm(4), Tmp(GPRInfo::regT3));
    root->append(
        Shuffle, nullptr,
        Tmp(GPRInfo::regT0), Tmp(GPRInfo::regT1), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT1), Tmp(GPRInfo::regT2), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT2), Tmp(GPRInfo::regT0), Arg::widthArg(Arg::Width32));

    int32_t things[4];
    Tmp base = code.newTmp(Arg::GP);
    root->append(Move, nullptr, Arg::imm64(bitwise_cast<intptr_t>(&things)), base);
    root->append(Move32, nullptr, Tmp(GPRInfo::regT0), Arg::addr(base, 0 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT1), Arg::addr(base, 1 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT2), Arg::addr(base, 2 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT3), Arg::addr(base, 3 * sizeof(int32_t)));
    root->append(Move, nullptr, Arg::imm(0), Tmp(GPRInfo::returnValueGPR));
    root->append(Ret32, nullptr, Tmp(GPRInfo::returnValueGPR));

    memset(things, 0, sizeof(things));
    
    CHECK(!compileAndRun<int>(proc));

    CHECK(things[0] == 3);
    CHECK(things[1] == 1);
    CHECK(things[2] == 2);
    CHECK(things[3] == 4);
}

void testShuffleSimpleBroadcast()
{
    B3::Procedure proc;
    Code& code = proc.code();

    BasicBlock* root = code.addBlock();
    root->append(Move, nullptr, Arg::imm(1), Tmp(GPRInfo::regT0));
    root->append(Move, nullptr, Arg::imm(2), Tmp(GPRInfo::regT1));
    root->append(Move, nullptr, Arg::imm(3), Tmp(GPRInfo::regT2));
    root->append(Move, nullptr, Arg::imm(4), Tmp(GPRInfo::regT3));
    root->append(
        Shuffle, nullptr,
        Tmp(GPRInfo::regT0), Tmp(GPRInfo::regT1), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT0), Tmp(GPRInfo::regT2), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT0), Tmp(GPRInfo::regT3), Arg::widthArg(Arg::Width32));

    int32_t things[4];
    Tmp base = code.newTmp(Arg::GP);
    root->append(Move, nullptr, Arg::imm64(bitwise_cast<intptr_t>(&things)), base);
    root->append(Move32, nullptr, Tmp(GPRInfo::regT0), Arg::addr(base, 0 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT1), Arg::addr(base, 1 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT2), Arg::addr(base, 2 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT3), Arg::addr(base, 3 * sizeof(int32_t)));
    root->append(Move, nullptr, Arg::imm(0), Tmp(GPRInfo::returnValueGPR));
    root->append(Ret32, nullptr, Tmp(GPRInfo::returnValueGPR));

    memset(things, 0, sizeof(things));
    
    CHECK(!compileAndRun<int>(proc));

    CHECK(things[0] == 1);
    CHECK(things[1] == 1);
    CHECK(things[2] == 1);
    CHECK(things[3] == 1);
}

void testShuffleBroadcastAllRegs()
{
    B3::Procedure proc;
    Code& code = proc.code();

    const Vector<Reg>& regs = regsInPriorityOrder(Arg::GP);

    BasicBlock* root = code.addBlock();
    root->append(Move, nullptr, Arg::imm(35), Tmp(GPRInfo::regT0));
    unsigned count = 1;
    for (Reg reg : regs) {
        if (reg != Reg(GPRInfo::regT0))
            root->append(Move, nullptr, Arg::imm(count++), Tmp(reg));
    }
    Inst& shuffle = root->append(Shuffle, nullptr);
    for (Reg reg : regs) {
        if (reg != Reg(GPRInfo::regT0))
            shuffle.append(Tmp(GPRInfo::regT0), Tmp(reg), Arg::widthArg(Arg::Width32));
    }

    StackSlot* slot = code.addStackSlot(sizeof(int32_t) * regs.size(), B3::StackSlotKind::Locked);
    for (unsigned i = 0; i < regs.size(); ++i)
        root->append(Move32, nullptr, Tmp(regs[i]), Arg::stack(slot, i * sizeof(int32_t)));

    Vector<int32_t> things(regs.size(), 666);
    Tmp base = code.newTmp(Arg::GP);
    root->append(Move, nullptr, Arg::imm64(bitwise_cast<intptr_t>(&things[0])), base);
    for (unsigned i = 0; i < regs.size(); ++i) {
        root->append(Move32, nullptr, Arg::stack(slot, i * sizeof(int32_t)), Tmp(GPRInfo::regT0));
        root->append(Move32, nullptr, Tmp(GPRInfo::regT0), Arg::addr(base, i * sizeof(int32_t)));
    }
    
    root->append(Move, nullptr, Arg::imm(0), Tmp(GPRInfo::returnValueGPR));
    root->append(Ret32, nullptr, Tmp(GPRInfo::returnValueGPR));

    CHECK(!compileAndRun<int>(proc));

    for (int32_t thing : things)
        CHECK(thing == 35);
}

void testShuffleTreeShift()
{
    B3::Procedure proc;
    Code& code = proc.code();

    BasicBlock* root = code.addBlock();
    root->append(Move, nullptr, Arg::imm(1), Tmp(GPRInfo::regT0));
    root->append(Move, nullptr, Arg::imm(2), Tmp(GPRInfo::regT1));
    root->append(Move, nullptr, Arg::imm(3), Tmp(GPRInfo::regT2));
    root->append(Move, nullptr, Arg::imm(4), Tmp(GPRInfo::regT3));
    root->append(Move, nullptr, Arg::imm(5), Tmp(GPRInfo::regT4));
    root->append(Move, nullptr, Arg::imm(6), Tmp(GPRInfo::regT5));
    root->append(Move, nullptr, Arg::imm(7), Tmp(GPRInfo::regT6));
    root->append(Move, nullptr, Arg::imm(8), Tmp(GPRInfo::regT7));
    root->append(
        Shuffle, nullptr,
        Tmp(GPRInfo::regT0), Tmp(GPRInfo::regT1), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT0), Tmp(GPRInfo::regT2), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT1), Tmp(GPRInfo::regT3), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT1), Tmp(GPRInfo::regT4), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT2), Tmp(GPRInfo::regT5), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT2), Tmp(GPRInfo::regT6), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT3), Tmp(GPRInfo::regT7), Arg::widthArg(Arg::Width32));

    int32_t things[8];
    Tmp base = code.newTmp(Arg::GP);
    root->append(Move, nullptr, Arg::imm64(bitwise_cast<intptr_t>(&things)), base);
    root->append(Move32, nullptr, Tmp(GPRInfo::regT0), Arg::addr(base, 0 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT1), Arg::addr(base, 1 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT2), Arg::addr(base, 2 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT3), Arg::addr(base, 3 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT4), Arg::addr(base, 4 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT5), Arg::addr(base, 5 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT6), Arg::addr(base, 6 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT7), Arg::addr(base, 7 * sizeof(int32_t)));
    root->append(Move, nullptr, Arg::imm(0), Tmp(GPRInfo::returnValueGPR));
    root->append(Ret32, nullptr, Tmp(GPRInfo::returnValueGPR));

    memset(things, 0, sizeof(things));
    
    CHECK(!compileAndRun<int>(proc));

    CHECK(things[0] == 1);
    CHECK(things[1] == 1);
    CHECK(things[2] == 1);
    CHECK(things[3] == 2);
    CHECK(things[4] == 2);
    CHECK(things[5] == 3);
    CHECK(things[6] == 3);
    CHECK(things[7] == 4);
}

void testShuffleTreeShiftBackward()
{
    B3::Procedure proc;
    Code& code = proc.code();

    BasicBlock* root = code.addBlock();
    root->append(Move, nullptr, Arg::imm(1), Tmp(GPRInfo::regT0));
    root->append(Move, nullptr, Arg::imm(2), Tmp(GPRInfo::regT1));
    root->append(Move, nullptr, Arg::imm(3), Tmp(GPRInfo::regT2));
    root->append(Move, nullptr, Arg::imm(4), Tmp(GPRInfo::regT3));
    root->append(Move, nullptr, Arg::imm(5), Tmp(GPRInfo::regT4));
    root->append(Move, nullptr, Arg::imm(6), Tmp(GPRInfo::regT5));
    root->append(Move, nullptr, Arg::imm(7), Tmp(GPRInfo::regT6));
    root->append(Move, nullptr, Arg::imm(8), Tmp(GPRInfo::regT7));
    root->append(
        Shuffle, nullptr,
        Tmp(GPRInfo::regT3), Tmp(GPRInfo::regT7), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT2), Tmp(GPRInfo::regT6), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT2), Tmp(GPRInfo::regT5), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT1), Tmp(GPRInfo::regT4), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT1), Tmp(GPRInfo::regT3), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT0), Tmp(GPRInfo::regT2), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT0), Tmp(GPRInfo::regT1), Arg::widthArg(Arg::Width32));

    int32_t things[8];
    Tmp base = code.newTmp(Arg::GP);
    root->append(Move, nullptr, Arg::imm64(bitwise_cast<intptr_t>(&things)), base);
    root->append(Move32, nullptr, Tmp(GPRInfo::regT0), Arg::addr(base, 0 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT1), Arg::addr(base, 1 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT2), Arg::addr(base, 2 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT3), Arg::addr(base, 3 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT4), Arg::addr(base, 4 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT5), Arg::addr(base, 5 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT6), Arg::addr(base, 6 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT7), Arg::addr(base, 7 * sizeof(int32_t)));
    root->append(Move, nullptr, Arg::imm(0), Tmp(GPRInfo::returnValueGPR));
    root->append(Ret32, nullptr, Tmp(GPRInfo::returnValueGPR));

    memset(things, 0, sizeof(things));
    
    CHECK(!compileAndRun<int>(proc));

    CHECK(things[0] == 1);
    CHECK(things[1] == 1);
    CHECK(things[2] == 1);
    CHECK(things[3] == 2);
    CHECK(things[4] == 2);
    CHECK(things[5] == 3);
    CHECK(things[6] == 3);
    CHECK(things[7] == 4);
}

void testShuffleTreeShiftOtherBackward()
{
    // NOTE: This test was my original attempt at TreeShiftBackward but mistakes were made. So, this
    // ends up being just a weird test. But weird tests are useful, so I kept it.
    
    B3::Procedure proc;
    Code& code = proc.code();

    BasicBlock* root = code.addBlock();
    root->append(Move, nullptr, Arg::imm(1), Tmp(GPRInfo::regT0));
    root->append(Move, nullptr, Arg::imm(2), Tmp(GPRInfo::regT1));
    root->append(Move, nullptr, Arg::imm(3), Tmp(GPRInfo::regT2));
    root->append(Move, nullptr, Arg::imm(4), Tmp(GPRInfo::regT3));
    root->append(Move, nullptr, Arg::imm(5), Tmp(GPRInfo::regT4));
    root->append(Move, nullptr, Arg::imm(6), Tmp(GPRInfo::regT5));
    root->append(Move, nullptr, Arg::imm(7), Tmp(GPRInfo::regT6));
    root->append(Move, nullptr, Arg::imm(8), Tmp(GPRInfo::regT7));
    root->append(
        Shuffle, nullptr,
        Tmp(GPRInfo::regT4), Tmp(GPRInfo::regT7), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT5), Tmp(GPRInfo::regT6), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT5), Tmp(GPRInfo::regT5), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT6), Tmp(GPRInfo::regT4), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT6), Tmp(GPRInfo::regT3), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT7), Tmp(GPRInfo::regT2), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT7), Tmp(GPRInfo::regT1), Arg::widthArg(Arg::Width32));

    int32_t things[8];
    Tmp base = code.newTmp(Arg::GP);
    root->append(Move, nullptr, Arg::imm64(bitwise_cast<intptr_t>(&things)), base);
    root->append(Move32, nullptr, Tmp(GPRInfo::regT0), Arg::addr(base, 0 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT1), Arg::addr(base, 1 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT2), Arg::addr(base, 2 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT3), Arg::addr(base, 3 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT4), Arg::addr(base, 4 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT5), Arg::addr(base, 5 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT6), Arg::addr(base, 6 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT7), Arg::addr(base, 7 * sizeof(int32_t)));
    root->append(Move, nullptr, Arg::imm(0), Tmp(GPRInfo::returnValueGPR));
    root->append(Ret32, nullptr, Tmp(GPRInfo::returnValueGPR));

    memset(things, 0, sizeof(things));
    
    CHECK(!compileAndRun<int>(proc));

    CHECK(things[0] == 1);
    CHECK(things[1] == 8);
    CHECK(things[2] == 8);
    CHECK(things[3] == 7);
    CHECK(things[4] == 7);
    CHECK(things[5] == 6);
    CHECK(things[6] == 6);
    CHECK(things[7] == 5);
}

void testShuffleMultipleShifts()
{
    B3::Procedure proc;
    Code& code = proc.code();

    BasicBlock* root = code.addBlock();
    root->append(Move, nullptr, Arg::imm(1), Tmp(GPRInfo::regT0));
    root->append(Move, nullptr, Arg::imm(2), Tmp(GPRInfo::regT1));
    root->append(Move, nullptr, Arg::imm(3), Tmp(GPRInfo::regT2));
    root->append(Move, nullptr, Arg::imm(4), Tmp(GPRInfo::regT3));
    root->append(Move, nullptr, Arg::imm(5), Tmp(GPRInfo::regT4));
    root->append(Move, nullptr, Arg::imm(6), Tmp(GPRInfo::regT5));
    root->append(
        Shuffle, nullptr,
        Tmp(GPRInfo::regT0), Tmp(GPRInfo::regT1), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT2), Tmp(GPRInfo::regT3), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT2), Tmp(GPRInfo::regT4), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT0), Tmp(GPRInfo::regT5), Arg::widthArg(Arg::Width32));

    int32_t things[6];
    Tmp base = code.newTmp(Arg::GP);
    root->append(Move, nullptr, Arg::imm64(bitwise_cast<intptr_t>(&things)), base);
    root->append(Move32, nullptr, Tmp(GPRInfo::regT0), Arg::addr(base, 0 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT1), Arg::addr(base, 1 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT2), Arg::addr(base, 2 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT3), Arg::addr(base, 3 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT4), Arg::addr(base, 4 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT5), Arg::addr(base, 5 * sizeof(int32_t)));
    root->append(Move, nullptr, Arg::imm(0), Tmp(GPRInfo::returnValueGPR));
    root->append(Ret32, nullptr, Tmp(GPRInfo::returnValueGPR));

    memset(things, 0, sizeof(things));
    
    CHECK(!compileAndRun<int>(proc));

    CHECK(things[0] == 1);
    CHECK(things[1] == 1);
    CHECK(things[2] == 3);
    CHECK(things[3] == 3);
    CHECK(things[4] == 3);
    CHECK(things[5] == 1);
}

void testShuffleRotateWithFringe()
{
    B3::Procedure proc;
    Code& code = proc.code();

    BasicBlock* root = code.addBlock();
    root->append(Move, nullptr, Arg::imm(1), Tmp(GPRInfo::regT0));
    root->append(Move, nullptr, Arg::imm(2), Tmp(GPRInfo::regT1));
    root->append(Move, nullptr, Arg::imm(3), Tmp(GPRInfo::regT2));
    root->append(Move, nullptr, Arg::imm(4), Tmp(GPRInfo::regT3));
    root->append(Move, nullptr, Arg::imm(5), Tmp(GPRInfo::regT4));
    root->append(Move, nullptr, Arg::imm(6), Tmp(GPRInfo::regT5));
    root->append(
        Shuffle, nullptr,
        Tmp(GPRInfo::regT0), Tmp(GPRInfo::regT1), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT1), Tmp(GPRInfo::regT2), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT2), Tmp(GPRInfo::regT0), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT0), Tmp(GPRInfo::regT3), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT1), Tmp(GPRInfo::regT4), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT2), Tmp(GPRInfo::regT5), Arg::widthArg(Arg::Width32));

    int32_t things[6];
    Tmp base = code.newTmp(Arg::GP);
    root->append(Move, nullptr, Arg::imm64(bitwise_cast<intptr_t>(&things)), base);
    root->append(Move32, nullptr, Tmp(GPRInfo::regT0), Arg::addr(base, 0 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT1), Arg::addr(base, 1 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT2), Arg::addr(base, 2 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT3), Arg::addr(base, 3 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT4), Arg::addr(base, 4 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT5), Arg::addr(base, 5 * sizeof(int32_t)));
    root->append(Move, nullptr, Arg::imm(0), Tmp(GPRInfo::returnValueGPR));
    root->append(Ret32, nullptr, Tmp(GPRInfo::returnValueGPR));

    memset(things, 0, sizeof(things));
    
    CHECK(!compileAndRun<int>(proc));

    CHECK(things[0] == 3);
    CHECK(things[1] == 1);
    CHECK(things[2] == 2);
    CHECK(things[3] == 1);
    CHECK(things[4] == 2);
    CHECK(things[5] == 3);
}

void testShuffleRotateWithLongFringe()
{
    B3::Procedure proc;
    Code& code = proc.code();

    BasicBlock* root = code.addBlock();
    root->append(Move, nullptr, Arg::imm(1), Tmp(GPRInfo::regT0));
    root->append(Move, nullptr, Arg::imm(2), Tmp(GPRInfo::regT1));
    root->append(Move, nullptr, Arg::imm(3), Tmp(GPRInfo::regT2));
    root->append(Move, nullptr, Arg::imm(4), Tmp(GPRInfo::regT3));
    root->append(Move, nullptr, Arg::imm(5), Tmp(GPRInfo::regT4));
    root->append(Move, nullptr, Arg::imm(6), Tmp(GPRInfo::regT5));
    root->append(
        Shuffle, nullptr,
        Tmp(GPRInfo::regT0), Tmp(GPRInfo::regT1), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT1), Tmp(GPRInfo::regT2), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT2), Tmp(GPRInfo::regT0), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT0), Tmp(GPRInfo::regT3), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT3), Tmp(GPRInfo::regT4), Arg::widthArg(Arg::Width32),
        Tmp(GPRInfo::regT4), Tmp(GPRInfo::regT5), Arg::widthArg(Arg::Width32));

    int32_t things[6];
    Tmp base = code.newTmp(Arg::GP);
    root->append(Move, nullptr, Arg::imm64(bitwise_cast<intptr_t>(&things)), base);
    root->append(Move32, nullptr, Tmp(GPRInfo::regT0), Arg::addr(base, 0 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT1), Arg::addr(base, 1 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT2), Arg::addr(base, 2 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT3), Arg::addr(base, 3 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT4), Arg::addr(base, 4 * sizeof(int32_t)));
    root->append(Move32, nullptr, Tmp(GPRInfo::regT5), Arg::addr(base, 5 * sizeof(int32_t)));
    root->append(Move, nullptr, Arg::imm(0), Tmp(GPRInfo::returnValueGPR));
    root->append(Ret32, nullptr, Tmp(GPRInfo::returnValueGPR));

    memset(things, 0, sizeof(things));
    
    CHECK(!compileAndRun<int>(proc));

    CHECK(things[0] == 3);
    CHECK(things[1] == 1);
    CHECK(things[2] == 2);
    CHECK(things[3] == 1);
    CHECK(things[4] == 4);
    CHECK(things[5] == 5);
}

#define RUN(test) do {                          \
        if (!shouldRun(#test))                  \
            break;                              \
        tasks.append(                           \
            createSharedTask<void()>(           \
                [&] () {                        \
                    dataLog(#test "...\n");     \
                    test;                       \
                    dataLog(#test ": OK!\n");   \
                }));                            \
    } while (false);

void run(const char* filter)
{
    JSC::initializeThreading();
    vm = &VM::create(LargeHeap).leakRef();

    Deque<RefPtr<SharedTask<void()>>> tasks;

    auto shouldRun = [&] (const char* testName) -> bool {
        return !filter || !!strcasestr(testName, filter);
    };

    RUN(testSimple());
    RUN(testShuffleSimpleSwap());
    RUN(testShuffleSimpleShift());
    RUN(testShuffleLongShift());
    RUN(testShuffleLongShiftBackwards());
    RUN(testShuffleSimpleRotate());
    RUN(testShuffleSimpleBroadcast());
    RUN(testShuffleBroadcastAllRegs());
    RUN(testShuffleTreeShift());
    RUN(testShuffleTreeShiftBackward());
    RUN(testShuffleTreeShiftOtherBackward());
    RUN(testShuffleMultipleShifts());
    RUN(testShuffleRotateWithFringe());
    RUN(testShuffleRotateWithLongFringe());

    // Still need the following tests:
    // - multiple shifts
    // - multiple rotates
    // - shift and rotate
    // - shift over all registers
    // - rotate over all registers
    // - rotate with multiple widths
    // - memory shift
    // - memory->memory shift
    // - memory->memory shift with no spare registers
    // - memory rotate
    // - memory rotate with multiple widths
    // - memory->memory rotate
    // - memory->memory rotate with multiple widths
    // - memory rotate with no spare registers
    // - memory rotate with no spare registers with multiple widths
    // - memory->memory rotate with no spare registers
    // - memory->memory rotate with no spare registers with multiple widths
    // - floating point

    if (tasks.isEmpty())
        usage();

    Lock lock;

    Vector<ThreadIdentifier> threads;
    for (unsigned i = filter ? 1 : WTF::numberOfProcessorCores(); i--;) {
        threads.append(
            createThread(
                "testb3 thread",
                [&] () {
                    for (;;) {
                        RefPtr<SharedTask<void()>> task;
                        {
                            LockHolder locker(lock);
                            if (tasks.isEmpty())
                                return;
                            task = tasks.takeFirst();
                        }

                        task->run();
                    }
                }));
    }

    for (ThreadIdentifier thread : threads)
        waitForThreadCompletion(thread);
    crashLock.lock();
}

} // anonymois namespace

#else // ENABLE(B3_JIT)

static void run(const char*)
{
    dataLog("B3 JIT is not enabled.\n");
}

#endif // ENABLE(B3_JIT)

int main(int argc, char** argv)
{
    const char* filter = nullptr;
    switch (argc) {
    case 1:
        break;
    case 2:
        filter = argv[1];
        break;
    default:
        usage();
        break;
    }
    
    run(filter);
    return 0;
}

Return to Bug 152952

Lines 1411-1416 public: Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h_sec1
- Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h +10 lines
1411	}	1411	}
1412	#endif	1412	#endif
1413		1413
		1414	void swap32(RegisterID src, RegisterID dest)
		1415	{
		1416	m_assembler.xchgl_rr(src, dest);
		1417	}
		1418
		1419	void swap32(RegisterID src, Address dest)
		1420	{
		1421	m_assembler.xchgl_rm(src, dest.offset, dest.base);
		1422	}
		1423
1414	void moveConditionally32(RelationalCondition cond, RegisterID left, RegisterID right, RegisterID src, RegisterID dest)	1424	void moveConditionally32(RelationalCondition cond, RegisterID left, RegisterID right, RegisterID src, RegisterID dest)
1415	{	1425	{
1416	m_assembler.cmpl_rr(right, left);	1426	m_assembler.cmpl_rr(right, left);

Lines 1-5 Source/JavaScriptCore/b3/B3CCallValue.h_sec1
- Source/JavaScriptCore/b3/B3CCallValue.h -3 / +2 lines
1	/*	1	/*
2	* Copyright (C) 2015 Apple Inc. All rights reserved.	2	* Copyright (C) 2015-2016 Apple Inc. All rights reserved.
3	*	3	*
4	* Redistribution and use in source and binary forms, with or without	4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions	5	* modification, are permitted provided that the following conditions
Lines 39-45 public: Source/JavaScriptCore/b3/B3CCallValue.h_sec2
39		39
40	~CCallValue();	40	~CCallValue();
41		41
42	Effects effects;	42	Effects effects { Effects::forCall() };
43		43
44	private:	44	private:
45	friend class Procedure;	45	friend class Procedure;
Lines 47-53 private: Source/JavaScriptCore/b3/B3CCallValue.h_sec3
47	template<typename... Arguments>	47	template<typename... Arguments>
48	CCallValue(unsigned index, Type type, Origin origin, Arguments... arguments)	48	CCallValue(unsigned index, Type type, Origin origin, Arguments... arguments)
49	: Value(index, CheckedOpcode, CCall, type, origin, arguments...)	49	: Value(index, CheckedOpcode, CCall, type, origin, arguments...)
50	, effects(Effects::forCall())
51	{	50	{
52	RELEASE_ASSERT(numChildren() >= 1);	51	RELEASE_ASSERT(numChildren() >= 1);
53	}	52	}

Lines 1-5 Source/JavaScriptCore/b3/B3OpaqueByproducts.h_sec1
- Source/JavaScriptCore/b3/B3OpaqueByproducts.h -2 / +2 lines
1	/*	1	/*
2	* Copyright (C) 2015 Apple Inc. All rights reserved.	2	* Copyright (C) 2015-2016 Apple Inc. All rights reserved.
3	*	3	*
4	* Redistribution and use in source and binary forms, with or without	4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions	5	* modification, are permitted provided that the following conditions
Lines 39-45 class OpaqueByproducts { Source/JavaScriptCore/b3/B3OpaqueByproducts.h_sec2
39	WTF_MAKE_FAST_ALLOCATED;	39	WTF_MAKE_FAST_ALLOCATED;
40	public:	40	public:
41	OpaqueByproducts();	41	OpaqueByproducts();
42	~OpaqueByproducts();	42	JS_EXPORT_PRIVATE ~OpaqueByproducts();
43		43
44	size_t count() const { return m_byproducts.size(); }	44	size_t count() const { return m_byproducts.size(); }
45		45

Lines 200-220 bool StackmapSpecial::isArgValidForValue Source/JavaScriptCore/b3/B3StackmapSpecial.cpp_sec1
- Source/JavaScriptCore/b3/B3StackmapSpecial.cpp -11 / +4 lines
200	case Arg::Tmp:	200	case Arg::Tmp:
201	case Arg::Imm:	201	case Arg::Imm:
202	case Arg::Imm64:	202	case Arg::Imm64:
203	case Arg::Stack:
204	case Arg::CallArg:
205	break; // OK
206	case Arg::Addr:
207	if (arg.base() != Tmp(GPRInfo::callFrameRegister)
208	&& arg.base() != Tmp(MacroAssembler::stackPointerRegister))
209	return false;
210	break;	203	break;
211	default:	204	default:
212	return false;	205	if (!arg.isStackMemory())
		206	return false;
		207	break;
213	}	208	}
214
215	Arg::Type type = Arg::typeForB3Type(value->type());
216		209
217	return arg.isType(type);	210	return arg.canRepresent(value);
218	}	211	}
219		212
220	bool StackmapSpecial::isArgValidForRep(Air::Code& code, const Air::Arg& arg, const ValueRep& rep)	213	bool StackmapSpecial::isArgValidForRep(Air::Code& code, const Air::Arg& arg, const ValueRep& rep)

Lines 78-92 public: Source/JavaScriptCore/b3/air/AirBasicBlock.h_sec1
- Source/JavaScriptCore/b3/air/AirBasicBlock.h -2 / +4 lines
78	InstList& insts() { return m_insts; }	78	InstList& insts() { return m_insts; }
79		79
80	template<typename Inst>	80	template<typename Inst>
81	void appendInst(Inst&& inst)	81	Inst& appendInst(Inst&& inst)
82	{	82	{
83	m_insts.append(std::forward<Inst>(inst));	83	m_insts.append(std::forward<Inst>(inst));
		84	return m_insts.last();
84	}	85	}
85		86
86	template<typename... Arguments>	87	template<typename... Arguments>
87	void append(Arguments&&... arguments)	88	Inst& append(Arguments&&... arguments)
88	{	89	{
89	m_insts.append(Inst(std::forward<Arguments>(arguments)...));	90	m_insts.append(Inst(std::forward<Arguments>(arguments)...));
		91	return m_insts.last();
90	}	92	}
91		93
92	// The "0" case is the case to which the branch jumps, so the "then" case. The "1" case is the	94	// The "0" case is the case to which the branch jumps, so the "then" case. The "1" case is the

Line 0 Source/JavaScriptCore/b3/air/AirCCallingConvention.cpp_sec1
- Source/JavaScriptCore/b3/air/AirCCallingConvention.cpp +127 lines
		1	/*
		2	* Copyright (C) 2016 Apple Inc. All rights reserved.
		3	*
		4	* Redistribution and use in source and binary forms, with or without
		5	* modification, are permitted provided that the following conditions
		6	* are met:
		7	* 1. Redistributions of source code must retain the above copyright
		8	* notice, this list of conditions and the following disclaimer.
		9	* 2. Redistributions in binary form must reproduce the above copyright
		10	* notice, this list of conditions and the following disclaimer in the
		11	* documentation and/or other materials provided with the distribution.
		12	*
		13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
		14	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		15	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
		17	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		18	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		19	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		20	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
		21	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
		22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
		23	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		24	*/
		25
		26	#include "config.h"
		27	#include "AirCCallingConvention.h"
		28
		29	#if ENABLE(B3_JIT)
		30
		31	#include "AirCCallSpecial.h"
		32	#include "AirCode.h"
		33	#include "B3CCallValue.h"
		34	#include "B3ValueInlines.h"
		35
		36	namespace JSC { namespace B3 { namespace Air {
		37
		38	namespace {
		39
		40	template<typename BankInfo>
		41	Arg marshallCCallArgumentImpl(unsigned& argumentCount, unsigned& stackOffset, Value* child)
		42	{
		43	unsigned argumentIndex = argumentCount++;
		44	if (argumentIndex < BankInfo::numberOfArgumentRegisters)
		45	return Tmp(BankInfo::toArgumentRegister(argumentIndex));
		46
		47	unsigned slotSize;
		48	if (isARM64() && isIOS()) {
		49	// Arguments are packed.
		50	slotSize = sizeofType(child->type());
		51	} else {
		52	// Arguments are aligned.
		53	slotSize = 8;
		54	}
		55
		56	stackOffset = WTF::roundUpToMultipleOf(slotSize, stackOffset);
		57	Arg result = Arg::callArg(stackOffset);
		58	stackOffset += slotSize;
		59	return result;
		60	}
		61
		62	Arg marshallCCallArgument(
		63	unsigned& gpArgumentCount, unsigned& fpArgumentCount, unsigned& stackOffset, Value* child)
		64	{
65	switch (Arg::typeForB3Type(child->type())) {
66	case Arg::GP:
67	return marshallCCallArgumentImpl<GPRInfo>(gpArgumentCount, stackOffset, child);
68	case Arg::FP:
69	return marshallCCallArgumentImpl<FPRInfo>(fpArgumentCount, stackOffset, child);
70	}
71	RELEASE_ASSERT_NOT_REACHED();
72	return Arg();
73	}
74
75	} // anonymous namespace
76
77	Vector<Arg> computeCCallingConvention(Code& code, CCallValue* value)
78	{
79	Vector<Arg> result;
80	result.append(Tmp(CCallSpecial::scratchRegister));
81	unsigned gpArgumentCount = 0;
82	unsigned fpArgumentCount = 0;
83	unsigned stackOffset = 0;
84	for (unsigned i = 1; i < value->numChildren(); ++i) {
85	result.append(
86	marshallCCallArgument(gpArgumentCount, fpArgumentCount, stackOffset, value->child(i)));
87	}
88	code.requestCallArgAreaSize(WTF::roundUpToMultipleOf(stackAlignmentBytes(), stackOffset));
89	return result;
90	}
91
92	Tmp cCallResult(Type type)
93	{
94	switch (type) {
95	case Void:
96	return Tmp();
97	case Int32:
98	case Int64:
99	return Tmp(GPRInfo::returnValueGPR);
100	case Float:
101	case Double:
102	return Tmp(FPRInfo::returnValueFPR);
103	}
104
105	RELEASE_ASSERT_NOT_REACHED();
106	return Tmp();
107	}
108
109	Inst buildCCall(Code& code, Value* origin, const Vector<Arg>& arguments)
110	{
111	Inst inst(Patch, origin, Arg::special(code.cCallSpecial()));
112	inst.args.append(arguments[0]);
113	inst.args.append(Tmp(GPRInfo::returnValueGPR));
114	inst.args.append(Tmp(GPRInfo::returnValueGPR2));
115	inst.args.append(Tmp(FPRInfo::returnValueFPR));
116	for (unsigned i = 1; i < arguments.size(); ++i) {
117	Arg arg = arguments[i];
118	if (arg.isTmp())
119	inst.args.append(arg);
120	}
121	return inst;
122	}
123
124	} } } // namespace JSC::B3::Air
125
126	#endif // ENABLE(B3_JIT)
127

Lines 1-5 Source/JavaScriptCore/b3/air/AirCode.h_sec1
- Source/JavaScriptCore/b3/air/AirCode.h -3 / +4 lines
1	/*	1	/*
2	* Copyright (C) 2015 Apple Inc. All rights reserved.	2	* Copyright (C) 2015-2016 Apple Inc. All rights reserved.
3	*	3	*
4	* Redistribution and use in source and binary forms, with or without	4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions	5	* modification, are permitted provided that the following conditions
Lines 55-66 public: Source/JavaScriptCore/b3/air/AirCode.h_sec2
55		55
56	Procedure& proc() { return m_proc; }	56	Procedure& proc() { return m_proc; }
57		57
58	BasicBlock* addBlock(double frequency = 1);	58	JS_EXPORT_PRIVATE BasicBlock* addBlock(double frequency = 1);
59		59
60	// Note that you can rely on stack slots always getting indices that are larger than the index	60	// Note that you can rely on stack slots always getting indices that are larger than the index
61	// of any prior stack slot. In fact, all stack slots you create in the future will have an index	61	// of any prior stack slot. In fact, all stack slots you create in the future will have an index
62	// that is >= stackSlots().size().	62	// that is >= stackSlots().size().
63	StackSlot* addStackSlot(unsigned byteSize, StackSlotKind, StackSlotValue* = nullptr);	63	JS_EXPORT_PRIVATE StackSlot* addStackSlot(
		64	unsigned byteSize, StackSlotKind, StackSlotValue* = nullptr);
64	StackSlot* addStackSlot(StackSlotValue*);	65	StackSlot* addStackSlot(StackSlotValue*);
65		66
66	Special* addSpecial(std::unique_ptr<Special>);	67	Special* addSpecial(std::unique_ptr<Special>);

Line 0 Source/JavaScriptCore/b3/air/AirEmitShuffle.cpp_sec1
- Source/JavaScriptCore/b3/air/AirEmitShuffle.cpp +461 lines
		1	/*
		2	* Copyright (C) 2016 Apple Inc. All rights reserved.
		3	*
		4	* Redistribution and use in source and binary forms, with or without
		5	* modification, are permitted provided that the following conditions
		6	* are met:
		7	* 1. Redistributions of source code must retain the above copyright
		8	* notice, this list of conditions and the following disclaimer.
		9	* 2. Redistributions in binary form must reproduce the above copyright
		10	* notice, this list of conditions and the following disclaimer in the
		11	* documentation and/or other materials provided with the distribution.
		12	*
		13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
		14	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		15	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
		17	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		18	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		19	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		20	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
		21	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
		22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
		23	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		24	*/
		25
		26	#include "config.h"
		27	#include "AirEmitShuffle.h"
		28
		29	#if ENABLE(B3_JIT)
		30
		31	#include "AirInstInlines.h"
		32	#include "AirRegisterPriority.h"
		33	#include <wtf/GraphNodeWorklist.h>
		34
		35	namespace JSC { namespace B3 { namespace Air {
		36
		37	namespace {
		38
		39	template<typename Functor>
		40	Tmp findPossibleScratch(Arg::Type type, const Functor& functor) {
		41	for (Reg reg : regsInPriorityOrder(type)) {
		42	Tmp tmp(reg);
		43	if (functor(tmp))
		44	return tmp;
		45	}
		46	return Tmp();
		47	}
		48
		49	Tmp findPossibleScratch(Arg::Type type, const Arg& arg1, const Arg& arg2) {
		50	return findPossibleScratch(
		51	type,
		52	[&] (Tmp tmp) -> bool {
		53	return !arg1.usesTmp(tmp) && !arg2.usesTmp(tmp);
		54	});
		55	}
		56
		57	// Example: (a => b, b => a, a => c, b => d)
		58	struct Rotate {
		59	Vector<ShufflePair> loop; // in the example, this is the loop: (a => b, b => a)
		60	Vector<ShufflePair> fringe; // in the example, these are the associated shifts: (a => c, b => d)
		61	};
		62
		63	} // anonymous namespace
		64
65	void ShufflePair::dump(PrintStream& out) const
66	{
67	out.print(width(), ":", src(), "=>", dst());
68	}
69
70	Vector<Inst> emitShuffle(
71	Vector<ShufflePair> pairs, std::array<Arg, 2> scratches, Arg::Type type, Value* origin)
72	{
73	pairs.removeAllMatching(
74	[&] (const ShufflePair& pair) -> bool {
75	return pair.src() == pair.dst();
76	});
77
78	// First validate that this is the kind of shuffle that we know how to deal with.
79	for (const ShufflePair& pair : pairs) {
80	ASSERT(pair.src().isType(type));
81	ASSERT(pair.dst().isType(type));
82	ASSERT(pair.dst().isTmp() \|\| pair.dst().isMemory());
83	}
84
85	// There are two possible kinds of operations that we will do:
86	//
87	// - Shift. Example: (a => b, b => c). We emit this as "Move b, c; Move a, b". This only requires
88	// scratch registers if there are memory->memory moves. We want to find as many of these as
89	// possible because they are cheaper. Note that shifts can involve the same source mentioned
90	// multiple times. Example: (a => b, a => c, b => d, b => e).
91	//
92	// - Rotate. Example: (a => b, b => a). We want to emit this as "Swap a, b", but that instruction
93	// may not be available, in which case we may need a scratch register or a scratch memory
94	// location. A gnarlier example is (a => b, b => c, c => a). We can emit this as "Swap b, c;
95	// Swap a, b". Note that swapping has to be careful about differing widths.
96	//
97	// Note that a rotate can have "fringe". For example, we might have (a => b, b => a, a =>c,
98	// b => d). This has a rotate loop (a => b, b => a) and some fringe (a => c, b => d). We treat
99	// the whole thing as a single rotate.
100	//
101	// We will find multiple disjoint such operations. We can execute them in any order.
102
103	// We interpret these as Moves that should be executed backwards. All shifts are keyed by their
104	// starting source.
105	HashMap<Arg, Vector<ShufflePair>> shifts;
106
107	// We interpret these as Swaps over src()'s that should be executed backwards, i.e. for a list
108	// of size 3 we would do "Swap list[1].src(), list[2].src(); Swap list[0].src(), list[1].src()".
109	// Note that we actually can't do that if the widths don't match or other bad things happen.
110	// But, prior to executing all of that, we need to execute the fringe: the shifts comming off the
111	// rotate.
112	Vector<Rotate> rotates;
113
114	{
115	HashMap<Arg, Vector<ShufflePair>> mapping;
116	for (const ShufflePair& pair : pairs)
117	mapping.add(pair.src(), Vector<ShufflePair>()).iterator->value.append(pair);
118
119	Vector<ShufflePair> currentPairs;
120
121	while (!mapping.isEmpty()) {
122	ASSERT(currentPairs.isEmpty());
123	Arg originalSrc = mapping.begin()->key;
124	ASSERT(!shifts.contains(originalSrc));
125
126	GraphNodeWorklist<Arg> worklist;
127	worklist.push(originalSrc);
128	while (Arg src = worklist.pop()) {
129	HashMap<Arg, Vector<ShufflePair>>::iterator iter = mapping.find(src);
130	if (iter == mapping.end()) {
131	// With a shift it's possible that we previously built the tail of this shift.
132	// See if that's the case now.
133	currentPairs.appendVector(shifts.take(src));
134	continue;
135	}
136	Vector<ShufflePair> pairs = WTFMove(iter->value);
137	mapping.remove(iter);
138
139	for (const ShufflePair& pair : pairs) {
140	currentPairs.append(pair);
141	ASSERT(pair.src() == src);
142	worklist.push(pair.dst());
143	}
144	}
145
146	ASSERT(currentPairs.size());
147	ASSERT(currentPairs[0].src() == originalSrc);
148
149	bool isRotate = false;
150	for (const ShufflePair& pair : currentPairs) {
151	if (pair.dst() == originalSrc) {
152	isRotate = true;
153	break;
154	}
155	}
156
157	if (isRotate) {
158	Rotate rotate;
159
160	// The common case is that the rotate does not have fringe. When this happens, the
161	// last element is the rotate.
162	if (currentPairs.last().dst() == originalSrc)
163	rotate.loop = WTFMove(currentPairs);
164	else {
165	// This is the slow path. The rotate has fringe. We figure this out by working
166	// backward.
167
168	HashMap<Arg, ShufflePair> dstMapping;
169	for (const ShufflePair& pair : currentPairs)
170	dstMapping.add(pair.dst(), pair);
171
172	ShufflePair pair = dstMapping.take(originalSrc);
173	for (;;) {
174	rotate.loop.append(pair);
175
176	auto iter = dstMapping.find(pair.src());
177	if (iter == dstMapping.end())
178	break;
179	pair = iter->value;
180	dstMapping.remove(iter);
181	}
182
183	rotate.loop.reverse();
184
185	// Make sure that the fringe appears in the same order as how it appeared in the
186	// currentPairs, since that's the DFS order.
187	for (const ShufflePair& pair : currentPairs) {
188	// But of course we only include it if it's not in the loop.
189	if (dstMapping.contains(pair.dst()))
190	rotate.fringe.append(pair);
191	}
192	}
193
194	// If the graph search terminates because we returned to the first source, then the
195	// pair list has to have a very particular shape.
196	for (unsigned i = rotate.loop.size() - 1; i--;)
197	ASSERT(rotate.loop[i].dst() == rotate.loop[i + 1].src());
198	rotates.append(WTFMove(rotate));
199	} else
200	shifts.add(originalSrc, WTFMove(currentPairs));
201	}
202	}
203
204	// In the worst case, we need two scratch registers. The way we do this is that the client passes
205	// us what scratch registers he happens to have laying around. We will need scratch registers in
206	// the following cases:
207	//
208	// - Shuffle pairs where both src and dst refer to memory.
209	// - Rotate when no Swap instruction is available.
210	//
211	// Lucky for us, we are guaranteed to have extra scratch registers anytime we have a Shift that
212	// ends with a register. We search for such a register right now.
213
214	auto moveForWidth = [&] (Arg::Width width) -> Opcode {
215	switch (width) {
216	case Arg::Width32:
217	return type == Arg::GP ? Move32 : MoveFloat;
218	case Arg::Width64:
219	return type == Arg::GP ? Move : MoveDouble;
220	default:
221	RELEASE_ASSERT_NOT_REACHED();
222	}
223	};
224
225	Opcode conservativeMove = moveForWidth(Arg::conservativeWidth(type));
226
227	// We will emit things in reverse. We maintain a list of packs of instructions, and then we emit
228	// append them together in reverse (for example the thing at the end of resultPacks is placed
229	// first). This is useful because the last thing we emit frees up its destination registers, so
230	// it affects how we emit things before it.
231	Vector<Vector<Inst>> resultPacks;
232	Vector<Inst> result;
233
234	auto commitResult = [&] () {
235	resultPacks.append(WTFMove(result));
236	};
237
238	auto getScratch = [&] (unsigned index, Tmp possibleScratch) -> Tmp {
239	if (scratches[index].isTmp())
240	return scratches[index].tmp();
241
242	if (!possibleScratch)
243	return Tmp();
244	result.append(Inst(conservativeMove, origin, possibleScratch, scratches[index]));
245	return possibleScratch;
246	};
247
248	auto returnScratch = [&] (unsigned index, Tmp tmp) {
249	if (Arg(tmp) != scratches[index])
250	result.append(Inst(conservativeMove, origin, scratches[index], tmp));
251	};
252
253	auto handleShiftPair = [&] (const ShufflePair& pair, unsigned scratchIndex) {
254	Opcode move = moveForWidth(pair.width());
255
256	if (!isValidForm(move, pair.src().kind(), pair.dst().kind())) {
257	Tmp scratch =
258	getScratch(scratchIndex, findPossibleScratch(type, pair.src(), pair.dst()));
259	RELEASE_ASSERT(scratch);
260	if (isValidForm(move, pair.src().kind(), Arg::Tmp))
261	result.append(Inst(moveForWidth(pair.width()), origin, pair.src(), scratch));
262	else {
263	ASSERT(pair.src().isSomeImm());
264	ASSERT(move == Move32);
265	result.append(Inst(Move, origin, Arg::imm64(pair.src().value()), scratch));
266	}
267	result.append(Inst(moveForWidth(pair.width()), origin, scratch, pair.dst()));
268	returnScratch(scratchIndex, scratch);
269	return;
270	}
271
272	result.append(Inst(move, origin, pair.src(), pair.dst()));
273	};
274
275	auto handleShift = [&] (Vector<ShufflePair>& shift) {
276	for (unsigned i = shift.size(); i--;)
277	handleShiftPair(shift[i], 0);
278
279	Arg lastDst = shift.last().dst();
280	if (lastDst.isTmp()) {
281	for (Arg& scratch : scratches) {
282	ASSERT(scratch != lastDst);
283	if (!scratch.isTmp()) {
284	scratch = lastDst;
285	break;
286	}
287	}
288	}
289	};
290
291	// First handle shifts whose last destination is a tmp because these free up scratch registers.
292	// These end up last in the final sequence, so the final destination of these shifts will be
293	// available as a scratch location for anything emitted prior (so, after, since we're emitting in
294	// reverse).
295	for (auto& entry : shifts) {
296	Vector<ShufflePair>& shift = entry.value;
297	if (shift.last().dst().isTmp())
298	handleShift(shift);
299	commitResult();
300	}
301
302	// Now handle the rest of the shifts.
303	for (auto& entry : shifts) {
304	Vector<ShufflePair>& shift = entry.value;
305	if (!shift.last().dst().isTmp())
306	handleShift(shift);
307	commitResult();
308	}
309
310	for (Rotate& rotate : rotates) {
311	if (!rotate.fringe.isEmpty()) {
312	// Make sure we do the fringe first! This won't clobber any of the registers that are
313	// part of the rotation.
314	handleShift(rotate.fringe);
315	}
316
317	bool canSwap = false;
318	Opcode swap = Oops;
319	Arg::Width swapWidth = Arg::Width8; // bogus value
320
321	if (type == Arg::GP) {
322	swap = Swap32;
323	swapWidth = Arg::Width32;
324	for (ShufflePair& pair : rotate.loop) {
325	switch (pair.width()) {
326	case Arg::Width32:
327	break;
328	case Arg::Width64:
329	swap = Swap64;
330	swapWidth = Arg::Width64;
331	break;
332	default:
333	RELEASE_ASSERT_NOT_REACHED();
334	break;
335	}
336	}
337
338	canSwap = isValidForm(swap, Arg::Tmp, Arg::Tmp);
339	for (ShufflePair& pair : rotate.loop) {
340	if (pair.src().isMemory() \|\| pair.dst().isMemory()) {
341	canSwap &= isValidForm(swap, Arg::Tmp, Arg::Addr);
342
343	// We don't take the swapping path if there is a mix of widths and some of the
344	// shuffles involve memory. That gets too confusing.
345	canSwap &= (pair.width() < swapWidth);
346	}
347	}
348	}
349
350	if (canSwap) {
351	for (unsigned i = rotate.loop.size() - 1; i--;) {
352	Arg left = rotate.loop[i].src();
353	Arg right = rotate.loop[i + 1].src();
354
355	if (left.isMemory() && right.isMemory()) {
356	// Note that this is a super rare outcome. Rotates are rare. Spills are rare.
357	// Moving data between two spills is rare. To get here a lot of rare stuff has to
358	// all happen at once.
359
360	Tmp scratch = getScratch(0, findPossibleScratch(type, left, right));
361	RELEASE_ASSERT(scratch);
362	result.append(Inst(moveForWidth(swapWidth), origin, left, scratch));
363	result.append(Inst(swap, origin, scratch, right));
364	result.append(Inst(moveForWidth(swapWidth), origin, scratch, left));
365	returnScratch(0, scratch);
366	continue;
367	}
368
369	if (left.isMemory())
370	std::swap(left, right);
371
372	result.append(Inst(swap, origin, left, right));
373	}
374
375	for (ShufflePair pair : rotate.loop) {
376	if (pair.width() == swapWidth)
377	continue;
378
379	RELEASE_ASSERT(pair.width() == Arg::Width32);
380	RELEASE_ASSERT(swapWidth == Arg::Width64);
381	RELEASE_ASSERT(pair.dst().isTmp());
382
383	// Need to do an extra zero extension.
384	result.append(Inst(Move32, origin, pair.dst(), pair.dst()));
385	}
386	} else {
387	// We can treat this as a shift so long as we take the last destination (i.e. first
388	// source) and save it first. Then we handle the first entry in the pair in the rotate
389	// specially, after we restore the last destination. This requires some special care to
390	// find a scratch register. It's possible that we have a rotate that uses the entire
391	// available register file.
392
393	Tmp scratch = findPossibleScratch(
394	type,
395	[&] (Tmp tmp) -> bool {
396	for (ShufflePair pair : rotate.loop) {
397	if (pair.src().usesTmp(tmp))
398	return false;
399	if (pair.dst().usesTmp(tmp))
400	return false;
401	}
402	return true;
403	});
404
405	scratch = getScratch(0, scratch);
406
407	Arg rotateSave = scratch ? Arg(scratch) : scratches[0];
408
409	handleShiftPair(
410	ShufflePair(rotate.loop.last().dst(), rotateSave, rotate.loop[0].width()), 1);
411
412	for (unsigned i = rotate.loop.size(); i-- > 1;)
413	handleShiftPair(rotate.loop[i], 1);
414
415	handleShiftPair(
416	ShufflePair(rotateSave, rotate.loop[0].dst(), rotate.loop[0].width()), 1);
417
418	if (scratch)
419	returnScratch(0, scratch);
420	}
421
422	commitResult();
423	}
424
425	ASSERT(result.isEmpty());
426
427	for (unsigned i = resultPacks.size(); i--;)
428	result.appendVector(resultPacks[i]);
429
430	return result;
431	}
432
433	Vector<Inst> emitShuffle(
434	const Vector<ShufflePair>& pairs,
435	const std::array<Arg, 2>& gpScratch, const std::array<Arg, 2>& fpScratch,
436	Value* origin)
437	{
438	Vector<ShufflePair> gpPairs;
439	Vector<ShufflePair> fpPairs;
440	for (const ShufflePair& pair : pairs) {
441	if (pair.src().isMemory() && pair.dst().isMemory() && pair.width() > Arg::pointerWidth()) {
442	// 8-byte memory-to-memory moves on a 32-bit platform are best handled as float moves.
443	fpPairs.append(pair);
444	} else if (pair.src().isGP() && pair.dst().isGP()) {
445	// This means that gpPairs gets memory-to-memory shuffles. The assumption is that we
446	// can do that more efficiently using GPRs, except in the special case above.
447	gpPairs.append(pair);
448	} else
449	fpPairs.append(pair);
450	}
451
452	Vector<Inst> result;
453	result.appendVector(emitShuffle(gpPairs, gpScratch, Arg::GP, origin));
454	result.appendVector(emitShuffle(fpPairs, fpScratch, Arg::FP, origin));
455	return result;
456	}
457
458	} } } // namespace JSC::B3::Air
459
460	#endif // ENABLE(B3_JIT)
461

Line 0 Source/JavaScriptCore/b3/air/AirLowerAfterRegAlloc.cpp_sec1
- Source/JavaScriptCore/b3/air/AirLowerAfterRegAlloc.cpp +207 lines
		1	/*
		2	* Copyright (C) 2016 Apple Inc. All rights reserved.
		3	*
		4	* Redistribution and use in source and binary forms, with or without
		5	* modification, are permitted provided that the following conditions
		6	* are met:
		7	* 1. Redistributions of source code must retain the above copyright
		8	* notice, this list of conditions and the following disclaimer.
		9	* 2. Redistributions in binary form must reproduce the above copyright
		10	* notice, this list of conditions and the following disclaimer in the
		11	* documentation and/or other materials provided with the distribution.
		12	*
		13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
		14	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		15	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
		17	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		18	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		19	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		20	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
		21	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
		22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
		23	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		24	*/
		25
		26	#include "config.h"
		27	#include "AirLowerAfterRegAlloc.h"
		28
		29	#if ENABLE(B3_JIT)
		30
		31	#include "AirCCallingConvention.h"
		32	#include "AirCode.h"
		33	#include "AirEmitShuffle.h"
		34	#include "AirInsertionSet.h"
		35	#include "AirInstInlines.h"
		36	#include "AirLiveness.h"
		37	#include "AirPhaseScope.h"
		38	#include "AirRegisterPriority.h"
		39	#include "B3CCallValue.h"
		40	#include "RegisterSet.h"
		41	#include <wtf/HashMap.h>
		42
		43	namespace JSC { namespace B3 { namespace Air {
		44
		45	void lowerAfterRegAlloc(Code& code)
		46	{
		47	PhaseScope phaseScope(code, "lowerAfterRegAlloc");
		48
		49	HashMap<Inst*, RegisterSet> usedRegisters;
		50
		51	RegLiveness liveness(code);
		52	for (BasicBlock* block : code) {
		53	RegLiveness::LocalCalc localCalc(liveness, block);
		54
		55	for (unsigned instIndex = block->size(); instIndex--;) {
		56	Inst& inst = block->at(instIndex);
		57
		58	RegisterSet set;
		59
		60	if (inst.opcode == Shuffle \|\| inst.opcode == ColdCCall) {
		61	for (Reg reg : localCalc.live())
		62	set.set(reg);
		63	}
		64
65	localCalc.execute(instIndex);
66
67	if (set.numberOfSetRegisters())
68	usedRegisters.add(&inst, set);
69	}
70	}
71
72	auto getScratches = [&] (const RegisterSet& set, Arg::Type type) -> std::array<Arg, 2> {
73	std::array<Arg, 2> result;
74	for (unsigned i = 0; i < 2; ++i) {
75	bool found = false;
76	for (Reg reg : regsInPriorityOrder(type)) {
77	if (!set.get(reg)) {
78	result[i] = Tmp(reg);
79	found = true;
80	break;
81	}
82	}
83	if (!found) {
84	result[i] = Arg::stack(
85	code.addStackSlot(
86	Arg::bytes(Arg::conservativeWidth(type)),
87	StackSlotKind::Anonymous));
88	}
89	}
90	return result;
91	};
92
93	// Now transform the code.
94	InsertionSet insertionSet(code);
95	for (BasicBlock* block : code) {
96	for (unsigned instIndex = 0; instIndex < block->size(); ++instIndex) {
97	Inst& inst = block->at(instIndex);
98
99	switch (inst.opcode) {
100	case Shuffle: {
101	RegisterSet set = usedRegisters.get(&inst);
102	Vector<ShufflePair> pairs;
103	for (unsigned i = 0; i < inst.args.size(); i += 3) {
104	Arg src = inst.args[i + 0];
105	Arg dst = inst.args[i + 1];
106	Arg::Width width = inst.args[i + 2].width();
107	if (src.isReg())
108	set.set(src.reg());
109	pairs.append(ShufflePair(src, dst, width));
110	}
111	std::array<Arg, 2> gpScratch = getScratches(set, Arg::GP);
112	std::array<Arg, 2> fpScratch = getScratches(set, Arg::FP);
113	insertionSet.insertInsts(
114	instIndex, emitShuffle(pairs, gpScratch, fpScratch, inst.origin));
115	inst = Inst();
116	break;
117	}
118
119	case ColdCCall: {
120	CCallValue* value = inst.origin->as<CCallValue>();
121
122	RegisterSet preUsed;
123	Vector<Arg> destinations = computeCCallingConvention(code, value);
124	Tmp result = cCallResult(value->type());
125
126	Vector<ShufflePair> pairs;
127	for (unsigned i = 0; i < destinations.size(); ++i) {
128	Value* child = value->child(i);
129	Arg src = inst.args[result ? (i >= 1 ? i + 1 : i) : i ];
130	Arg dst = destinations[i];
131	Arg::Width width = Arg::widthForB3Type(child->type());
132	pairs.append(ShufflePair(src, dst, width));
133	if (src.isReg())
134	preUsed.set(src.reg());
135	}
136
137	std::array<Arg, 2> gpScratch = getScratches(preUsed, Arg::GP);
138	std::array<Arg, 2> fpScratch = getScratches(preUsed, Arg::FP);
139
140	RegisterSet regsToSave = usedRegisters.get(&inst);
141
142	// Also need to save all live registers. Don't need to worry about the result
143	// register.
144	if (result)
145	regsToSave.clear(result.reg());
146	Vector<StackSlot*> stackSlots;
147	regsToSave.forEach(
148	[&] (Reg reg) {
149	Tmp tmp(reg);
150	Arg arg(tmp);
151	Arg::Width width = Arg::conservativeWidth(arg.type());
152	StackSlot* stackSlot =
153	code.addStackSlot(Arg::bytes(width), StackSlotKind::Anonymous);
154	pairs.append(ShufflePair(arg, Arg::stack(stackSlot), width));
155	stackSlots.append(stackSlot);
156	});
157
158	insertionSet.insertInsts(
159	instIndex, emitShuffle(pairs, gpScratch, fpScratch, inst.origin));
160
161	inst = buildCCall(code, inst.origin, destinations);
162
163	// Now we need to emit code to restore registers.
164	pairs.resize(0);
165	unsigned stackSlotIndex = 0;
166	regsToSave.forEach(
167	[&] (Reg reg) {
168	Tmp tmp(reg);
169	Arg arg(tmp);
170	Arg::Width width = Arg::conservativeWidth(arg.type());
171	StackSlot* stackSlot = stackSlots[stackSlotIndex++];
172	pairs.append(ShufflePair(Arg::stack(stackSlot), arg, width));
173	});
174	if (result) {
175	ShufflePair pair(result, inst.args[1], Arg::widthForB3Type(value->type()));
176	pairs.append(pair);
177	}
178
179	if (result)
180	regsToSave.set(result.reg());
181
182	gpScratch = getScratches(regsToSave, Arg::GP);
183	fpScratch = getScratches(regsToSave, Arg::FP);
184
185	insertionSet.insertInsts(
186	instIndex + 1, emitShuffle(pairs, gpScratch, fpScratch, inst.origin));
187	break;
188	}
189
190	default:
191	break;
192	}
193	}
194
195	insertionSet.execute(block);
196
197	block->insts().removeAllMatching(
198	[&] (Inst& inst) -> bool {
199	return !inst;
200	});
201	}
202	}
203
204	} } } // namespace JSC::B3::Air
205
206	#endif // ENABLE(B3_JIT)
207

Line 0 Source/JavaScriptCore/b3/air/AirLowerMacros.cpp_sec1
- Source/JavaScriptCore/b3/air/AirLowerMacros.cpp +105 lines
		1	/*
		2	* Copyright (C) 2016 Apple Inc. All rights reserved.
		3	*
		4	* Redistribution and use in source and binary forms, with or without
		5	* modification, are permitted provided that the following conditions
		6	* are met:
		7	* 1. Redistributions of source code must retain the above copyright
		8	* notice, this list of conditions and the following disclaimer.
		9	* 2. Redistributions in binary form must reproduce the above copyright
		10	* notice, this list of conditions and the following disclaimer in the
		11	* documentation and/or other materials provided with the distribution.
		12	*
		13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
		14	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		15	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
		17	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		18	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		19	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		20	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
		21	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
		22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
		23	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		24	*/
		25
		26	#include "config.h"
		27	#include "AirLowerMacros.h"
		28
		29	#if ENABLE(B3_JIT)
		30
		31	#include "AirCCallingConvention.h"
		32	#include "AirCode.h"
		33	#include "AirInsertionSet.h"
		34	#include "AirInstInlines.h"
		35	#include "AirPhaseScope.h"
		36	#include "B3CCallValue.h"
		37	#include "B3ValueInlines.h"
		38
		39	namespace JSC { namespace B3 { namespace Air {
		40
		41	void lowerMacros(Code& code)
		42	{
		43	PhaseScope phaseScope(code, "lowerMacros");
		44
		45	InsertionSet insertionSet(code);
		46	for (BasicBlock* block : code) {
		47	for (unsigned instIndex = 0; instIndex < block->size(); ++instIndex) {
		48	Inst& inst = block->at(instIndex);
		49
		50	switch (inst.opcode) {
		51	case CCall: {
		52	CCallValue* value = inst.origin->as<CCallValue>();
		53
		54	Vector<Arg> destinations = computeCCallingConvention(code, value);
		55
		56	Inst shuffleArguments(Shuffle, value);
		57	unsigned offset = value->type() == Void ? 0 : 1;
		58	for (unsigned i = 1; i < destinations.size(); ++i) {
		59	Value* child = value->child(i);
		60	shuffleArguments.args.append(inst.args[offset + i]);
		61	shuffleArguments.args.append(destinations[i]);
		62	shuffleArguments.args.append(Arg::widthArg(Arg::widthForB3Type(child->type())));
		63	}
		64	insertionSet.insertInst(instIndex, WTFMove(shuffleArguments));
65
66	// Indicate that we're using our original callee argument.
67	destinations[0] = inst.args[0];
68
69	// Save where the original instruction put its result.
70	Arg resultDst = value->type() == Void ? Arg() : inst.args[1];
71
72	inst = buildCCall(code, inst.origin, destinations);
73
74	Tmp result = cCallResult(value->type());
75	switch (value->type()) {
76	case Void:
77	break;
78	case Float:
79	insertionSet.insert(instIndex + 1, MoveFloat, value, result, resultDst);
80	break;
81	case Double:
82	insertionSet.insert(instIndex + 1, MoveDouble, value, result, resultDst);
83	break;
84	case Int32:
85	insertionSet.insert(instIndex + 1, Move32, value, result, resultDst);
86	break;
87	case Int64:
88	insertionSet.insert(instIndex + 1, Move, value, result, resultDst);
89	break;
90	}
91	break;
92	}
93
94	default:
95	break;
96	}
97	}
98	insertionSet.execute(block);
99	}
100	}
101
102	} } } // namespace JSC::B3::Air
103
104	#endif // ENABLE(B3_JIT)
105

Lines 1-5 Source/JavaScriptCore/b3/air/AirRegisterPriority.h_sec1
- Source/JavaScriptCore/b3/air/AirRegisterPriority.h -2 / +2 lines
1	/*	1	/*
2	* Copyright (C) 2015 Apple Inc. All rights reserved.	2	* Copyright (C) 2015-2016 Apple Inc. All rights reserved.
3	*	3	*
4	* Redistribution and use in source and binary forms, with or without	4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions	5	* modification, are permitted provided that the following conditions
Lines 52-58 const Vector<typename Bank::RegisterType Source/JavaScriptCore/b3/air/AirRegisterPriority.h_sec2
52	return RegistersInPriorityOrder<Bank>::inPriorityOrder();	52	return RegistersInPriorityOrder<Bank>::inPriorityOrder();
53	}	53	}
54		54
55	const Vector<Reg>& regsInPriorityOrder(Arg::Type);	55	JS_EXPORT_PRIVATE const Vector<Reg>& regsInPriorityOrder(Arg::Type);
56		56
57	} } } // namespace JSC::B3::Air	57	} } } // namespace JSC::B3::Air
58		58