[clang-format] Add BreakBeforeInlineASMColon configuration

[anastasiia_lukianenko]

Summary

If `true`, colons in ASM parameters will be placed after line breaks.
true:

asm volatile("string",
                     :
                     : val);

false:
asm volatile("string", : : val);

[MyDeveloperDay]

1. this needs a full context diff (diff -U 999999)
2. this needs unit tests

[anastasiia_lukianenko]

1. Diff was made by git diff with full context
2. Added description in documentation
3. Added unit test

[MyDeveloperDay]

Do you think we should show what it looks like with more complex asm examples in the tests?

what would the following look like?

asm volatile("rbit %[aVal], %[aVal]" : [aVal] "+r"(val) : "[aVal]"(val));
__asm__ __volatile__("str x0, %0" : "=m"(regs->regs[0]));
asm volatile ("get\t%0,rfsl" stringify(id) : "=d" (val))

asm ("mov %1, %0\n\t"
    "add $1, %0"
    : "=r" (dst) 
    : "r" (src));

For the "purpose of the tape" is there a reason or group of people who prefer this style? (gcc, linux kernel)

[anastasiia_lukianenko]

Nothing will happen with your examples, because the line length is less than column limit. But if I make parameters longer results will be:

BreakBeforeInlineASMColon = false;

asm volatile("rbffffit %[aVal], %[aVal]" : [aVal] "+r"(val)
             : "[aVaffffl]"(val));
__asm__ __volatile__("str fffffx0, %0"
                     : "=fffffffffffffffffffffm"(regs->regs[0]));
asm volatile("get\t%0,rffffffffsl" stringify(id)
             : "=dfffffffffffffffffffffff"(val))

BreakBeforeInlineASMColon = true;

asm volatile("rbffffit %[aVal], %[aVal]"
             : [aVal] "+r"(val)
             : "[aVaffffl]"(val));
__asm__ __volatile__("str fffffx0, %0"
                     : "=fffffffffffffffffffffm"(regs->regs[0]));
asm volatile("get\t%0,rffffffffsl" stringify(id)
             : "=dfffffffffffffffffffffff"(val))

And asking the question who will use this configuration:
We are trying to use the clang-format approach as a base for Xen [1] style formatting. During the state of testing clang-format with different configurations, we found that some points regarding the Xen coding style are not
configurable. Therefore, we decided to add them (this and other my patches [2], [3]) to be able to make a choice in different cases.

[1] - https://xenproject.org/
[2] - https://reviews.llvm.org/D92168
[3] - https://reviews.llvm.org/D91949

[MyDeveloperDay]

1. You need to default initialize BreakBeforeInlineASMColon in the LLVM style.

FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
       ...
       LLVMStyle.BreakBeforeInlineASMColon  = false;
       ...

2. You need a "CHECK_PARSE_BOOL" unit test

CHECK_PARSE_BOOL(BreakBeforeInlineASMColon  );

[MyDeveloperDay]

My understanding is that the following current behavour

asm("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
    : "DEF"
    : "GHI");

asm volatile(
    "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
    : "DEF"
    : "GHI");

asm("AAAAAAAAAAAAAAAAAAA" : "DEF" : "GHI");

asm volatile("AAAAAAAAAAAAA" : "DEF" : "GHI");

asm volatile("AAAAAAAAAAAAA" : "DEF"(dst) : "GHI"(src));
asm volatile("AAAAAAAAAAAAA" : "DEF"(dst));

asm volatile("AAAAAAAAAAAAA" : [Foo] "DEF"(dst) : [Foo] "GHI"(src));
asm volatile("AAAAAAAAAAAAA" : % [Foo] "DEF"(dst) : % [Foo] "GHI"(src));

should generate as the following (with the option set to true) correct?

asm("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
    : "DEF"
    : "GHI");

asm volatile(
    "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
    : "DEF"
    : "GHI");

asm("AAAAAAAAAAAAAAAAAAA"
    : "DEF"
    : "GHI");

asm volatile("AAAAAAAAAAAAA"
    : "DEF"
    : "GHI");

asm volatile("AAAAAAAAAAAAA"
    : "DEF"(dst)
    : "GHI"(src));

asm volatile("AAAAAAAAAAAAA"
    : "DEF"(dst));

asm volatile("AAAAAAAAAAAAA"
    : [Foo] "DEF"(dst) : [Foo] "GHI"(src));

asm volatile("AAAAAAAAAAAAA"
    : %[Foo] "DEF"(dst)
    : %[Foo] "GHI"(src));

is that correct? I highly recommend adding a few more examples in the test to show this behavior isn't just for "loooong" strings

NOTE: there is a bug in the way '%[Foo]' would get formatted to be '% [Foo]'

[anastasiia_lukianenko]

For now without my patch current behavior is the following:
Your examples listed below:

asm("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
    : "DEF"
    : "GHI");

asm volatile(
    "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
    : "DEF"
    : "GHI");

asm("AAAAAAAAAAAAAAAAAAA" : "DEF" : "GHI");

asm volatile("AAAAAAAAAAAAA" : "DEF" : "GHI");

asm volatile("AAAAAAAAAAAAA" : "DEF"(dst) : "GHI"(src));
asm volatile("AAAAAAAAAAAAA" : "DEF"(dst));

asm volatile("AAAAAAAAAAAAA" : [Foo] "DEF"(dst) : [Foo] "GHI"(src));
asm volatile("AAAAAAAAAAAAA" : % [Foo] "DEF"(dst) : % [Foo] "GHI"(src));

Formatted with clang-format in this way:

asm("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
    : "DEF"
    : "GHI");

asm volatile(
    "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
    : "DEF"
    : "GHI");

asm("AAAAAAAAAAAAAAAAAAA" : "DEF" : "GHI");

asm volatile("AAAAAAAAAAAAA" : "DEF" : "GHI");

asm volatile("AAAAAAAAAAAAA" : "DEF"(dst) : "GHI"(src));
asm volatile("AAAAAAAAAAAAA" : "DEF"(dst));

asm volatile("AAAAAAAAAAAAA" : [Foo] "DEF"(dst) : [Foo] "GHI"(src));
asm volatile("AAAAAAAAAAAAA" : % [Foo] "DEF"(dst) : % [Foo] "GHI"(src));

So that's why my patch is breaking only long strings. If this is a bug, I can try to fix it. Then I update my patch so the configuration will be as @MyDeveloperDay expected.

[MyDeveloperDay]

Maybe I'm confused, if you set this setting isn't it to break before ever ASM Colon is that not what is required?

[anastasiia_lukianenko]

BreakBeforeInlineASMColon configuration was created to have an option of removing this break, because without my patch it breaks before ASM colon in long lines. That's why I saved the behavior of BreakBeforeInlineASMColon=true as it was initially.
Therefore, I'm asking you is this a bug - breaking only long lines or this is normal clang-format behavior?

[MyDeveloperDay]

I think my expectation would be that if you are going to have an option BreakBeforeInlineASMColon then it should do it for all case long and short, otherwise its not going to be clear.

[HazardyKnusperkeks]

clang/unittests/Format/FormatTest.cpp

7267

You should add a test case with long lines. You can use a style with a lower ColumnLimit for that.

[HazardyKnusperkeks]

Looks good, but please fix the clang-format notes.

[HazardyKnusperkeks]

LGTM but please wait for @MyDeveloperDay opinion.

[HazardyKnusperkeks]

Then we can push it, do you need some one to do that? If yes please post name and email.

clang/unittests/Format/FormatTest.cpp

23812

I think the pre merge lint means this line.
Please fix that and rebase on current main.

[HazardyKnusperkeks]

clang/unittests/Format/FormatTest.cpp

4555

I already gave my go in the past, but now I have to wonder, why are you setting this to true here? Does this mean before your change clang-format did behave as if the option is true? If that's the case please set the default also to true. If the old behavior is neither true nor false we have to find something different.

[anastasiia_lukianenko]

clang/unittests/Format/FormatTest.cpp

4555

Old behavior is neither true nor false. As I understand, the behavior was doing break only in case when the string length is longer than column limit.

[HazardyKnusperkeks]

Then I am sorry that I've missed that before. But you need to change your bool to an enum and also model the current behavior, so that there is no change in formatting without adapting the .clang-format. A option names maybe Always, Never, and OnlyMultiline?

[HazardyKnusperkeks]

And format what clang-format says. Then it looks good to me.

clang/unittests/Format/FormatTest.cpp

7269

Could you add for Never and Always the code from Above?

"asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
"    \"cpuid\\n\\t\"\n"
"    \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
"    : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n"
"    : \"a\"(value));"

[MyDeveloperDay]

clang/lib/Format/Format.cpp

1277

Are we happy that is the correct default? didn't it always break before?

[anastasiia_lukianenko]

clang/lib/Format/Format.cpp

1277

It didn't always break before. Old tests in FormatsInlineASM block prove this:

verifyFormat("asm(\"nop\" ::: \"memory\");");
  verifyFormat(
      "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
      "    \"cpuid\\n\\t\"\n"
      "    \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
      "    : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n"
      "    : \"a\"(value));");

[anastasiia_lukianenko]

@HazardyKnusperkeks @MyDeveloperDay Could you please review the last version?

[HazardyKnusperkeks]

If you still want this to be landed, we need a name and email for the commit.

[HazardyKnusperkeks]

@MyDeveloperDay @owenpan What shall we do?

1. Abandon this
2. Commit it in our name
3. Use the email from this commit: https://github.com/Wandalen/game_chess/commit/a84bba03667643ded0cfe7aff2907c6546a6a192 I'm pretty sure this is the correct person

[owenpan]

In D91950#3915777, @HazardyKnusperkeks wrote:

@MyDeveloperDay @owenpan What shall we do?

1. Abandon this
2. Commit it in our name
3. Use the email from this commit: https://github.com/Wandalen/game_chess/commit/a84bba03667643ded0cfe7aff2907c6546a6a192 I'm pretty sure this is the correct person

IMO we should either commit it with her name only or also include the email you found.

[MyDeveloperDay]

I think this is them..

https://twitter.com/xen_org/status/1397581514318225412
https://xenproject.org/
https://xenproject.org/2021/09/22/clang-format-for-xen-coding-style-checking-scheduled/
https://www.youtube.com/watch?v=3EVE0TTEztc

https://github.com/NastyaVicodin

[HazardyKnusperkeks]

In D91950#3917635, @MyDeveloperDay wrote:

I think this is them..

https://twitter.com/xen_org/status/1397581514318225412
https://xenproject.org/
https://xenproject.org/2021/09/22/clang-format-for-xen-coding-style-checking-scheduled/
https://www.youtube.com/watch?v=3EVE0TTEztc

https://github.com/NastyaVicodin

Yep, from that github account I got the mail.

clang/docs/ClangFormatStyleOptions.rst

* ``BBCDS_Always`` (in configuration: ``Always``)
 
     .. code-block:: c++
 
       template <typename T>
       concept C = ...;
 
 
 
+**BreakBeforeInlineASMColon** (``BreakBeforeInlineASMColonStyle``) :versionbadge:`clang-format 16`
+  The inline ASM colon style to use.
+
+  Possible values:
+
+  * ``BBIAS_Never`` (in configuration: ``Never``)
+    No break before inline ASM colon.
+
+    .. code-block:: c++
+
+       asm volatile("string", : : val);
+
+  * ``BBIAS_OnlyMultiline`` (in configuration: ``OnlyMultiline``)
+    Break before inline ASM colon if the line length is longer than column
+    limit.
+
+    .. code-block:: c++
+
+       asm volatile("string", : : val);
+       asm("cmoveq %1, %2, %[result]"
+           : [result] "=r"(result)
+           : "r"(test), "r"(new), "[result]"(old));
+
+  * ``BBIAS_Always`` (in configuration: ``Always``)
+    Always break before inline ASM colon.
+
+    .. code-block:: c++
+
+       asm volatile("string",
+                    :
+                    : val);
+
+
+
 **BreakBeforeTernaryOperators** (``Boolean``) :versionbadge:`clang-format 3.7`
   If ``true``, ternary operators will be placed after line breaks.
 
   .. code-block:: c++
 
      true:
      veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription
          ? firstValue

clang/include/clang/Format/Format.h

enum BreakBeforeConceptDeclarationsStyle : int8_t {
     /// \endcode
     BBCDS_Always,
   };
 
   /// The concept declaration style to use.
   /// \version 12
   BreakBeforeConceptDeclarationsStyle BreakBeforeConceptDeclarations;
 
+  /// Different ways to break ASM parameters.
+  enum BreakBeforeInlineASMColonStyle : int8_t {
+    /// No break before inline ASM colon.
+    /// \code
+    ///    asm volatile("string", : : val);
+    /// \endcode
+    BBIAS_Never,
+    /// Break before inline ASM colon if the line length is longer than column
+    /// limit.
+    /// \code
+    ///    asm volatile("string", : : val);
+    ///    asm("cmoveq %1, %2, %[result]"
+    ///        : [result] "=r"(result)
+    ///        : "r"(test), "r"(new), "[result]"(old));
+    /// \endcode
+    BBIAS_OnlyMultiline,
+    /// Always break before inline ASM colon.
+    /// \code
+    ///    asm volatile("string",
+    ///                 :
+    ///                 : val);
+    /// \endcode
+    BBIAS_Always,
+  };
+
+  /// The inline ASM colon style to use.
+  /// \version 16
+  BreakBeforeInlineASMColonStyle BreakBeforeInlineASMColon;
+
   /// If ``true``, ternary operators will be placed after line breaks.
   /// \code
   ///    true:
   ///    veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription
   ///        ? firstValue
   ///        : SecondValueVeryVeryVeryVeryLong;
   ///
   ///    false:
return AccessModifierOffset == R.AccessModifierOffset &&
            BinPackArguments == R.BinPackArguments &&
            BinPackParameters == R.BinPackParameters &&
            BitFieldColonSpacing == R.BitFieldColonSpacing &&
            BreakAfterJavaFieldAnnotations == R.BreakAfterJavaFieldAnnotations &&
            BreakArrays == R.BreakArrays &&
            BreakBeforeBinaryOperators == R.BreakBeforeBinaryOperators &&
            BreakBeforeBraces == R.BreakBeforeBraces &&
            BreakBeforeConceptDeclarations == R.BreakBeforeConceptDeclarations &&
+           BreakBeforeInlineASMColon == R.BreakBeforeInlineASMColon &&
            BreakBeforeTernaryOperators == R.BreakBeforeTernaryOperators &&
            BreakConstructorInitializers == R.BreakConstructorInitializers &&
            BreakInheritanceList == R.BreakInheritanceList &&
            BreakStringLiterals == R.BreakStringLiterals &&
            ColumnLimit == R.ColumnLimit && CommentPragmas == R.CommentPragmas &&
            CompactNamespaces == R.CompactNamespaces &&
            ConstructorInitializerIndentWidth ==
                R.ConstructorInitializerIndentWidth &&

clang/lib/Format/ContinuationIndenter.cpp

bool ContinuationIndenter::mustBreak(const LineState &State) {
   const FormatToken &Current = *State.NextToken;
   const FormatToken &Previous = *Current.Previous;
   const auto &CurrentState = State.Stack.back();
   if (Style.BraceWrapping.BeforeLambdaBody && Current.CanBreakBefore &&
       Current.is(TT_LambdaLBrace) && Previous.isNot(TT_LineComment)) {
     auto LambdaBodyLength = getLengthToMatchingParen(Current, State.Stack);
     return LambdaBodyLength > getColumnLimit(State);
   }
-  if (Current.MustBreakBefore || Current.is(TT_InlineASMColon))
+  if (Current.MustBreakBefore ||
+      (Current.is(TT_InlineASMColon) &&
+       (Style.BreakBeforeInlineASMColon == FormatStyle::BBIAS_Always ||
+        Style.BreakBeforeInlineASMColon == FormatStyle::BBIAS_OnlyMultiline))) {
     return true;
+  }
   if (CurrentState.BreakBeforeClosingBrace &&
       Current.closesBlockOrBlockTypeList(Style)) {
     return true;
   }
   if (CurrentState.BreakBeforeClosingParen && Current.is(tok::r_paren))
     return true;
   if (Style.Language == FormatStyle::LK_ObjC &&
       Style.ObjCBreakBeforeNestedBlockParam &&

clang/lib/Format/Format.cpp

enumeration(IO &IO, FormatStyle::BreakBeforeConceptDeclarationsStyle &Value) {
 
     // For backward compatibility.
     IO.enumCase(Value, "true", FormatStyle::BBCDS_Always);
     IO.enumCase(Value, "false", FormatStyle::BBCDS_Allowed);
   }
 };
 
 template <>
+struct ScalarEnumerationTraits<FormatStyle::BreakBeforeInlineASMColonStyle> {
+  static void enumeration(IO &IO,
+                          FormatStyle::BreakBeforeInlineASMColonStyle &Value) {
+    IO.enumCase(Value, "Never", FormatStyle::BBIAS_Never);
+    IO.enumCase(Value, "OnlyMultiline", FormatStyle::BBIAS_OnlyMultiline);
+    IO.enumCase(Value, "Always", FormatStyle::BBIAS_Always);
+  }
+};
+template <>
 struct ScalarEnumerationTraits<FormatStyle::BreakConstructorInitializersStyle> {
   static void
   enumeration(IO &IO, FormatStyle::BreakConstructorInitializersStyle &Value) {
     IO.enumCase(Value, "BeforeColon", FormatStyle::BCIS_BeforeColon);
     IO.enumCase(Value, "BeforeComma", FormatStyle::BCIS_BeforeComma);
     IO.enumCase(Value, "AfterColon", FormatStyle::BCIS_AfterColon);
   }
 };
static void mapping(IO &IO, FormatStyle &Style) {
     IO.mapOptional("BreakAfterJavaFieldAnnotations",
                    Style.BreakAfterJavaFieldAnnotations);
     IO.mapOptional("BreakArrays", Style.BreakArrays);
     IO.mapOptional("BreakBeforeBinaryOperators",
                    Style.BreakBeforeBinaryOperators);
     IO.mapOptional("BreakBeforeConceptDeclarations",
                    Style.BreakBeforeConceptDeclarations);
     IO.mapOptional("BreakBeforeBraces", Style.BreakBeforeBraces);
+    IO.mapOptional("BreakBeforeInlineASMColon",
+                   Style.BreakBeforeInlineASMColon);
     IO.mapOptional("BreakBeforeTernaryOperators",
                    Style.BreakBeforeTernaryOperators);
     IO.mapOptional("BreakConstructorInitializers",
                    Style.BreakConstructorInitializers);
     IO.mapOptional("BreakInheritanceList", Style.BreakInheritanceList);
     IO.mapOptional("BreakStringLiterals", Style.BreakStringLiterals);
     IO.mapOptional("ColumnLimit", Style.ColumnLimit);
     IO.mapOptional("CommentPragmas", Style.CommentPragmas);
FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
   LLVMStyle.AlwaysBreakBeforeMultilineStrings = false;
   LLVMStyle.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_MultiLine;
   LLVMStyle.AttributeMacros.push_back("__capability");
   LLVMStyle.BinPackArguments = true;
   LLVMStyle.BinPackParameters = true;
   LLVMStyle.BreakArrays = true;
   LLVMStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
   LLVMStyle.BreakBeforeConceptDeclarations = FormatStyle::BBCDS_Always;
+  LLVMStyle.BreakBeforeInlineASMColon = FormatStyle::BBIAS_OnlyMultiline;
   LLVMStyle.BreakBeforeTernaryOperators = true;
   LLVMStyle.BreakBeforeBraces = FormatStyle::BS_Attach;
   LLVMStyle.BraceWrapping = {/*AfterCaseLabel=*/false,
                              /*AfterClass=*/false,
                              /*AfterControlStatement=*/FormatStyle::BWACS_Never,
                              /*AfterEnum=*/false,
                              /*AfterFunction=*/false,
                              /*AfterNamespace=*/false,

clang/lib/Format/TokenAnnotator.cpp

if ((Left.is(TT_ArrayInitializerLSquare) && Left.is(tok::l_square) &&
           return true;
         if (Tok->isOneOf(tok::r_brace, tok::r_square))
           break;
       }
       return Style.BreakArrays;
     }
   }
 
+  if (Line.startsWith(tok::kw_asm) && Right.is(TT_InlineASMColon) &&
+      Style.BreakBeforeInlineASMColon == FormatStyle::BBIAS_Always) {
+    return true;
+  }
+
   // If the last token before a '}', ']', or ')' is a comma or a trailing
   // comment, the intention is to insert a line break after it in order to make
   // shuffling around entries easier. Import statements, especially in
   // JavaScript, can be an exception to this rule.
   if (Style.JavaScriptWrapImports || Line.Type != LT_ImportStatement) {
     const FormatToken *BeforeClosingBrace = nullptr;
     if ((Left.isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) ||
          (Style.isJavaScript() && Left.is(tok::l_paren))) &&

clang/unittests/Format/FormatTest.cpp

verifyFormat("extern \"C\"\n"
                Style);
 }
 
 TEST_F(FormatTest, FormatsInlineASM) {
   verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));");
   verifyFormat("asm(\"nop\" ::: \"memory\");");
   verifyFormat(
       "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
       "    \"cpuid\\n\\t\"\n"
       "    \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
       "    : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n"
       "    : \"a\"(value));");
   EXPECT_EQ(
       "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n"
       "  __asm {\n"
       "        mov     edx,[that] // vtable in edx\n"
       "        mov     eax,methodIndex\n"
TEST_F(FormatTest, AllowAllArgumentsOnNextLineDontAlign) {
   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
   EXPECT_EQ(StringRef("functionCall(\n"
                       "    paramA, paramB, paramC);\n"
                       "void functionDecl(\n"
                       "    int A, int B, int C);"),
             format(Input, Style));
 }
 
+TEST_F(FormatTest, BreakBeforeInlineASMColon) {
+  FormatStyle Style = getLLVMStyle();
+  Style.BreakBeforeInlineASMColon = FormatStyle::BBIAS_Never;
+  /* Test the behaviour with long lines */
+  Style.ColumnLimit = 40;
+  verifyFormat("asm volatile(\"loooooooooooooooooooong\",\n"
+               "             : : val);",
+               Style);
+  verifyFormat("asm volatile(\"loooooooooooooooooooong\",\n"
+               "             : val1 : val2);",
+               Style);
+  verifyFormat("asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
+               "    \"cpuid\\n\\t\"\n"
+               "    \"xchgq\\t%%rbx %%rsi\\n\\t\",\n"
+               "    : \"=a\" : \"a\");",
+               Style);
+  Style.ColumnLimit = 80;
+  verifyFormat("asm volatile(\"string\", : : val);", Style);
+  verifyFormat("asm volatile(\"string\", : val1 : val2);", Style);
+
+  Style.BreakBeforeInlineASMColon = FormatStyle::BBIAS_Always;
+  verifyFormat("asm volatile(\"string\",\n"
+               "             :\n"
+               "             : val);",
+               Style);
+  verifyFormat("asm volatile(\"string\",\n"
+               "             : val1\n"
+               "             : val2);",
+               Style);
+  /* Test the behaviour with long lines */
+  Style.ColumnLimit = 40;
+  verifyFormat("asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
+               "    \"cpuid\\n\\t\"\n"
+               "    \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
+               "    : \"=a\"(*rEAX)\n"
+               "    : \"a\"(value));",
+               Style);
+  verifyFormat("asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
+               "    \"cpuid\\n\\t\"\n"
+               "    \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
+               "    :\n"
+               "    : \"a\"(value));",
+               Style);
+  verifyFormat("asm volatile(\"loooooooooooooooooooong\",\n"
+               "             :\n"
+               "             : val);",
+               Style);
+  verifyFormat("asm volatile(\"loooooooooooooooooooong\",\n"
+               "             : val1\n"
+               "             : val2);",
+               Style);
+}
+
 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) {
   FormatStyle Style = getLLVMStyle();
   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
 
   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}",
                getStyleWithColumns(Style, 45));
   verifyFormat("Constructor() :\n"
)");
   verifyFormat(R"(//
 asm("cmoveq %1, %2, %[result]"
     : [result] "=r"(result)
     : "r"(test), "r"(new), "[result]"(old));
 )");
 
   // ASM symbolic names in inline ASM with no outputs.
   verifyFormat(R"(asm("mov %[e], %[d]" : : [d] "=rm"(d), [e] "rm"(*e));)");
 }
 
 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) {
   EXPECT_EQ(FormatStyle::LK_Cpp,
             guessLanguage("foo.h", "void f() {\n"
                                    "  asm (\"mov %[e], %[d]\"\n"
                                    "     : [d] \"=rm\" (d)\n"
                                    "       [e] \"rm\" (*e));\n"
                                    "}"));