What AttributeTarget should I use for enum members?

I want to use my IsGPUBasedAttribute for enum members like this:

public enum EffectType
{
	[IsGPUBased(true)]
	PixelShader,

	[IsGPUBased(false)]
	Blur
}

but the compiler doesn't let me to use:

[AttributeUsage (AttributeTargets.Enum, AllowMultiple = false)]

What is the right AttributeTarget value to limit the usage to enum members?

Far as I know, there isn't one specifically for enum constants. The closest you could get would probably be "Field", which limits the use to field members of a class or struct (which Enum constants are treated as for purposes of attributes).

EDIT: bringing the explanation of "why" up from the comments, Enum constants are exactly that, and as such their values and usages are [embedded directly into the IL][1]. An enum declaration is therefore really not very different from creating a static class definition with static constant members:

public static class MyEnum
{
    public const int Value1 = 0;
    public const int Value2 = 1;
    public const int Value3 = 2;
    public const int Value4 = 3;        
}

... the only difference being that it derives from System.Enum which is a value type instead of being a reference class (you can't create a static struct, nor an unconstructible one). [1]: http://www.dotnetperls.com/enum-performance

AttributeTargets.Field allow you to use attribute for enum values.

[AttributeUsage(AttributeTargets.Field)]

There isn't a way to specify that an attribute can be used only on enum members. Honestly, you're probably better off creating your own Effect (or EffectType) class and implementing these as ordinary properties if you're going to have multiple attributes like this.

For example,

public class EffectType
{
    public bool IsGpuBased { get; private set; }

    private EffectType(bool isGpuBased)
    {
        IsGpuBased = isGpuBased;
    }

    public static readonly EffectType PixelShader = new EffectType(true);
    public static readonly EffectType Blur = new EffectType(false);
}

Taking this approach will give you code that's both easier to read and will perform better compared to metadata extraction.

[AttributeUsage(AttributeTargets.Field)]